Journey into Web Development

Spring Roo: Advanced Rendering

2012-08-15T22:29:00.000-07:00

Intro

Multipurpose World Navigator 3D (MWN3D)

MWN3D is a customization of the web application described at http://pragmatikroo.blogspot.com/2012/08/a-multipurpose-world-navigator-mwn.html. Where instead of loading the database repository with an specific content; the original rendering system has been replaced.

The original MWN uses flat maps systems like Goggle Maps for bringing the geographic system context. In the 3D version, the flat maps system has been substituted with an animated 3D World in rotation.

Basically, I am leveraging the great rendering capabilities of current browsers. Current browsers are using HTML5 canvas and WebGL for implementing outstanding Web 2.0 applications.

The functionality of the application is pretty much the same as its ancestor. The User locates Continents/Countries/Cities by selecting them in the treeview component on the side. MWN3D marks the selected object in the World in motion.

Potential Uses and Applicability

Global awareness systems
Global monitoring systems
Command and control systems
Games based on geography context

Next a video clip of the application is shown.

Video Gallery

Continents: red cubes, Countries: yellow cylinders and Cities: green spheres

Conclusion

Aligning best-of-breed technologies like Spring(Framework+Roo) with current advanced rendering capabilities of the browsers open the implementation of very interactive and real-time applications.
MWN3D uses the exceptional Three.js library for creating the 3D capabilities shown.

B. and 3D Roogards
jD

A Multipurpose World Navigator (MWN)

2012-08-04T22:40:00.002-07:00

Intro

MWN root level

MWN is a foundational prototype for implementing geography-context information systems.
It has an ample applicability across many areas of human activity.

MWN is a Java web application that uses a top-down approach for navigating the Continents, Countries and Cities of the World. It implements a treeview component that is populated on demand as the User visits a node. By selecting a Continent/Country/City node the application renders the correspondent geo-referenced map.

Precisely, this is this geographic context able to be customized for serving multiple purposes.
Areas of applicability are:

Education
Tourism
Sales
Planning

Just to mention a few.

In Education, would be a great tool for teaching kids about World concepts. The hierarchical structure of MWN would help them to visualize and understand the notions of Continents, Countries and Cities. MWN loaded with the appropriated data would be a great assistant for teaching and learning different World cultures. MWN great interactivity would help to keep students focused. This is a web application that can be deployed to a large number of Users. It has an excellent cost-effective escalation and is affordable to pretty much any education budget.

In Toursim, would be a great marketing tool by showing maps, images and facts for vacation destinations. MWN uses MongoDB document database and can be extend to handle any multimedia object.

In Sales, MWN could be loaded with real-time data from any corporation branch and provide sales status aggregated to different levels: Office, City, State, Country, etc. by virtue of the top-down structure. MWN can be extended with any custom analytics for supporting any business practice.

In Planning, loaded with demographics data MWN would be a great discovery tool for assisting the planning tasks.

MWN Technology Profile

Front-end

jQuery and jQuery components
Google Maps
JavaScript ( almost nothing)

Back-end

Spring Framework
MongoDB

Development environment and RAD tools

STS
Spring Roo

Next, I am showing screens shoots of MWN in action.

Gallery

Conclusion

MWN is a foundational web app that can easily be customized to support uses-cases that requires a geographic-context.
MWN technology used is flexible and be extended/customized on the front/back end.

B. and geographic-context Roogards
jD

Spring Roo: The war is over... jQuery won. How to adjust to the new reality

2012-07-16T14:59:00.001-07:00

Intro

This is a two purpose mini-article...

Purpose #1. To provide evidence that jQuery is the defacto RIA technology for pretty much all platforms. Particularly on the ecosystem where I work, Java and Java Web has turned the major well known established UI players in to legacy options.

Let's review the following table. The table is a compilation of the # jobs in the US IT market as today (7-15-12).

UI Technology	Total posted jobs
jQuery alone	4880
JSP alone	3025
With Java	1970
With .NET	1623
jQuery Mobile alone	1114
Flex alone	1074
With PHP	993
JSF alone	908
With Spring	821
Dojo alone	546
GWT alone	476
Y-UI alone	325
With Python	310
With Lamp	270
Ext-JS alone	228
Sencha alone	191
Phonegap alone	104

The thing is... jQuery is at the top; which is totally consistent to other indicators like: great activity in the jQuery development community, books, blogs and # tweets, etc.

Next, I will show you what I have done for getting ready my framework-of-choice: the Spring Framework, to work with jQuery.

My list of articles on jQuery and Spring Roo

Date	Description	Link
Feb 13 2011	Seminal article announcing that nowadays is a fact. jQuery got the heart and minds of web developers on all platforms	JSP is dead long live jQuery
Mar 11 2011	Experimenting with jQuery Mobile and Spring Roo in a non-invasive way.	Spring Roo goes Mobile
Mar 17 2011	A more formal PoC for using jQuery mobile and Spring Roo. This is time using a 300K employees database for performance verification.	jQuery and Java in the spot light
May 27 2011	Using plain Spring Web MVC and jQuery for emulating GWT look and feel.	Spring Roo: jQuery Web MVC View Composition
Oct 28 2011	This is an effort for moving WEB MVC-to-jQuery addon from PoC to full development project.	Spring Roo: Towards a lightweight, non-invasive WEB MVC-jQuery addons-lightweight-non.html
Oct 30 2011	Article shows how easy your web app can benefit from multiple themes available in jQuery UI	Spring Roo: Pick your theme for Halloween
Nov 5 2011	Article describes the project formalization for implementing an add-on for turning a WEB MVC app into a jQuery based.	CodeName: SYNERGY
Nov 24 2011	Synergy was extended using other best-of-breed jQuery components libraries.	Spring Roo: Totally Embracing the jQuery World
Nov 12 2011	SYNERGY brought a great number of programming opportunities for automatically creating the boiler plate code and perform behavior based on datatype.	Spring Roo: Synergy Automatic Datatype-Control Mapping
Dec 3 2011	Another jQuery library added to Synergy	Synergy: Unlimited RIA
Jun 5 2012	jQuery charting library used here in the context for Spring Integration	Spring Roo: Visual Eip
Jun 29 2012	jQuery Ajax is used for all the client-server side communication. Spring Roo generated code leveraged in a non-invasive way. Personally this is the the web app that I liked the most to implement(so far).	MongoDB Geospatial Perspective Version 1.1
Jul 12 2012	jQuery Ajax handles in very interactive way the retrieval of one or many documents based on QBE criteria. The repository is loaded with 1000,000 documents for performance verification.	Spring Roo: Anatomy of a Functional Data Grid

