Miles to go …

“Extensibility” is a major theme of Java EE 6. This theme enables seamless pluggability of other popular Web frameworks with Java EE 6.

Before Java EE 6, these frameworks have to rely upon registering servlet listeners/filters in “web.xml” or some other similar mechanism to register the framework with the Web container. Thus your application and framework deployment descriptors are mixed together. As an application developer you need to figure out the magical descriptors of the framework that will make this registration.

What if you are using multiple frameworks ? Then “web.xml” need to have multiple of those listeners/servlets. So your deployment descriptor becomes daunting and maintenance nightmare even before any application deployment artifacts are added.

Instead you should focus on your application descriptors and let the framework developer provide the descriptors along with their jar file so that the registration is indeed magical.

For that, the Servlet 3.0 specification introduces “web module deployment descriptor fragment” (aka “web-fragment.xml”). The spec defines it as:

A web fragment is a logical partitioning of the web app in such a way that the frameworks being used within the web app can define all the artifacts without asking devlopers to edit or add information in the web.xml.

Basically, the framework configuration deployment descriptor can now be defined in “META-INF/web-fragment.xml” in the JAR file of the framework. The Web container picks up and use the configuration for registering the framework. The spec clearly defines the rules around ordering, duplicates and other complexities.

TOTD #86 explained how to get started with Apache Wicket on GlassFish. This Tip Of The Day (TOTD) explains how to leverage ”web-fragment.xml” to deploy a Wicket application on GlassFish v3. The basic concepts are also discussed here.

For the “Hello World” app discussed in TOTD #86, the generated “web.xml” looks like:

This deployment descriptor defines a Servlet Filter (wicket.helloworld) that registers the Wicket framework with the Web container. The filter specifies an initialization parameter that specifies the class name of the Wicket application to be loaded. And it also contains some other information that is also relevant to the framework. None of this application is either required or specified by the application. And so that makes this fragment a suitable candidate for “web-fragment.xml”.

Here are the simple steps to make this change:

