A pleasant guest stopped at Vaadin office yesterday as Tommi Laukkanen - the author of LazyQueryContainer visited us. He took the trip here just to see what is it like in our offices - and maybe also to pick up the iPad he won in Vaadin Add-on Compo in August. Congratulations!

The LazyQueryContainer add-on solves the one of a most prominent problem with large datasets: Lazily loading data from database (or a web service) as user browses it, keeping applications fast and smooth while limiting the memory consumption. It relies on Vaadin data-aware components (like Table) with the ability to show only the data needed and introduces a simple API to implement logic for virtually any datasource very easily.

"Vaadin is my favorite web framework and very happy to contribute like this.", told Mr. Laukkanen giving us a a quick tour on the add-on features. "Also, I want to thank Volker Krebs for helping me with the buffered writes. The LazyQueryContainer now supports also buffered in-place editing. In the same sprint I implemented a few built-in QueryFactories for JPA and Java Beans, also building the optimal feature set to make it reach more users."

As said the API is very easy and you can easily add new datasources too. Just implement two things: QueryFactory and Query. The first one is used to create a new Query object whenever a data needs to be re-read. For example sorting items is made in the data source. There are also nice built-in debug features showing query meta information. These help you to optimize the data retrieval logic.

Really, that was an earned victory. The add-on itself, source code, supporting wiki tutorial and demo are all there. Check it out!

Today we rolled out a new version of the Vaadin Directory. This update is mostly about fulfilling a common feature request we have heard from the community, downloading add-ons via Maven repository. We have setup our own Maven repository for Vaadin Add-ons and already deployed existing add-ons there with the exception of some add-ons that wouldn't make sense to use via Maven (tools etc). All future add-ons (and new versions of existing add-ons) will automatically be also available via the Maven repository.

How to use this new feature? It's simple, in the Directory we now have a Maven POM button right under the download button for each add-on that is available via Maven. By clicking this button you will be shown all the needed information (<repository> and <dependency>) for you to copy-paste into the pom.xml file of your Maven project. More defailed instructions here.

We would be happy to hear any feedback from you about this new feature. There might still be some rough edges and together we can smooth them out. Please post your comments, bug reports, ideas or any other feedback into this forum thread or use the feedback link on the Directory menu.

One of my first assignments as a fresh employee of IT Mill was to investigate how well Vaadin integrates with the new GlassFish 3 application server. The last time I had used the "official JEE" was back in the 1.4 days, resulting in me becoming somewhat of a Spring fanatic. However, I had read that JEE 5 had improved considerably and approached my assignment with careful optimism.

I had previously done a lot of development on Eclipse Rich Client Platform and really liked the modular thinking that was enforced by the underlying OSGi platform. Therefore, when I found out that GlassFish supported OSGi, I immediately became excited.

I started small by turning the Vaadin JAR into an OSGi bundle and deployed it on the GlassFish server. After that, I created a Vaadin application that could be deployed as a web application bundle (WAB). The result of this experiment was an article that can be found here.

With the basic building blocks in place, I moved on to create a simple modular Vaadin application inspired by Eclipse RCP. The user interface was running as an ordinary JEE web application, but it could be dynamically extended by installing OSGi bundles into GlassFish. The application is described in an article that can be found here. I have not yet created any "real-world" applications using this approach, but I have some ideas for a pet project that will utilize OSGi. If the ideas ever turn into code, I will let you know.

In addition to OSGi, I also checked out the new annotation-based way of configuring JEE applications and injecting dependencies. While figuring out how to utilize it with Vaadin, I came up with two different approaches that resulted in yet another article found here. Quickly after I had posted the article, I received a third (better) approach from a community member and included it in the article as well.

Finally, I investigated how the security features of GlassFish can be used to secure Vaadin applications. Although I still think Spring Security is more fine grained when it comes to security, the standard GlassFish/JEE 6 security features are sufficient for most applications. Custom security features, such as auditing or ACLs, can easily be implemented using interceptors to avoid cluttering the business logic with security code. My article on Vaadin and JEE6 security can be found here.

Overall, discovering GlassFish 3 has been a pleasant experience and I am going to continue on this path, as there is still a lot to discover. Thanks to the modular design of GlassFish 3, JEE has become a lightweight, non-intrusive framework for developing both small and large enterprise applications. Although Spring and Tomcat will still play an important role in my Vaadin toolbox, they are now accompanied by JEE6 and GlassFish 3 as well.