Conclusion

Conclusion: jQuery alone or co-exiting with other UI technologies has won the minds and hearts of the development community on all platforms.

Purpose #2
I am starting an R&D project called Hallelujah. Hallelujah is a tactical work on automatically turn or assist the conversion to jQuery of legacy applications based on JSF, Flex and GWT.

Let me know what you think about the Hallelujah initiative. Do you think is worthy?

B. Roogards
jD

Spring Roo: Anatomy of a Functional Data Grid

2012-07-12T18:25:00.000-07:00

Intro

Big Data Grid (1000,000! documents)

a) Multiple fields QBE incremental search sensible data types

b) Multiple headers column sort

c) Elapsed query time indicator

d) Number of records retrieved indicator

I am still working in the MongoDB, Spring (Data+Roo) subject. Developing -sexy, hopefully- showcases for my consulting work. I decided to implement more functionality on top my previous QBE showcase. The referred show case is here http://pragmatikroo.blogspot.com/2012/07/spring-roo-query-by-example.html.

In this iteration, I added Column Sorting (CS) across all the field in the UI. This is not the first time doing CS for Roo. The previous incarnation was reported here http://pragmatikroo.blogspot.com/2011/02/spring-roo-web-mvc-column-sorting.html.

Following, this is brief description of the UI. The QBE fields on the top are data type sensitive and allowing incremental search on each of them. The column headers are toggled buttons enabling ascending/descending sorting on the correspondent clicked header.

Next I am showing some moments of the UI in action...

Gallery

Fig above, shows a incremental searches in two fields and sorted by first name.

Previous result set sorted by birthday descending

Now ascending

Conclusions

The data grid UI resulted of the experienced is very efficient narrowing down in group of documents. Not to mention that the database holdings are one-million documents (1000,000) BIG DATA member.
Just adding exporting capabilities perform some QA work on it...
This is almost a product!!!

B. & humongous Roogards

Spring Roo: Query-By-Example

2012-07-06T07:36:00.001-07:00

Intro

Grid View populated with 1000,000 documents!

A little bit of context first...
This is a mini-article; part of the Developing MongoDB Perspectives using Spring Roo suite. It is the one dedicated to traditional or typical web enterprise requirement for databases.

Some of these requirements are:

Smoothly navigate a grid with thousand of records
Enable column sorting
Incremental search
Master-detail
File uploads

I wanted to try with MongoDB the experience for fulling such requirements. For such purpose, I created a use case that includes a grid UI and a document database with one-million- records (1000,000).

Now, Imagine you need to retrieve one particular document from the database. May be you need to retrieve only the ones that are active or all the males which where hired in a particular date range.

In addition, you have to enable it in a user-friendly manner, with a intuitive UI that any User can work with.

I believe an efficient way to accomplish it is by using Query-by-Example or QBE.

Next, in the gallery section I am showing screen shots about MongoDB-QBE in action:

Gallery

Lets warm up MongoDB-QBE retrieving all the employees whose first name starts with an "M"... Fig #1, shows it.

Fig. #1 First name lookup View

Fig.#2 Incremental seach view

Narrow down a little bit more adding an "a" or "Ma". Resulted record set shown in fig # 2.

Fig.# 3 Two fields conjunction view

Fig. #4 I retrieved myself too! (Eating my dog food, Yuck!)

Now, you are interested on females only, from the previous search, as shown in fig. #3. Fig. # 4 is self explanatory. Views include total records retrieved and actual query times.

Conclusion

I am surprised with the preliminary retrieving times got. They are pretty good out of the bat for a million documents db; without any optimization effort.

I think... I believe... the RDBMS establishment will face a humongous challenge pretty-pretty soon. You know what I mean, right?

Attribution notice: I used data coming the employees db for creating the 1000,000 repository referred in this article. Employees db @ http://dev.mysql.com/doc/employee/en/employees-license.html

B. Roogards
jD

MongoDB Geospatial Perspective Version 1.1

2012-06-29T21:03:00.000-07:00

Fig.# 1Boxed-area retrieval enabled version 1.1

Fig. # 2 Circled-area retrieval since 1.0

Intro

News. Version 1.1 includes boxed-area retrieval capabilities and quick Country look up enabled.

This is the Perspective for the characterization of relevant geo-spatial MongoDB capabilities. This Spring Roo implemented web app. shown utilizes a MongoDB collection with more than 10k geo-located World cities.

On top of the automatically source code created by Spring Roo, I implemented an incremental look-up control for quickly find the required city. Then after, the selected city is depicted on a map. MongoDB geo-spatial superior query capabilities are used for retrieving all cities in a circle around the found original city.

Next some images are shown with the Perspective in action...

Gallery

Fig. #1 Country look up in action!

Fig. #2 City look up in action!

Fig. #4 Dynamic Cities Retrieval Area based

Fig. #3 Selected City View

Fig# 5. View centered on Valencia, Spain

Fig.#6 View centered on Philadelphia, USA

Fig#. 8 View centered PHX, USA

Fig#.7 View centered on Berlin, Germany

Conclusion

I am very-very pleased with all the learned experiences gathered by implementing this Perspective.

It is the kind-of showcase great for stressing the server and client side, memory allocation/de-allocation and User interactivity.

MongoDB is humongous effective, humongous powerful and a humongous fun NoSQL DB to work with.

Smoothy navigating grids with ten-of-thousands of records -documents in MongoDB world-, flashy look-up components and real-time retrieving data for rendering images are truly real-world Java Enterprise requirements.

If I tell you how long did it take me to implement this puppy... You won't believe me.

Well... I think... I believe... Spring Roo is a fantastic RAD application tool. What you think?

BTW don't miss the other MongoDB Perspectives.

B. and Geo-spatial Roogards
jD

Developing MongoDB Perspectives using Spring Roo

2012-06-29T12:20:00.000-07:00

Global Intro

This is a multifaceted article that introduces a variety of showcases using MongoDB. MongoDB is NoSQL document database and the featured technology for this suite of articles. I am using MongoDB, altogether with the correspondent Spring Data and Spring Roo.

Bottom line, I would like to investigate strategies for releasing real-world Java Enterprise applications on a very short time-to-market using Spring ROO rapid-application-development capabilities.

I am not interested in implementing CRUD or tinker-toy kind-of web apps. I want to implement showcases that really addresses real-world development expectations.

For this purpose, I am introducing this notion of a "Perspective", to emphasize a relevant MongoDB feature connected with a typical real-world web development requirement. So, the purpose of is to extended what is created by Spring Roo for including the requirement.