1. Remove “src/main/webapp/WEB-INF/web.xml” because no application specific deployment descriptors are required.
2. Include “wicket-quickstart-web-fragment.jar” in the “WEB-INF/lib” directory of your application by adding the following fragment in your “pom.xml”:
   

   <dependencies>         . . .         <!– web-fragment –>         <dependency>             <groupId>org.glassfish.extras</groupId>             <artifactId>wicket-quickstart-web-fragment</artifactId>             <version>1.0</version>             <scope>runtime</scope>         </dependency>     </dependencies>    . . .     <repositories>         <repository>             <id>maven2-repository.dev.java.net</id>             <name>Java.net Repository for Maven</name>          &nbsp ;  <url>http://download.java.net/maven/2/</url>         </repository>     </repositories>

   This file contains only “META-INF/web-fragment.xml” with the following content:

   <web-fragment>         <filter>                 <filter-name>wicket.helloworld</filter-name>                 <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>                 <init-param>                         <param-name>applicationClassName</param-name>                         <param-value>org.glassfish.samples.WicketApplication</param-value>                 </init-param>         </filter>         <filter-mapping>                 <filter-name>wicket.helloworld</filter-name>                 <url-pattern>/*</url-pattern>         </filter-mapping> </web-fragment>

3. Create the WAR file without “web.xml” by editing “pom.xml” and adding the following fragment:
   

   <plugins>             . . .             <plugin>                 <groupId>org.apache.maven.plugins</groupId>                 <artifactId>maven-war-plugin</artifactId>                 <version>2.1-beta-1</version>                 <configuration>                     <failOnMissingWebXml>false</failOnMissingWebXml>                 </configuration>             </plugin>             . . .       </plugins>

That’s it, now you can create a WAR file using “mvn package” and deploy this web application on GlassFish v3 latest promoted build (58 as of today) as explained in TOTD #86.

The updated WAR file structure looks like:

Notice, there is no “web.xml” and the additional “wicket-quickstart-web-fragment-1.0.jar” and everything works as is!

It would be nice if the next version of wicket-*.jar can include “META-INF/web-fragment.xml” then everything will work out-of-the-box

Here is a snapshot of the deployed application:

Are you deploying your Wicket applications on GlassFish ?

Technorati: totd glassfish v3 wicket javaee6 servlet web-fragment

So you need to include JSON libraries in your Maven project. The only option that seems to be currently available is using json-lib with the following dependencies:

The APIs are based upon the original work done at json.org/java.

If you are using NetBeans for adding the Maven dependency then it nicely shows the different versions for the artifact as shown below:

The usage guide and samples at json-lib have lots of documentation to get you started. Don’t forget the package names are changed so “org.json.JSONObject” is ”net.sf.json.JSONObject” and similarly other classes.

Please leave suggestions on other TOTD (Tip Of The Day) that you’d like to see. A complete archive of all the tips is available here.

Technorati: json maven json-lib netbeans

TOTD #86 explained how to get started with deploying a Apache Wicket application on GlassFish. This Tip Of The Day (TOTD) will show how to add pagination to your Wicket application.

The blog entry “JPA/Hibernate and Wicket Repeating Views with Netbeans” Part 1 and 2 explain in detail how to create a CRUD application using NetBeans, JPA, Hibernate and Wicket. This blog uses the data created in TOTD #38 for the database table.

1. After creating the JPA Controller, adding the IDataProvider and DataView implementations and hooking together, the application is available at “http://localhost:8080/helloworld” and looks like:

   

   As noticed in the output, all the states are listed in one page. The HTML markup looks like:

   <html>     <head>         <title>Wicket Quickstart Archetype Homepage</title>     </head>     <body>         <strong>Wicket Quickstart Archetype Homepage</strong>         <br/><br/>         <span wicket:id=”message”>message will be here</span>         <table>             <tr>                 <th>ID</th>                 <th>Abbreviation</th>                 <th>Name</th>             </tr>             <tr wicket:id=”rows”>                 <td><span wicket:id=”id”>ID</span></td>                 <td><span wicket:id=”abbrev”>Abbreviation</span></td>                 <td><span wicket:id=”name”>Name</span></td>             </tr>         </table>     </body> </html>

   The backing POJO looks like:

   package org.glassfish.samples; import java.util.Iterator; import org.apache.wicket.PageParameters; import org.apache.wicket.markup.html.basic.Label; import org.apache.wicket.markup.html.WebPage; import org.apache.wicket.markup.repeater.Item; import org.apache.wicket.markup.repeater.data.DataView; import org.apache.wicket.markup.repeater.data.IDataProvider; import org.apache.wicket.model.CompoundPropertyModel; import org.apache.wicket.model.IModel; import org.apache.wicket.model.LoadableDetachableModel; import org.glassfish.samples.controller.StatesJpaController; import org.glassfish.samples.model.States; /**  * Homepage  */ public class HomePage extends WebPage {     private static final long serialVersionUID = 1L;     // TODO Add any page properties or variables here     /**      * Constructor that is invoked when page is invoked without a session.      *      * @param parameters      *            Page parameters      */     public HomePage(final PageParameters parameters) {         // Add the simplest type of label         add(new Label(“message”, “If you see this message wicket is properly configured and running”));         // TODO Add your page’s components here                 // create a Data Provider         IDataProvider statesProvider = new IDataProvider() {             public Iterator iterator(int first, int count) {                 StatesJpaController sc = new StatesJpaController();                 return sc.findStatesEntities(count, first).iterator();             }             public int size() {                 StatesJpaController sc = new StatesJpaController();                 return sc.getStatesCount();             }             public IModel model(final Object object) {                 return new LoadableDetachableModel() {                     @Override                     protected States load() {                         return (States)object;                     }                 };             }             public void detach() {             }         };         // TODO Add your page’s components here       &nbsp ; DataView dataView = new DataView(“rows”, statesProvider) {             @Override             protected void populateItem(Item item) {                 States state = (States)item.getModelObject();                 item.setModel(new CompoundPropertyModel(state));                 item.add(new Label(“id”));                 item.add(new Label(“abbrev”));                 item.add(new Label(“name”));             }         };         add(dataView);     } }

   and “persistence.xml” looks like:

   <?xml version=”1.0″ encoding=”UTF-8″?> <persistence version=”1.0″ xmlns=”http://java.sun.com/xml/ns/persistence” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd”>   <persistence-unit name=”helloworld” transaction-type=”RESOURCE_LOCAL”>     <provider>org.hibernate.ejb.HibernatePersistence</provider>     <class>org.glassfish.samples.model.States</class>     <properties>       <property name=”hibernate.connection.username” value=”app”/>       <property name=”hibernate.connection.driver_class” value=”org.apache.derby.jdbc.ClientDriver”/>       <property name=”hibernate.connection.password” value=”app”/>       <property name=”hibernate.connection.url” value=”jdbc:derby://localhost:1527/sample”/>     </properties>   </persistence-unit> </persistence>

2. Lets add pagination to this simple sample.
1. In the POJO, change DataView constructor so that it looks like:

   DataView dataView = new DataView(“rows”, statesProvider, 5)

   where “5″ is the number of entries displayed per page. Alternatively you can also set the number of items per page by invoking:

   dataView.setItemsPerPage(5);

2. In the HTML page, add the following right after “<table/>”:
   

   <span wicket:id=”pager”>message will be here</span><br>

   as the last line. This is the placeholder for pagination controls.

3. In the POJO, add the following:
   

   PagingNavigator pager = new PagingNavigator(“pager”, dataView);         add(pager);

   right after “add(dateView);”.

   The output now looks like:

   

   and clicking on “>” shows:

   

   And finally clicking on “>>” shows

   

   The information is now nicely split amongst multiple pages.

So just adding a pagination controls placeholder in the HTML and a corresponding configuration in DataView (in the backing POJO) did the trick for us.

Please leave suggestions on other TOTD (Tip Of The Day) that you’d like to see. A complete archive of all the tips is available here.

Technorati: wicket glassfish pagination

This Tip Of The Day (TOTD) explains how to add pagination to your Rails application.

1. Create a simple Rails scaffold as:

   ~/samples/jruby >~/tools/jruby/bin/jruby -S rails paginate ~/samples/jruby/paginate >~/tools/jruby/bin/jruby script/generate scaffold book title:string author:string ~/samples/jruby/paginate >sed s/’adapter: sqlite3′/’adapter: jdbcsqlite3′/ <config/database.yml >config/database.yml.new ~/samples/jruby/paginate >mv config/database.yml.new config/database.yml ~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S rake db:migrate

2. Edit “test/fixtures/books.yml” and specify the content as:
   

   # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html one:   title: Ultramarathon Man Confessions of an All-Night Runner   author: Dean Karnazes two:   title: My Life on the Run   author: Bart Yasso three:   title: 50/50 Secrets I Learned Running 50 Marathons in 50 Days   author: Dean Karnazes four:   title: Born to Run   author: Christopher Mcdougall five:   title: Four Months to a Four-hour Marathon   author: Dave Kuehls six:   title:  Galloway’s Book on Running   author: Jeff Galloway seven:   title: Marathoning for Mortals   author: John Bingham and Jenny Hadfield eight:   title:  Marathon You Can Do It!   author: Jeff Galloway nine:   title: Marathon The Ultimate Training Guide   author: Hal Higdon ten:   title: Running for Mortals   author: John Bingham and Jenny Hadfield

   and load the fixtures as:

   ~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S rake db:fixtures:load (in /Users/arungupta/samples/jruby/paginate)

3. Run the application as:
   

   ~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S glassfish -l Starting GlassFish server at: 129.145.132.8:3000 in development environment… Writing log messages to: /Users/arungupta/samples/jruby/paginate/log/development.log. . . . Jul 29, 2009 2:06:44 PM com.sun.grizzly.scripting.pool.DynamicPool$1 run INFO: New instance created in 7,488 milliseconds

   The application is accessible at “http://localhost:3000/books” and looks like:

   

   The page shows 10 rows, all in one page.

4. Lets add pagination to this simple sample.
1. Install will_paginate gem as:

   /tools/jruby >./bin/jruby -S gem install will_paginate JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed will_paginate-2.2.2 1 gem installed Installing ri documentation for will_paginate-2.2.2… Installing RDoc documentation for will_paginate-2.2.2…

   There are other methods of installation as well.

2. Edit “config/environment.rb” and add
   

   require “will_paginate”

   as the last line.

3. Edit the “index” action in “app/controllers/books_controller.rb” as:
   

   @books = Book.paginate(:page => params[:page], :per_page => 5) #@books = Book.all

   “:per_page” specifies the number of items to be displayed in each page.

4. In “app/views/books/index.html.erb”, add:
   

   <%= will_paginate @books %>

   right after “</table>”.

   The output now looks like:

   

   and clicking on “Next” shows:

   

   The information is nicely split amongst 2 pages.

An important point to remember is that will_paginate only adds pagination to your Rails app. You are still required to display all the values.

But essentially replacing “@books = Book.all” with “@books = Book.paginate(:page => params[:page], :per_page => 5)” in the Controller and adding
“<%= will_paginate @books %>” did the trick for us.

Clean and simple!

Please leave suggestions on other TOTD (Tip Of The Day) that you’d like to see. A complete archive of all the tips is available here.

Technorati: jruby rubyonrails glassfish pagination will_paginate