Each Perspective is having their own article, where I am describing the details of it. This is an incremental approach that would allow me to release each show case independently.

Next I will show the Perspective list and its link.

Perspectives Gallery

Perspective Name	Summary	Link
Geo-spatial	Showcase that uses a MondbDB collection with more than 10k geo-located World cities. It implements a fast incremental search for city selection. The found city is rendered on a map. The UI provides controls for dynamically retrieve more than 10,000 World cities around a circular area on different radius lengths. Update version 1.1 added fast incremental Country location and boxed area cities retrieval.	Mongo Geospatial Prespective
Traditional DB Use Case I	Using a 300k documents -previously known as records- the show case render basic operations on a grid. This results are relevant since show up the details about loading a collection with legacy data. Grid navigation performance is measured.	TBD
Traditional DB Use Case II	The previous use case was scaled to one million (1000,000) documents. A Query-by-Example UI is implementing for testing Human interaction with BIG DATAGRID CRUD operations.	http://pragmatikroo.blogspot.com/2012/07/spring-roo-query-by-example.html
Anatomy of a Functional Data Grid Intro	This is an R&D effort for implementing a functional real-world data grid off the CRUD code generate from Spring Roo. The web application is part of collection of showcases generating experiences on using MongoDB and Spring(Data+Roo). This particular showcase uses a one-million (1,000,000) documents MongoDB repository.	http://pragmatikroo.blogspot.com/2012/07/spring-roo-anatomy-of-functional-data.html
Multimedia Document Manager	This Perspective leverages previous incarnations of document managers presented in the site. GridFS is used for handing BIG DATA approach.	TBD
Map-Reduce	TBD	TBD

Conclusions

This a moving target so right now I referred the Reader to the specific conclusion at the end of each Perspective.

Spring Roo going forward...

2012-06-19T22:44:00.001-07:00

Intro
This is a thread name in the Spring Roo Forum...

As many of my blog posts, this one started by colleague Developers questions, interested in SR.
In other to get the whole context the about it; the Reader is referred to the actual thread located at http://forum.springsource.org/showthread.php?127143-Spring-Roo-going-forward.

The thread is quite interesting and gave me the opportunity of making my points on what is needed for "going forward" with SR. BTW. I post in the forum with the username delgad9.

At one point, I made my proposals and the exchange with my fellow Developer stopped. However another exchange started -motivated by the same Forum thread- behind the scene.

Basically, the value of this second exchange; it is the recognition of the baseline of real-world requirements that a Java Web Developer is expecting from SR for considering it a successful development tool.

I can't tell you "the laundry list" that was poured on me. Literally the kitchen sink of real-world requirements was thrown on this developer. I went through the list and I realize that I have done quite a few already; cool:). However, I got nervous about a particular requirement; that happens I never tried before. Not standalone and not with SR. The requirement is to use SR together with MongoDB.

Well, here I am after not really long time -literally few hours, introducing a pure-breed-state-of-art-java-web-app-based-on-SR-and-MongoDB.

Right now the app is using the Web MVC look and feel. However is totally CRUD functional* and is loaded with Mongo database with more than 300,000 records. Just to make sure the the grids are rendering with good performance. The expectation/requirement is to dress the app up with a full-blown jQuery RIA UI. I think, I can handle this part of the referred list by leveraging the experience provided by creating the Synergy add-on. For information about Synergy @ http://pragmatikroo.blogspot.com/2011/11/spring-roo-totally-embracing-jquery.html

Gallery

MongoDB List View

Mongo Admin Console

Conclusion

This new project re-validates my believes about SR and really might show EVERYBODY watching WHAT IS REALLY MISSING. Did you get it?

On the other hand; I invite my fellow Java Web Developers interested in the "SR going forward wave" to write to me your comments and ideas on how to make SR more successful.

Thank you and B. Roogards
jD
*Obviously, the app hasn't passed any QA effort at this point. It is just a foundational prototype for a potential second stage down the road.

Spring Roo: Visual Eip

2012-06-05T00:08:00.001-07:00

Intro


Fig #1. Show case EIP test bed.

Humans are visual animals...
This is why the possibility of creating a visual context for solutions for the Java Enterprise Ecosystem is special important to me. In this blog, I would like to introduce a solution for visualizing the dynamics of a Enterprise Integration Pattern (EIP) using Spring Integration and Spring Roo.

Typically the examples and tutorials about EIP, shown results as a bunch of logging outputs on console screens. Many times is this really complicated to understand. On the other hand, by visualizing the interactions through the a EIP workflow you can really have a grasp of the components functionality and its purpose.

The workflow shown above, fig #1, has an intentionally connection with a physical domain. It uses notions taken from Electrical Engineering and Electronics. I am using an Spring Integration EIP workflow for going through the dynamics of generating-transforming-charting mathematical functions. The referred mathematical functions are used as messages payloads flowing through the integration solution.

The description of the integration is pretty simple:

A "signal generator" is enabled using an inbound-channel-adapter Spring Integration component. The solution is capable of remotely switching several functions using a Spring Roo Web app.
The signal generator is channeled with a publish-subscribe-channel component to a battery of transformers endpoints.
Each transformer endpoint applies a real-time linear math operation coming from the generator.
A battery of service-activator components collect the transformed signals.
Finally the web tier consolidates all the output signals and prepare them for JSON serialization.
The Spring Roo UI renders a chart with all the signals coming out from the integration.

The functions used as payload messages are the following:

y = x
y = x * x
y = x * x * x
y = sin( x )
y = cos( x )
y = sign( x )

The operations applied by the transformation components are:

Identity: x = x
Reflection: x = -x
Doubled: x = 2 * x
Divided by 2: x = x/2

Following I'll show some screen shoots coming from the actual application.

Gallery

Sample signals coming out from the signal generator

Fig #2. Signal generator functions.

Fig #3. Sample of signal generator function: Sin( X ).

Fig #4. Sample of signal generator function: Sign( X).

Fig #5. Sample of signal generator function: X^2

Pristine sample signals together with their reflected counterpart.

Fig #6. Original sin( x ) signal and its reflection

Fig #7. Original cox( x ) signal and its reflection

Fig #8. Original x^2 signal and its reflection

Original and all transformed signals rendered in the same chart

Fig #9. All signum( x ) signals fanned out for charting together

Fig #10. All sin( x ) signals fanned out for charting together

Fig #11. All x^3 signals fanned out for charting together

Conclusion

This blog introduces a visual integration workflow for showing the behavior of components in the Spring Integration framework. It uses simple mathematical functions as payload messages for transversing a transformational workflow.
Currently an ad-hoc consolidation mechanism is used for combining all the signals in the web tier prior to being responded and charted in the client UI. I believe this work should be better done by using the aggregator component; that I plan it to use in a next iteration.

Last but not least. The charts shown were easily created by using a powerful Javascript library based on jQuery named jqPlot. I like the fact that jqPlot integrates very easy with Spring Roo.

Spring Roo: XML DetoX

2012-05-12T23:59:00.000-07:00

Intro

I've been long enough working with the Java Programming language and web development to see the raise and fall of several technologies around it.

I've been in the raise and fall of Corba, the raise and fall of EJB 1.0 to EJB 2.1. There are other technologies that have experienced same phenomenon too, but I would like to focus on what I believe we are experiencing right now: the fall in the web container and application server arena of XML for configuration metadata.

Raise and fall are only rhetorical descriptions of different technology moments. A technology raised when at one point became very hot and got the attention of the development community in a very intense way. The fall happened when the technology is replaced, because it has shown several drawbacks that questioned its practice in first place.

Prior to version 2.5, XML was de facto and de jure the only way for configuring a web application inside a web container with the Spring Framework. Same practice occurred with other popular Open Source technologies like Hibernate and J2EE.

To stay aligned with the trends and by using the new features enabled in the Spring Framework 3.X, I decided to replace the Spring Roo typical XML based Web MVC configuration for a XML-free based on Java configuration only. The cornerstone of the Java configuration is the @Configuration annotation introduced in version 3.0.

Next, I show a mini plan that I used for converting an XML Spring Roo Web MVC web app into a XML-free configuration:

Modify pom.xml file for including Servlet 3.0 api
Remove all filters and servlets in web.xml and rewrite them as @Bean methods in @Configuration qualified class extended with WebMvcConfigurerAdapter.
Replace all the functionality in webmvc-config.xml and applicationContext.xml
Enable an entityManagerFactory bean XML-free so we can remove the persistence.xml file.

Gallery

<?xml version="1.0"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee web-app_3_0.xsd"
          version="3.0">

</web-app>

Fig 1. This is the actual content left of web.xml file, after moving the configuration to a Java-annotation based*. Conclusion

The standard practice for using XML for describing metadata for web applications configuration is quickly being replaced by annotations. Annotations has proven being more effective than XML for metadata descriptions. XML ended to be extremely verbose and tedious. This blog article reports the steps used for reimplementing the typical Spring Roo Web MVC configuration -based on XML- with an equivalent based on annotations. Enabled this configuration is fundamental for my next Spring Roo RnD work.

B. Roogards
jD

*You can remove this file too.

Spring Roo: Instrument This

2012-05-02T17:22:00.000-07:00

Intro

Java Web Development is hard...
Ideally you have to meet or exceed User's expectations, finish on time or sooner, create performant and reusable applications and help or make sure that your project budget doesn't get overruned.

As a Java developer, I've tried to live with these standards. I believe mostly to the effectiveness of the Java Programming language, I've been able to deliver Java Web applications or contribute to them in that way.

Sometimes I've been involved in fixing projects with deficiencies; e.g. they are slow, throwing fatal exceptions, starving memory to the point of resource exhaustion just to mention a few. And the thing is no one in the office knows how this happened.

These projects are fascinating, indeed. You have to deal with thousands of lines of code, that most of the time are undocumented, I don't think documentation would help at this point anyway.

One of the tools that always-always has helped me out on finding the culprit issue(s) is Java VisualVM (VVM). This is an awesome monitoring-profiling-debugging -to mention a some of it uses- tool. that is currently included in JDK 1.6. distribution!.

As mentioned before, there are many facets about VVM. Here, I want to bring to the Reader attention how easy is to use it -for monitoring purposes- on top of the automatic CRUD code generated by Spring Roo.

I'll use the well known Petclinic sample to show it.

Let's say, that we are interested in knowing real time number of records of a particular table in a Spring Roo Web app. In case of the Petclinic web app, we would like to know how many pets, vets, owner and visits are in the database. For the Pets entity just modify the code as shown.

package com.springsource.petclinic.web;

@RequestMapping("/pets")
@Controller
@RooWebScaffold(path = "pets", formBackingObject = Pet.class)
@RooWebFinder
public class PetController {
     public long getTotalOfPets(){
        return Pet.countPets();
    }
}

Proceed the same way with the other entities. Next, stick the following declarative code into webmvc-config.xml file.

<bean id="jmxViewer" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
             <map>
                 <entry key="bean:name=petControllerView" value-ref="petController"/>
                 <entry key="bean:name=ownerControllerView" value-ref="ownerController"/>
                 <entry key="bean:name=vetControllerView" value-ref="vetController"/>
                 <entry key="bean:name=vistControllerView" value-ref="visitController"/>
             </map>
        </property>
     </bean>

Deploy the web app to tc Server using STS ide. Lunch the petclinic app and VVM.

The screen in the gallery section is showing the # of records of the referred entities using VVM.

Gallery

Conclusion

This basic tutorial just scratches the surfaces of the critical multifaceted topic of Instrumentation. I promise to come back with more cases -of course with Spring Roo- in the near future.

Database Composition Web Apps

2012-03-26T21:02:00.001-07:00

Intro

It started as most of my blog articles... with a question posted in the Spring Roo Forum. I like resolving questions coming from developer colleagues posted in the forum, since they represent real world development issues or problems to solve. Most of the time they are very-very interesting to solve.

I've been trying to differentiate myself from other blog writers interested in Spring Roo in targeting problems without or hard to find solution(s). The purpose is to complement the majority of "getting started", "basic blog/tutorials" and "books" currently available with intermediate and advanced topics about it.

This time the question posted is on how to reverse engineer 2 mysql databases?. As the Roo developer knows, the tool comes with DBRE. DBRE is a very convenient DB reverse engineer tool. As it is incarnated it only supports the reverse engineering of one database per web app. Which is useful for the majority of possible reverse engineering projects. With very exceptional situations when more than one db is required for being reversed at the same time. This is when this article pretends to be helpful.

When I thought a little more about it; I believe the question is more valuable, if it is positioned as on how to do database-composition-web-apps using Spring Roo. I mean, the creation of a web app, using one or more databases.

As this blog is showing it possible to create the referred applications by following these steps:

Create two Roo projects and reverse a db per project.
Merge relevant content: copy the entities files for one to the other. You can create a third project for merging them too.
Use my Two-Databases-Configuration* for accessing both dbs in the merged project.

Instead of reverse engineering hypothetical databases -since not needing to be explained, this step is straight forward and well documented in the Spring Roo User Manual- I decided to skip it and use two sample projects coming with the Spring Roo distribution.

In other words, I database-composed Wedding with Vote samples projects using the steps shown above. The final composed app does not make any sense at all!! but it is totally functional. It just for the purpose of implementing the show case.

Next, I show the Reader an screen shot from this very special Roo web app.

Gallery

View shows the final menu of the db composed web app

Conclusion

This blog shows how to do database composition web applications using Spring Roo. It uses baseline only features of the tool for accomplishing it.

B. Roogards
jD

*This is the link of my referred article:Spring Roo: Two Databases Configuration

Fixing SQL with NOSQL

2012-02-25T11:55:00.000-07:00

Intro
   There are some colleagues developers out there, struggling trying to make their legacy sql dbms to handle the way they want/need blob objects. For some reason blobs -which basically is just an array of bytes- are particularly complicated to work with on very popular-well-known- dbms. This issue got my attention and I wanted to do something about. Instead of dealing with it directly, I want to give it a twist of differentiation with a "work around" kind of solution. Besides, I don't know what else I could try in addition of the what the mentioned folks have unsuccessfully tried already and there are multiple SQL products showing the same issue. I want a generic solution that can be applied across to all SQL dbms.

All right, this is my solution: To use an associated NOSQL db for storing blob objects. In other words, to approach the legacy SQL blob issue with a CROSS STORE solution!.

The notion of cross storing a database is simple: to partially save fields of a schema in multiple repositories. But for the application and more importantly the business it is the same unified database.

    There is a visionary NOSQL product that fits perfectly for implementing my approach: this product is Neo4j working in conjunction with Spring Data.

    Neo4j provides an elegant -almost magic- way for enabling cross storing between a SQL product and a NOSQL db. In this case Neo4j Graph Database.

   I would like to mention of what I consider few benefits of this approach:

Generic. I can be applied to any legacy based application regardless the product name
Extremely lightweight and none invasive
Prepares legacy db for supporting social-media requirements

On the rest of the blog I will show some snapshots of a PoC for validating my point. I am using my Spring Roo Document Manager application referred at http://pragmatikroo.blogspot.com/2011/10/spring-roo-document-manager-based-on.html as a foundation for this cross storing implementation.

Gallery


Spring Roo Script

Populated SQL DB View

Populated List View

NOSQL view by Awesome! Neoclipse tool

Show View

Conclusion
This blog provides an approach for solving the weakness that some SQL implementation have for handling data-type BLOB objects using a cross store solution.
OK, what you think?, I am interested in your opinion about this blog, so feedback is always welcome!

B. Roogards
jD

Pivoting Tables using JPA

2012-01-23T11:37:00.011-07:00

Grid & Charts Main View

Intro

I decided to implement Grid & Charts by jD (GnC) as a show case for the Spring Roo Flex add-on a year ago. I wanted to create a web application showing the magnificent RIA capabilities provided by the Flex technology working in conjunction with a leader Java Web technology framework: the Spring framework and its RAD tool; Spring Roo.

Grids and Charts are UI elements used on web apps with very high data rendering and presentation richness expectation. Examples of such web apps are: Sales and marketing dashboards, Stocks market and reporting to mention only a few. GnC uses public data provided by the United Nations Statistics Division (UNSD); that implements dynamic views for the following Country indexes:

Global Economic Index	# Records in table
GDP at current prices (per capita)- US dollars	8712
GDP growth (annual %)	8418
Public expenditure on education as % of GDP	1138
Inflation, GDP deflator (annual %)	8071
Cash surplus/deficit (% of GDP)	1633
Military expenditure (% of GDP)	3494
Exports of goods and services (% of GDP)	7786
Imports of goods and services (% of GDP)	7616
Carbon dioxide emissions (CO2, kg CO2 per $1 GDP)	691

The Reader can visit GnC at link here. Click on the Analytics button on the per-year index page for rendering pivot table view.

Pivoting tables. Implementation details

I added an Analytics View to GnC web app. Basically I wanted to render a Counties vs. Year navigational grid view for a particular index. In order to provide the referred view, I have to pivot the table since the original structure is like this:

CREATE TABLE IF NOT EXISTS `gdp` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`Country` varchar(30) DEFAULT NULL,
`Year` varchar(30) DEFAULT NULL,
`Item` varchar(30) DEFAULT NULL,
`Value` float DEFAULT NULL,
`version` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

JPA does not provide a method for pivoting tables directly. However it provides all the elements for easily and quickly pivot them. Following I am showing the steps for creating a pivoted table using JPA:

Created a class that generates SQL code for aggregating and index per year and grouped by country. Below a generated sql statement is show as an example.
Populated of entities on execution of point referred before
Returned pivoted result set based on page parameters

select id, country,
sum( if(year='1970',round(value,2), null)) as 'y1970',
sum( if(year='1971',round(value,2), null)) as 'y1971',
sum( if(year='1972',round(value,2), null)) as 'y1972',
sum( if(year='1973',round(value,2), null)) as 'y1973',
sum( if(year='1974',round(value,2), null)) as 'y1974',
sum( if(year='1975',round(value,2), null)) as 'y1975',
sum( if(year='1976',round(value,2), null)) as 'y1976',
sum( if(year='1977',round(value,2), null)) as 'y1977',
sum( if(year='1978',round(value,2), null)) as 'y1978',
sum( if(year='1979',round(value,2), null)) as 'y1979',
sum( if(year='1980',round(value,2), null)) as 'y1980',
sum( if(year='1981',round(value,2), null)) as 'y1981',
sum( if(year='1982',round(value,2), null)) as 'y1982',
sum( if(year='1983',round(value,2), null)) as 'y1983',
sum( if(year='1984',round(value,2), null)) as 'y1984',
sum( if(year='1985',round(value,2), null)) as 'y1985',
sum( if(year='1986',round(value,2), null)) as 'y1986',
sum( if(year='1987',round(value,2), null)) as 'y1987',
sum( if(year='1988',round(value,2), null)) as 'y1988',
sum( if(year='1989',round(value,2), null)) as 'y1989',
sum( if(year='1990',round(value,2), null)) as 'y1990',
sum( if(year='1991',round(value,2), null)) as 'y1991',
sum( if(year='1992',round(value,2), null)) as 'y1992',
sum( if(year='1993',round(value,2), null)) as 'y1993',
sum( if(year='1994',round(value,2), null)) as 'y1994',
sum( if(year='1995',round(value,2), null)) as 'y1995',
sum( if(year='1996',round(value,2), null)) as 'y1996',
sum( if(year='1997',round(value,2), null)) as 'y1997',
sum( if(year='1998',round(value,2), null)) as 'y1998',
sum( if(year='1999',round(value,2), null)) as 'y1999',
sum( if(year='2000',round(value,2), null)) as 'y2000',
sum( if(year='2001',round(value,2), null)) as 'y2001',
sum( if(year='2002',round(value,2), null)) as 'y2002',
sum( if(year='2003',round(value,2), null)) as 'y2003',
sum( if(year='2004',round(value,2), null)) as 'y2004',
sum( if(year='2005',round(value,2), null)) as 'y2005',
sum( if(year='2006',round(value,2), null)) as 'y2006',
sum( if(year='2007',round(value,2), null)) as 'y2007',
sum( if(year='2008',round(value,2), null)) as 'y2008'
from gdp group by country
order by country

Automatic generated code for pivoting the GDP table

GNP View (Pivoted GNP table)

Conclusion

This blog shows an implementation for pivot tables using JPA. I am leaving for a another time the creation of the pivoted entities classes programatically. Right now I entered them manually. I have the intention of recreating GnC replacing Flex with jQuery in the near future. So, stated tuned to this blog in cases of interested on the topic

Thank you for reading

The Play Framework: First Impressions

2012-01-12T16:00:00.005-07:00

Intro

Recently the Play framework (PF) has been mentioned in the Spring Roo forum as a better web development framework/tool to Spring/Spring Roo. So, I decided to do some "Findings work" looking to learn what PF is bringing to the Java Web Development table.

Initial Discoveries

From the architectural point of view PF is just another incarnation of the MVC pattern. PF is Java framework but it seems that it uses Scala as well -which by the way, is another Java programming derivative too- specialized on Web development targeting RESTful architectures.

PF considers itself as a "clean alternative to bloated enterprise Java stack" and brings its own implementations for replacing traditional J2EE and JEE web apis. A very important differentiator is that PF is not using The Java Servlet API. PF instead implements is own web server container.

I wanted to review the jar files used PF and downloaded it. The following group of jars files a part of PF distribution:.

The Reader can see that basically PF is using pretty much the same jars that other bloated Java based MVC are using. An interesting point is that fact that the "geronimo-servlet_2.5_spec-1.2.jar" -which is the servlet framework- is included in the directory, since PF allow to deploy to regular Java web servers.

The RESTful approach does not allow keeping state on the server side. So the session state is kept using an encrypted cookie on the client side. There are situations when the state must be stored on the server side for those cases, PF uses memcached framework, an open source object caching system

Tools and Development Cycle

PF uses a Python based shell for development. Nothing more than a text editor is required for entering code. The shell provides typical commands for creating, executing, deploying, etc

After creating a new app -which requires just one command line- the new application is ready for deploying and executing. The developer enters code using the mentioned editor and the PF web server automatically complies the new code. The changes done appears almost instantly reflected by refreshing the page under development.

Server-Side Development

PF pretty much uses popular Java persistence APIs, like JPA and Hibernate. It includes is own module for supporting CRUD type of implementations.

Client-Side Development

PF has totally embrace jQuery as a driving force on the client side, together with JSON. These two pieces of technology offer a modern, lightweight, Web 2.0, RIA effective web development

Preliminary Conclusions

These are a lot of features of PF that I like;

It brings is a refreshing pragmatic approach to the Java Web Development
Embraces RESTful approach as main stage technology
Elegant and simple client side development 100% jQuery. I am very glad that finally someone in the Java Web frameworks/tools development world is leveraging jQuery. I noticed that jQuery would have a tremendous impact on UI development, regardless the platform. I wrote about it and published a blog here Jsp is Dead. Long live jQuery. At the same time, I did R&D that culminated on the creation of SYNERGY: an add-on for enabling jQuery into WEB MVC for Spring Roo. For more info on Syngery please visit here Synergy: An Effective Java Web Development Approach
The interactivity and instant feedback writing code is very effective and fun

But the Devil is in the details. There are bunch of things that I would like to investigate on PF, before closing on final conclusions.

PF uses Reflection a lot. Inherently heavy weight Reflection, could be a performance issue for enterprise web apps.
Keeping the state on the client size, open issues that need to be investigated on performance and security to mention a few only.
PF depends totally on Developer "muscle" and a "text editor" for entering code. This could be an issue for some developers so used to fancy IDEs.
Deployment and performance on typical web server or J2EE/JEE app server requires characterization.
I think PF brings innovation to the Java Web Development not because implements MVC again, but because allows a very interactive way of web development.

The Play Framework!... Simple but not Simpler. I believe is for Real!

Beyond CRUD: jD Spring Roo Articles, Videos and Live Demos

2011-12-13T10:01:00.008-07:00

New links included as 5/5/2012!

Customizing Web MVC UI Forms
How to implement Master/Detail Forms

Saving/Retreving BLOB object in Spring Roo aka. FileUpload

Viral Patel

Two Databases Configuration

Synergy: Unlimited RIA

2011-12-03T15:01:00.000-07:00

Intro

Built using Spring Roo great foundation. Synergy -currently under development- is the add-on that turns a Roo WEB MVC app into a RIA jQuery based. Synergy is lightweight, totally non-invasive and integrates with many of the most relevant jQuery frameworks available these days.

Precisely, this blog reports the integration -into SR- of another really-great jQuery-based widgets library: Wijmo for the Web. Visit Wijmo website at Wijmo here. Wijmo is a complete kit of over 30 UI widgets with everything from interactive menus to rich charts. Wijmo operates with two type of licenses based on the product-type. Again for details on it, visit their website.

I think, Wijmo is really an outstanding product. It is an elegant and concise widget library that uses the latest and greatest of jQuery technology.

Now with Wijmo in its "belt", this the list of jQuery libraries and frameworks that Synergy integrates with:

Wijmo for the Web
Kendo UI
jQuery UI
jqGrid
jQuery Mobile

Next, I am showing screen shots of Pet clinic web app using Synergy-Wijmo on different browsers. I think you are going to like them:

Gallery

Synergy on Opera

Synergy on Chrome

Synergy on IE9

Synergy on FireFox

Synergy on Safari

Conclusion

I can't believe it... every time I finish something on jQuery and raise my head. There is something new that gets my attention and want/need to integrate it to SR. All right, just line them up. I am going for all!

B. Unlimited jQuery-RIA Roograds
jD

Spring Roo: Totally Embracing the jQuery World

2011-11-24T22:46:00.000-07:00

Intro

A good way of verifying how popular is anything these days... the same is for a rock star or a technology. It is to look the number of tweets the topic is getting per unit of time. The rate at what jQuery is getting tweets is impressive!. This is just a reflex of how successfully jQuery has conquered the heart and minds of the web development community. I mean the web development community across many platforms.

While working on the integration of jqGrid -a powerful jQuery grid component- into Synergy -Synergy is a Spring Roo add-on for turning Spring Roo WEB MVC into RIA jQuery based-, I wanted to verify whether or not my implementation/programming decisions made so far, would allow to smoothly integrate other jQuery components or libraries, down the road.

This is when, Kendo UI got my attention. Kendo is not just one jQuery component... it is a complete framework that includes a very-very nice suite of widgets. Kendo UI is a commercial product that comes with a license agreement. For more information visit Kendo UI website at Kendo UI.

It was easy to retrofit my previous integrations to work with Kendo UI. Next is the list of jQuery libraries/components, Synergy integrates with:

Kendo UI
jQuery UI
jqGrid
jQuery Mobile

Screen shoots of a Spring Roo web app using the Kendo UI integration are shown below:

Gallery

Kendo UI menu-accordion in action

Kendo UI grid in action

Kendo UI menu-according and grid in action

Switching to horizontal menus is a "one-liner" with Synergy and Kendo UI

Conclusion

Straightforward, lightweight, non-invasive, sexy, performant, cost-effective, easy-to-maintain. This all is Synergy, the Spring Roo addon for turning WEB MVC jsp(x)-based web apps into jQuery-RIA based.

Syngery... way to go.

Roogards
jD

Spring Roo: Synergy Mobile

2011-11-16T09:21:00.000-07:00

Intro

I just want to make the point that with Synergy -the Spring Roo (in the works) add-on for generating RIA web applications for WEB-MVC- you can do Mobile web applications too.

Inclusive you can deploy the same middle/back-end tiers for serving all kind of different devices. This approach saves money in development, saves money in maintenance and saves money in production!.

More information on Synergy mobile on following links

Gallery

Conclusion

Before deploying to Cloud Foundry you need the application completed. Right?. You can get it really fast and nice with Synergy

B. Roogards
jD

Synergy: An Effective Java Web Development Approach

2011-11-14T11:11:00.000-07:00

Intro

Synergy is a Spring Roo add-on -in the works- that will allow to convert typical WEB-MVC app into RIA-jQuery based automatically.

The Reader interested in knowing more about Synergy can visit the following links

This time, I worked on cosmetics stuff and I have screen shots to share with you:

Gallery

Big Announcement

I think, I could have the first cut of Synergy in New Years Eve -2011 of course. You might be interested on using Synergy. I addition of creating a 100% functional web application using the Best-of-Breed on the Java technology on the server-side and jQuery in the client-side. You can learn tons of stuff by studying the code as well and-and deploy it to CLOUD Foundry if you want!. So, if interested send me a message using the comments section. It will work with Spring Roo version 1.1.5.RELEASE.

I bet you... You don't want to miss out this opportunity

B. Roogards
jD

Spring Roo: Synergy Automatic Datatype-Control Mapping

2011-11-12T00:06:00.000-07:00

Intro

This is just a brief post for showing the automatic datatype-control mapping built in Synergy. Synergy is the codename of a Web MVC-to-jQuery Spring Roo addon, that will allow to convert a "traditional" jspx web app into a RIA jQuery based automatically.

Synergy integrates a great-great open source jQuery grid component: The jQuery Grid plugin with Spring Roo. Both are best-of-breed technologies with great potential of delivering rich and high performance applications in the Java Web development ecosystem.

Next, I will show you screen shots of the Synergy mapping capabilities for mapping datatypes. e.g. String, Boolean, Date, enums, etc. to HTML controls e.g. text, checkbox, datepicker jQuery control, selects and so. Likewise, I show you the wired-up of the grid control with the validation back end. Which is based on JSR 303. All of it is done automatic by Synergy.

Gallery

1) Tabbed Menu
2) Automatic HTML rendering controls based associated datatype
3) Native Navigation jQuery Grid Pluging component
4) jQuery Theme Roller
5) One-to-Many relationship via links
6) Native jQuery Grid Pluging pager

1) CRUD using modal views
2) CRUD automatic HTML rendering controls based associated data types

1) JSR 303 server-side validation integrated
2) Datepicker control automatically rendered based on associated date types

Conclusion

Ok... I just have time for grabbing more pizza and reload my 2 liters Mounting Dew jar.

Hasta la Roograds!
jD

What is in the Spring Roo Developer's Mind

2011-11-09T22:52:00.000-07:00

Intro

Basically, I am inferring what is Spring Roo developers mind by the Google searches that hit my blog-articles. Obviously this is just a fragment of the what developers working with SR "Google" everyday. However, I believe has considerable value because shows specific topics or areas of interest of the community.

I started working with SR - at that time on version 1.1.0.M1- on May 2010. By the end of the year I was able to deploy two mid-size web applications. My first SR is World Almanac by jD. World Almanac is an example of Spring framework WEB MVC touring experience involving many of the technologies included with Spring Roo and implementing many of the typical requirements in real world production web app. It is main purpose is to build a complete web app starting it from scratch. I wanted to know what is involved in turning the CRUD source code delivered by Roo into a production site.

My second Roo web app is Grid-and-Charts. I wanted to experience the Flex add-on. This one was little problematic due the lack of continuity on the production of referred add-on at time. However I was able to manage its completion and deployment. The Reader can visit both live-demos at:

At the same time, I registered and participated on different Spring Roo community forums. I realized that many of the issues asking for help by the community are the ones I had to solved while implementing World Almanac and Grid-N-Charts.

Some examples of the questions I am referring to are: How to's for implementing 1) Master/Detail view, 2) How to change menus, 3) How to implement file-upload, 4) How to do column sorting, 5) How to use jQuery with Spring and others.

With source code and experiences for publishing a book on real world java web development using Spring Roo. I stared making technical posts regularly. I posted my first four (4) articles on someone else blog site; since I didn't have one.

Based on the # number of page views these articles are done pretty well and helped a lot of Spring Roo developers out there. These are the stats up to today

Article Name	Published Date	# of Pagevies
Spring Roo: Customizing Web MVC UI Forms	2/7/2011	11,259
Spring Roo: Saving/Retreving BLOB object	2/1/2011	7,606
How to implement Master/Detail forms using Spring Roo	1/31/2011	6,560
Spring Roo: Two Databases Configuration	1/27/2011	5,964

I created my own blog HERE. Thank you very much to Google. The screen shoot below, shows the interests of the SR community based on the articles reviewd.

Straight from the source. What is Spring Roo community interests!

Conclusion

I have published 29 articles on Spring Roo so far. All they touches some relevant aspect of this great development tool. I believe, I have enough material for 3 books on the following topic:

Spring Roo WEB MVC. Turn your Scaffold CRUD app into a production app
Spring Roo jQuery Mobile web development
Spring Roo jQuery RIA web development with WEB MVC-to-jQuery addon

I have already in-roaded NOSQL -specially Neo4j- and Social Network that will be next

B. Roogards
jD

CodeName: SYNERGY

2011-11-05T16:28:00.000-07:00

Intro
SYNERGY
n., pl., -gies.

The interaction of two or more agents or forces so that their combined effect is greater than the sum of their individual effects.
Synergy is created when things work in concert together to create an outcome that is in some way of more value than the total of what the individual inputs is.

[From Greek sunergiā, cooperation, from sunergos, working together.]

I could not find a better concept/word that describes the result delivered for using jQuery and Spring Roo together. This is a tremendous web development proposition; where you have two of the best-of-breed technologies collaborating with their strengths: jQuery in the client-side; Spring Roo in the server-side.

In other to leverage this great potentials; we just need a rendezvous point. Precisely this is where "SYNERGY" -the Web MVC-to-jQuery add-on- appears in the picture.

The Reader is referred to spring-roo-towards-lightweight-non.html and jsp-is-dead-long-live-jquery.html for more information about this project.

I've been moving on implementing the road map of Synergy. This is milestone#2 and there are the deliverable:

Milestone #2

Automatic grid-view generation
CRUD-capable grid-view type
Client-side validation
Server-side using standard Spring Roo native JSR 303 validation

Features to implement in next milestones

In-grid multicolumn search
In-grid multicolumn sort
In-grid autocomplete
Add-on implementaion
All levels QA

Gallery

Conclusion

jQuery and jQuery components integration into Spring Roo has been remarkable non-invasive and lightweight so far. This is very-very good, since maintaining the add-on source code and keeping up to date would be very-very cost-effective. The prototype implementing the Petclinic sample uses a database with 100K records per table is showing pretty good performance. I will continue next phase of implementation NOW.

IMPORTANT: If you want to be part of the WEB MVC-to-jQuery add-on development and have access to it. Post a message using the comment section.

Have a Roonergetic Roogards

Spring Roo: Pick your theme for Halloween

2011-10-30T23:15:00.000-07:00

Intro

Frankly, I had a different Roo topic for a Halloween 2011 post...

I ran out of time for it; but I found a great replacement and is totally consistent with my most recent post about my WEB-MVC to jQuery add-on. The Reader can find more information about it by clicking on the following links:

Since, I already have jQuery library in my Spring Roo project, thanks to my POC addon. I can easily include any of the multiple jQuery resources available out there. Yes, and guess what?, every day are more-and-more-and-more!.

The resource, I am including is a jQuery Theme Roller switcher. A powerful but intuitive component that allows a Spring Roo web application to choose from multiple predefined UI themes and instantly applied to the UI. Very Cool, right?. jQuery Theme Roller allows to create custom UI themes as well.

I installed the switcher on the addon's milestone #1 project -which uses Petclinic sample- and created screen shoots and I want to share with you in the gallery section below

Gallery

View to applied jQuery Roller switcher

Screen shoot shows the Theme Roller activated

View instantly reflects the new UI lightness context working. Sweet!

Another example of UI switched on-the-fly

Another example of UI switched on-the-fly
Conclusion

Yes, I know what are you thinking right know... This is foundational for a Users Preferences Module for Spring Roo Web apps. I believe you are right!.

There is some clash between CSS stuff that I will take care down the road.

Treat or Trick?. Have a happy Roolloween!

IMPORTANT: If you want to be part of the WEB MVC-to-jQuery add-on development and have access to it. Post a message using the comment section.

B. Roogards jD

Spring Roo: Towards a lightweight, non-invasive WEB MVC-jQuery addon

2011-10-28T13:04:00.000-07:00

Intro

This mini-blog article reports the second milestone pursing the implementation of Spring Roo addon; an add-on that would automatically turn a "traditional" WEB MVC web application into a RIA jQuery based. The proof-of-concept PoC described in PoC link, has proven to be a solid foundation for keep building on top of it. Despite the fact that, I need to find a replacement for an important jQuery component that unfortunately has stopped its development.

Succinctly, The PoC allows the following features to any Spring Roo Web MVC app.

Installed jQuery libraries in an harmonious way with the other existent JavaScript libraries
Introduced tabbed menus
Introduced modal forms on certain views
Implemented a functional add-on
Addon creates working web apps
Just a PoC not QA tested

Milestone #1

On top of the PoC functionality, milestone #1, integrates a remarkable powerful grid component for replacing the WEB MVC grids scaffolded by Roo. The component is the jQuery Grid Plugin.

I used the Petclinic sample and the database used in the use case described in database holds more the 100k rows per table for creating the jqGrid implementation. The milestone results are the following

Installed jqGrid libraries
Installed a JSON library that allows a non-invasive programming approach
Replaced the scafolled WEB MVC grid for jqGrids
Enabled grid navigation

On the gallery section I am showing milestone #1 screen shots

Gallery

Integrated jqGrid Petclinic "Vet" view

Integrated jqGrid Petclinic "Owner" view

Integrated jqGrid Petclinic "Visit" view

Integrated jqGrid Petclinic "Pet" view
Next Milestones

To implement: add, edit, delete and search record grid functionality
To implement column sorting
To implement incremental search and auto-completion
To remove all non jQuery JavaScript libraries
To include client/server side validation
To incorporate blog Readers feedback. Assuming that I get it
To QA submit

Next Milestone sneak peek functionality. IN PROGRESS...

How to have access to these products

Send me an email, if you are interested in participating in the WEB MVC to jQuery add-on development and have access to it. I will provide you with further info on it

Conclusion

I showed up a major milestone in the WEB MVC to jQuery addon project. The milestone integrates an effective component for the replacement of the grids created by Roo scafolding. Bottom line: You don't need heavy-weight-old-fashion approaches for creating a sexy-good-looking-powerful RIA app using Roo. Did I make my point?

B. and RooIA Roogards
jD