Open Garage

Installing Spring Dynamic Module 2.0 on Apache Felix 3 in a hurry

2011-03-07T07:25:00.001-08:00

As I mentioned in my posts on Web-plug, I did not consider OSGi or Spring DM at that time because of learning curve and lack of time. But web-plug also has its own set of limitations. Versioning is a big issue for example. I did not try to extend the classloader of Tomcat for this. But off late OSGi and Spring DM has caught my attention again, as I have some time to focus on something new. Also I find that some really good and highly detailed books are out there in the market.So documentation is now reaching the state where it should be for a new technology and framework to be easily and widely acceptable.

Now I picked up – Spring Dynamic Module in Action (Manning, 2010). Its a wonderful book as most of them that I have read in Manning’s in Action series. This is a must read book. Please buy it and do not dowload a pirated e-book. The authors and publications take lot of pain in producing a good book. The examples in this book are based on Equinox OSGi container. I thought of using them on Apache Felix. So the first step is installing the OSGi container and then the framework.

Download and Install Apache Felix 3.0.9 from the link below:

http://mirror.atlanticmetro.net/apache//felix/org.apache.felix.main.distribution-3.0.9.zip

Unzip the zip file in a folder named felix-framework-3.0.8. e.g – C:\felix-framework-3.0.8

Now create a run.cmd file and save it in the felix-framework-3.0.8 folder using your favourite text editor.The file contains the instructions to launch the Felix framework as shown below:

java -jar bin/felix.jar

Once the run.cmd file is ready, we are all set to launch the framework. So, launch the command prompt and type run. The gogo console is shown below.

Download and unzip Spring DM

Note – Spring DM has now moved to Eclipse Foundation as Gemini Blueprint project. But its still in incubation stage. So we will download and use Spring DM 2.0.0.M1 from the link below:

http://s3.amazonaws.com/dist.springframework.org/milestone/OSGI/spring-osgi-2.0.0.M1-with-dependencies.zip

Just unzip the distribution and copy the bundles from dist and lib folders. The list is shown in figure below. The four selected bundles are core framework bundles. The rest are for Spring DM.

Just copy the files to the bundle folder (in this case - C:\felix-framework-3.0.8\bundle).Now once again fire the command run.cmd and you will the gogo console now spits some log4j warning.

The problem is well documented in the book. I will try to create a fragment in the next post to solve this on Apache Felix.

End of Java EE 6 show

2010-11-09T05:19:00.001-08:00

Since last 2 days I have had lot of issues integrating JPA2 with my SLSB. Some of these are attributed to my new learning curve in Java EE 6. However with my quick exploration in last few days I can safely say that there are still serious holes in Java EE 6 world. It is slim trim and good for rapid development (unless you are on some unstable open source server) but lacks full power to drive a highly customizable and external configuration driven flexible application. These are some of my observations:

Open source servers – Geronimo 3 and JBOSS 6 not yet ready. JBOSS 6 is still better. Guys for better adoption of open source we need documentation. Open source product and closed documentation will not promote this good products.
Directly injecting persistence unit / entity manager results in severe cross cutting concerns. I take back my earlier word, although speed of development is important, good design goes a long way in maintenance. After writing some code in my session bean with JPA I was sad myself.
Java EE 6 will not suffice if you need to build and app with good number of external configuration properties.
Security – although I did not try much, but looks like is not as strong in terms of features that Spring security provides – especially easy integration with directory servers or SSO systems.
If I want to clean up my session beans by moving data access code to a DAO, then I would have to build a factory to inject it. Ah Spring does a better job here. Does Java EE 6 promote code smell? I guess YES.
I was feeling the need for those template classes when writing direct JPA code with entity manager.
I had problems using the POSTGRES data source configured using JBOSS 6 console. The persistence unit could never connect. Finally I had to resort to old days of copy+paste the xml in the deploy directory.

Final conclusion

I am rolling back to stick to Spring 3 on Tomcat 6/7 with Primefaces and Hibernate or my home grown data mapper. I will also use JQUERY UI and JQUERY Mobile if my requirements are that way. I may consider JBOSS 5 / 6 if there is need for JMS / MQ and there is multiple resource managers calling for JTA. But all core will be Spring. I think lot of dust has to settle over Java EE 6, even then it will still take lot of time to match the pluggability, flexibility and wide coverage of Spring with other good frameworks.

Next focus will on my own simple data mapper. I will put it on source forge.

Adding and injecting the EJB3 session bean

2010-11-07T04:13:00.001-08:00

In the last post the managed bean was creating the data. As a good practice the get method should never ideally do load from database or do complex time consuming operations. Its time to move the data retrieval code to a session bean( subsequently use JPA) method. In Java EE 6 it is no longer required to put the ejbs in jar files with tons of deployment descriptors. The ear file is no longer mandatory in Java EE 6. You can put your EJBs in the same war file as the web components. Ah! life is so easy and simple.
The stateless session beans(SLSB) are POJOs and can be marked as SLSB with the @Stateless annotation. Things are even easier with EJB 3.1. You no longer require the business interface. Just a concrete class will do. Although program to interface is a great principle, but for simplicity, speed of development and ease of maintenance I will stick to the new ways. The purists may frown but I cannot think when I changed an implementation midway or in later stages of a project for whatever reason in my entire career. When we select a technology stack we need to build competency and stick to it rather than continuing to chop and change.
Listing 1 shows the simple stateless session bean.
Listing 1 – ProductService.java

package com.windowshop.business;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.ejb.Stateless;

import com.windowshop.domain.entities.Product;

/**
* @author Dhrubo
*
*/
@Stateless
public class ProductService {

public List getProductsByMonth(){
System.out.println("Hurray!!!!! SLSB called");
//TODO - use JPA to fetch from db
List products = new ArrayList();
Product product = null;
for(int i = 1 ; i <= 34; i++) {
product = new Product(i,"Abc",new Date(),"","",i+1.20d,"Rs");
products.add(product);
}

return products;
} 
}

Now that we have the SLSB, its time to refactor the managed bean - “move method” to the session bean. The “getProductsByMonth” will undergo few more rounds of refactoring in the future for sure. Listing 2 shows the modified managed bean.

package com.windowshop.web.controller;

import java.util.List;

import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import com.windowshop.business.ProductService;
import com.windowshop.domain.entities.Product;

/**
* @author Dhrubo
*
*/
@ManagedBean(name="productController")
public class ProductController {
@EJB 
ProductService productService;
public List getProductsByMonth(){
return productService.getProductsByMonth();
}
}

So we can see that the SLSB is injected into the managed bean using @EJB annotation. The getProductsByMonth method is slimmer as the call is dedicated now to the SLSB. You will need to add some dependencies to the pom.xml file. Listing 3 shows the modified pom.xml file.

Listing 3 – pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.windowshop</groupId>
<artifactId>shopweb</artifactId>
<packaging>war</packaging>
<version>1.0.0</version>
<name>shopweb Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>
<!-- Prime faces , JSF -->

<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>2.2.RC1-SNAPSHOT</version>
<scope>runtime</scope>
<type>jar</type>
</dependency>
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
<version>2.0.3</version>
<scope>provided</scope>
<type>jar</type>
</dependency>
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-impl</artifactId>
<version>2.0.3</version>
<scope>provided</scope>
<type>jar</type>
</dependency>

<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.5</version>
<scope>runtime</scope>
<type>jar</type>
</dependency>

<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>6.0</version>
<scope>provided</scope>
</dependency>

</dependencies>
<repositories>
<repository>
<id>prime-repo</id>
<name>Prime Technology Maven Repository</name>
<url>http://repository.prime.com.tr/</url>
</repository>
<repository>
<id>maven2-repository.dev.java.net</id>
<name>Java.net Repository for Maven</name>
<url>http://download.java.net/maven/2/</url>
</repository>

</repositories>
<build>
<finalName>shopweb</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

This was the easiest SLSB based project I have ever done in my life. Java EE 6 has been a refreshing experience so far. I intend to get more into depth and try out Java EE 6 and possibly all its facets possible with JBOSS 6. Now if you deploy this project you will the following lines in your JBOSS console confirming the deployment of EJB, registration in JNDI. You can launch the browser and check if the landing page is working as before. I did not find any problem.

JBOSS6 console

17:05:39,480 WARN [InterceptorInfoRepository] EJBTHREE-1852: InterceptorInfoRepository is deprecated
17:05:40,347 INFO [JBossASKernel] Created KernelDeployment for: shopweb.war
17:05:40,352 INFO [JBossASKernel] installing bean: jboss.j2ee:jar=shopweb.war,name=ProductService,service=EJB3
17:05:40,352 INFO [JBossASKernel]   with dependencies:
17:05:40,352 INFO [JBossASKernel]   and demands:
17:05:40,352 INFO [JBossASKernel]     jboss.ejb:service=EJBTimerService; Required: Described
17:05:40,353 INFO [JBossASKernel]   and supplies:
17:05:40,353 INFO [JBossASKernel]     jndi:ProductService
17:05:40,353 INFO [JBossASKernel]     jndi:ProductService/no-interface
17:05:40,354 INFO [JBossASKernel] Added bean(jboss.j2ee:jar=shopweb.war,name=ProductService,service=EJB3) to KernelDeployment of: shopweb.war
17:05:50,041 INFO [TomcatDeployment] deploy, ctxPath=/shopweb
17:05:50,237 INFO [config] Initializing Mojarra 2.0.2 (FCS b10) for context '/shopweb'
17:05:54,557 INFO [AbstractNoInterfaceViewJNDIBinder] Binding the following entry in Global JNDI:

    ProductService/no-interface - EJB3.1 no-interface view

17:05:54,561 INFO [SessionSpecContainer] Starting jboss.j2ee:jar=shopweb.war,name=ProductService,service=EJB3
17:05:54,573 INFO [EJBContainer] STARTED EJB: com.windowshop.business.ProductService ejbName: ProductService
17:05:54,579 INFO [JndiSessionRegistrarBase] Binding the following Entries in Global JNDI:

JSF 2.0 – First Managed Bean

2010-11-05T23:24:00.001-07:00

The window shop, landing page is not complete. I have not shown the new product arrivals for this month in the center of the screen. In order to do that we need a managed bean which will retrieve data from the database. Later on we will integrate EJB 3.x stateless session beans to fetch the data for us. For now our managed bean will cook up the data to set the ball rolling. In this process we also discover the first domain object – Product. Going forward this will be turned into a JPA entity for CRUD operations.
Here is how the domain object looks like:

/**
* 
*/
package com.windowshop.domain.entities;

import java.util.Date;

import org.apache.commons.lang.builder.ToStringBuilder;

/**
* @author Dhrubo
* 
*/
public class Product {
private int productId;
private String productName;
private Date createdDate;
private String thumnailLocation;
private String model;
private double price;
private String currency;

public Product() {}

public Product(int productId, String productName, Date createdDate,
String thumnailLocation, String model, double price, String currency) {
super();
this.productId = productId;
this.productName = productName;
this.createdDate = createdDate;
this.thumnailLocation = thumnailLocation;
this.model = model;
this.price = price;
this.currency = currency;
}

public int getProductId() {
return productId;
}

public void setProductId(int productId) {
this.productId = productId;
}

public String getProductName() {
return productName;
}

public void setProductName(String productName) {
this.productName = productName;
}

public Date getCreatedDate() {
return createdDate;
}

public void setCreatedDate(Date createdDate) {
this.createdDate = createdDate;
}

public String getThumnailLocation() {
return thumnailLocation;
}

public void setThumnailLocation(String thumnailLocation) {
this.thumnailLocation = thumnailLocation;
}

public String getModel() {
return model;
}

public void setModel(String model) {
this.model = model;
}

public double getPrice() {
return price;
}

public void setPrice(double price) {
this.price = price;
}

public String getCurrency() {
return currency;
}

public void setCurrency(String currency) {
this.currency = currency;
}

public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}

The managed bean is shown in the listing below

/**
* 
*/
package com.windowshop.web.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.faces.bean.ManagedBean;

import com.windowshop.domain.entities.Product;

/**
* @author Dhrubo
*
*/
@ManagedBean(name="productController")
public class ProductController {

public List getProductsByMonth(){

//TODO - Remove to session bean and JPA to fetch from db
List products = new ArrayList();
Product product = null;
for(int i = 1 ; i <= 34; i++) {
product = new Product(i,"Abc",new Date(),"","",i+1.20d,"Rs");
products.add(product);
}

return products;
}
}

Note that with JSF 2 you can do away with faces-config.xml. This file is just optional. Instead you can turn a POJO into a managed bean with the ManagedBean annotation. One attribute is the name of the managed bean. In this case the managed bean is named “productController”. In case you do not want to name the managed bean it will by default be named with the class name part of the fully qualified class name. There are other attributes which I will take up as and when we come across the need for them. This managed bean will have a default request scope. I will discuss different scopes later. For the moment just know that for managed beans the default scope is request.

Now you will want to use this managed bean in JSF pages. The listing below (newproducts.xhtml) shows the new JSF which fills the missing piece.

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:p="http://primefaces.prime.com.tr/ui">

<f:view contentType="text/html">
<h:form>
<h:outputText value="New Products for November 2010"  style="font-size:.9em"/>

<p:dataGrid var="product" value="#{productController.productsByMonth}" columns="4"
rows="12" paginator="true" effect="true"
paginatorTemplate="{CurrentPageReport}  {FirstPageLink} {PreviousPageLink} 
{PageLinks} {NextPageLink} {LastPageLink} {RowsPerPageDropdown}"
rowsPerPageTemplate="8,12,16">

<p:column>
<p:panel header="#{product.model}" style="text-align:center">
<h:panelGrid columns="1" style="width:100%">
<!--
<p:graphicImage value="/images/cars/#{car.manufacturer}.jpg"/> 
-->
<h:outputText value="#{product.productName}" />

<p:commandLink title="View Detail" action="#">

</p:commandLink>
</h:panelGrid>
</p:panel>
</p:column>

</p:dataGrid>
</h:form>
</f:view>
</html>

The layout and other pages have been updated and they are now in the SVN.

Servlet 3.0 – Add frameworks as Plugins

2010-11-04T22:07:00.001-07:00

With Servlet 3.0, it is now possible to include external or 3rd party frameworks as plug-ins to the web application. This is made possible by the ServletContainerInitializer interface. The documentation says that the implementation of this interface - “allows a library/runtime to be notified of a web application's startup phase and perform any required programmatic registration of servlets, filters, and listeners in response to it”. The servlet container finds the ServletContainerInitializer using the JAR services API during application startup. The framework implementing the ServletContainerInitializer needs to add a file named javax.servlet.ServletContainerInitializer in the META-INF/services directory of the JAR file. This file points to the implementation class of the ServletContainerInitializer.The JSF 2 Majorra implementation has used this feature. If we check the JSF-IMPL-2.x jar this file is located in META-INF/services folder and points to the class - com.sun.faces.config.FacesInitializer. If we look into this class we will find the following lines -

	ServletRegistration reg = servletContext.addServlet("FacesServlet","javax.faces.webapp.FacesServlet");
  	reg.addMapping("/faces/*", "*.jsf", "*.faces");
	servletContext.setAttribute(RIConstants.FACES_INITIALIZER_MAPPINGS_ADDED, Boolean.TRUE);

The ServletContainerInitializer thus registers the faces servlet and three URL mappings out of the box leading to clean web.xml. In fact web.xml is optional in Servlet 3.0.

A note on JBOSS 6 JSF application

JBOSS 6, JSF deployer is very special. It does some tricks with a JSF 2 web application. You can read it here - http://docs.jboss.org/jbossas/6/JSF_Guide/en-US/html/jsf.deployer.config.html

First Java EE 6 application

2010-11-03T05:22:00.001-07:00

to create a Maven 2 Java EE 6 application. This will be primarily the UI part build with JSF. Primefaces is the library of choice to build the “windowshop” application. I will try to build a landing page similar to oscommerce. The figure 1 below shows a screenshot of the landing page mock up.

Figure 1 – Landing page prototype

Now let us create a Maven 2 web project using the - “maven-archetype-webapp”.

The listing below shows the pom.xml

Listing 1 – pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.windowshop</groupId>
    <artifactId>shopweb</artifactId>
    <packaging>war</packaging>
    <version>1.0.0</version>
    <name>shopweb Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- Prime faces , JSF -->
        <dependency>
            <groupId>org.primefaces</groupId>
            <artifactId>primefaces</artifactId>
            <version>2.2.RC1-SNAPSHOT</version>
            <scope>runtime</scope>
            <type>jar</type>
        </dependency> 
    </dependencies>
    <repositories>
        <repository>
            <id>prime-repo</id>
            <name>Prime Technology Maven Repository</name>
            <url>http://repository.prime.com.tr/</url>
        </repository>
        <repository>
            <id>maven2-repository.dev.java.net</id>
            <name>Java.net Repository for Maven</name>
            <url>http://download.java.net/maven/2/</url>
        </repository>     </repositories>
    <build>
        <finalName>shopweb</finalName>
    </build>
</project>

The web.xml need not have any entry as shown in listing 2. As per JSF 2 auto – registers FacesServlet which is required for JSF URL interpretation following the pluggability feature of Servlet 3. I will write about this feature and how this is enabled in JSF 2 in the next post.

Listing.2 – web.xml

<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 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
      version="3.0">
  <display-name>shopweb</display-name>
</web-app>

Now let us modify the index.jsp page to redirect to the default home landing page as shown in listing 3.

Listing 3 – index.jsp

<html>
<body>
<jsp:forward page="ui/home.jsf"></jsp:forward>
</body>
</html>

I will add the facelet templates and the home page. These are all in the SVN now. I am lazy copying them over here.

You can add the JBOSS 5 server adapter in Eclipse to start stop JBOSS 6 for now. Add the shopweb project and start the server. Once deployment is over, browse to - http://localhost:8080/shopweb/. This should display the guest home page. I will work to make this page similar to the prototype in Figure 1.

Rolling out Java EE 6 development environment

2010-11-02T06:19:00.001-07:00

Step 0 – Download and install JDK 6

Download JDK 6 from the link - http://www.oracle.com/technetwork/java/javase/downloads/index.html. Install it under c:\java.

Step 1 – Download and install JBOSS 6

JBOSS6M5 can be downloaded from the following link - http://sourceforge.net/projects/jboss/files/JBoss/JBoss-6.0.0.M5. Once downloaded unzip the file to c:\jboss6.

Step 2 – Download and install Eclipse

Eclipse Helios 3.6.1 can be downloaded from the following link - http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/helios/SR1/eclipse-jee-helios-SR1-win32.zip. Once downloaded unzip the file to c:/eclipse

Step 3 – Install Maven 2 plug-in and extras

I will prefer to use Maven 2 as my build tool. This is very useful if we also have some continuous integration system set up in future. The Maven 2 eclipse plug-in update sites are located at - http://m2eclipse.sonatype.org/installing-m2eclipse.html. Launch Eclipse and install the plug-in core and extras. In case of the extras install only the WTP extension.

Once the M2E plug-in is installed,restarting Eclipse you may get some warnings as listed below:

Eclipse is running in a JRE, but a JDK is required
Some Maven plugins may not work when importing projects or updating source folders.

You can resolve this by adding the following line to your eclipse.ini file. This file is located at c:\eclipse folder.

-vm
C:\Java\jdk1.6.0_22\bin\javaw.exe

This is a snapshot from my eclipse.ini file

openFile
--launcher.XXMaxPermSize
256M
-showsplash
-vm
C:\Java\jdk1.6.0_22\bin\javaw.exe
org.eclipse.platform

Step 4 – Install Subversion plug-in

I want to safe keep my learning on some subversion repository. So I went on to create a project on GOOGLE CODE called “windowshop” - http://code.google.com/p/windowshop/

You can add the subversion plug-in for Eclipse using the following update URL - http://subclipse.tigris.org/update_1.6.x

Step 5 – Configure SVN

Now I will commit and change code kept on the Google Code SVN. So I need to add the code repository. You can do so easily by going to the SVN repository view and adding the following URL - https://windowshop.googlecode.com/svn

The development environment is more or less setup. If I see that I have missed anything going forward, I will try to add it here.

Exploring Java EE 6

2010-11-02T02:39:00.001-07:00

I have been using, learning and writing about Spring framework for last 5+ years now. It has done loads of good work to simplify life back in J2EE days. But off late I am seeing and participating in discussions where I see a transition back to the platform again. The reason being the Java EE 6 has adopted good ideas from frameworks like Spring, Hibernate etc and have come out with a lean and thin platform. This has not gone unnoticed in developer world.

Also in last couple of years Spring’s evolution has a framework has stalled to an extent. The core framework and extensions viz Spring MVC, Security etc being stable the guys at Spring Source have focused more on servers, OSGi, cloud and adding more products to Spring Source portfolio via acquisition route. The company itself was acquired by VMWare. So lots of things happening but nothing new or exciting enough in the core area to keep the developers attracted. This is really one bad thing that runs deep inside the Java developers’ veins. They are always in the lookout for something exciting new and better. This makes them restless to search for alternatives. The moribund around the core Spring and extensions stack and gradual evolution of Java EE 6 in the same time has acted as the new catalyst for excitement in the Java EE world.

I thought that this senior and experienced developers are showing interest for definite reason. I have been reviewing and reading about Java EE 6 for last few days and found it interesting, making things easier and I have a feeling that if you have half decent team Java EE 6 can cut down on development time significantly. So I thought of starting to explore this in greater detail. I have also got hold of the patterns book by Adam Bien and reading it. All in all things are looking good for the platform. I had a hard and reluctance to move to Spring from J2EE(I was a big fan of EJB in those days). But now I want to explore and make a quick transition back to Java EE 6.

I have decided to build some useful application to try and test all the different new features of Java EE 6. The application that I am trying to build is similar to OSCOMMERCE (http://www.oscommerce.com/), possibly a clone of this great application. I will try to build as many features as I can when I have time. Initially I thought of using Geronimo 3 for this, but I had to stumble upon some JSF issues possibly not compliant with JSF 2 and decided to switch to JBOSS 6M5 instead. Both these servers are very new in supporting the Java EE 6 specifications and catching up with documentation. Glassfish 3 seems to be there for sometime ready with Java EE 6. But since lot has already been written about Glassfish (including books from Apress), I thought its worthwhile exploring JBOSS (and later possibly Geronimo). Also I am a bit sceptical about the future of Glassfish. JONAS is still on Java EE 5. Before I end, here is the link to the JSF 2 and Geronimo 3 issue which I posted:

http://primefaces.prime.com.tr/forum/viewtopic.php?f=3&t=5635&p=24048#p24048

In my next post I will set up the development environment for Java EE 6 with Eclipse Helios 3.6.1 and JBOSS. Stay tuned!. The road will be pure Java EE 6 and then possibly some other frameworks if needed.

Removing the border from header layout unit

2010-09-25T23:35:00.001-07:00

As you have seen the layout contains layout units. You can put any element inside a layout unit. Now there is a border for each layout unit. For our online store, I do not want the border and the header title. In order to remove the border, you will need to override the CSS style and to remove the header just remove the header attribute (header="TOP") from the layout unit tag. This is shown in listing below

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:p="http://primefaces.prime.com.tr/ui">

<f:view contentType="text/html">

<h:head>
<title>Simple Store - Home</title>

<link type="text/css" rel="stylesheet"
href="#{request.contextPath}/themes/cupertino/skin.css" />

<style>

.ui-layout-unit-top .ui-layout-bd {
border: 0;
}

</style>


</h:head>

<h:body>


<p:layout fullPage="true">
<p:layoutUnit position="top" height="80">
<h:outputText value="Top content." />
</p:layoutUnit>
<p:layoutUnit position="bottom" header="BOTTOM" height="100">
<h:outputText value="Bottom content." />
</p:layoutUnit>
<p:layoutUnit position="left" header="LEFT" width="300">
<h:outputText value="Left content" />
</p:layoutUnit>
<p:layoutUnit position="right" header="RIGHT" width="200">
<h:outputText value="Right Content" />
</p:layoutUnit>
<p:layoutUnit position="center" header="CENTER">
<h:outputText value="Center Content" />
</p:layoutUnit>
</p:layout>



</h:body>



</f:view>
</html>

The result is shown in figure below

Creating the layout

2010-09-25T23:11:00.001-07:00

Any web site has a layout. Layouts can be created with HTML tables, divs and with CSS with Javascript tricks. Prime Faces provides out of the box support for border layout. A border layout typically has 5 parts as shown below

TOP / HEADER
LEFT	CENTER	RIGHT
BOTTOM / FOOTER

This border layout works well for most websites. Prime faces border layout can be either applied to a full page or a specific element. It can respond to expand, collapse, close and resize events of each layout unit with ajax listeners. Let us create a full page layout for a simple shopping cart application similar to OSCOMMERCE - http://demo.oscommerce.com/

The listing below shows the modified home.xhtml code.

Listing 1 – home.xhtml

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:p="http://primefaces.prime.com.tr/ui">

<f:view contentType="text/html">

<h:head>
<title>Simple Store - Home</title>

<link type="text/css" rel="stylesheet"
href="#{request.contextPath}/themes/cupertino/skin.css" />




</h:head>

<h:body>


<p:layout fullPage="true">
<p:layoutUnit position="top" header="TOP" height="80">
<h:outputText value="Top content." />
</p:layoutUnit>
<p:layoutUnit position="bottom" header="BOTTOM" height="100">
<h:outputText value="Bottom content." />
</p:layoutUnit>
<p:layoutUnit position="left" header="LEFT" width="300">
<h:outputText value="Left content" />
</p:layoutUnit>
<p:layoutUnit position="right" header="RIGHT" width="200">
<h:outputText value="Right Content" />
</p:layoutUnit>
<p:layoutUnit position="center" header="CENTER">
<h:outputText value="Center Content" />
</p:layoutUnit>
</p:layout>



</h:body>



</f:view>
</html>

You can now see the home page layout as shown in figure below:

Adding color to Prime Faces

2010-09-25T08:37:00.001-07:00

In my last post you have seen a command button. This command button uses the default Prime faces skin and is shown in grey. Let me now make things a bit colorful, by showing how to use the skins provided by Prime faces. Prime faces skins are all based on Jquery themeroller CSS framework. I am interested in cupertino font and I will download the same from - http://www.primefaces.org/themes/cupertino.zip. You can download lots of other ready made themes from - http://www.primefaces.org/themes.html.

In later posts I will show how to create, install and use custom theme or skin. Once downloaded unzip the theme to webapps/themes folder. This is shown in the figure below:

Prime faces theme consists of a skin.css file and a set of images placed in images folder. Now modify your web.xml to tell Prime faces that it should no longer use the default theme sam. Here is the modified web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
	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 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" >
	
   	
    <context-param>
        <param-name>primefaces.skin</param-name>
        <param-value>none</param-value>
    </context-param>
	
       
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.jsf</url-pattern>
    </servlet-mapping>
	
    
</web-app>

Finally add the css in your JSF source using the link tag as shown in the listing (home.xhtml) below:

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:p="http://primefaces.prime.com.tr/ui">

<f:view contentType="text/html">

	<h:head>
		<title>PrimeFaces - ShowCase</title>
		
		<link type="text/css" rel="stylesheet" href="#{request.contextPath}/themes/cupertino/skin.css" />
	
		
	</h:head>
	
	<h:body>
		<h:form>
		<p:commandButton value="Ajax Submit" />
		</h:form>
		
		
		
	</h:body>
	


</f:view>
</html>

Now just like in the previous post, build and deploy the application on tomcat and browse to the following URL - http://localhost:8080/hermesconsole/home.jsf. You will see the bluish button as shown in the figure below.

Getting started with Prime faces 2

2010-09-25T07:54:00.001-07:00

Prime faces is an amazing JSF framework from Cagatay Civici (http://cagataycivici.wordpress.com/). Its wonderful because it is easy to use, minimal dependencies, has probably the widest set of controls among all JSF frameworks, easy to integrate with Spring (including Spring Security) , Java EE EJBs, and last but not the least mobile UI support. So I decided to give Prime faces a try, before selecting it to use in my projects.

Step 1 – Create Maven 2 project

As a first step to integrating Prime faces, create a Maven 2 project in Eclipse. You will need to select ‘maven-archetype-webapp’.

Step 2 – Add repositories and dependencies in pom.xml

I will be using Prime faces 2 with JSF 2 on Tomcat 6. Since the dependencies for Prime Faces and JSF 2 (JSF 2.0.3 is required) are available on different repositories, I will add them to my pom file first. The listing below shows my pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>net.breezeware</groupId>
	<artifactId>hermesconsole</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>hermesconsole Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.primefaces</groupId>
			<artifactId>primefaces</artifactId>
			<version>2.2.M1</version>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-api</artifactId>
			<version>2.0.3</version>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-impl</artifactId>
			<version>2.0.3</version>
		</dependency>
	</dependencies>


	<repositories>
		<repository>
			<id>prime-repo</id>
			<name>Prime Technology Maven Repository</name>
			<url>http://repository.prime.com.tr/</url>
		</repository>
		<repository>
			<id>maven2-repository.dev.java.net</id>
			<name>Java.net Repository for Maven</name>
			<url>http://download.java.net/maven/2/</url>
		</repository>
		
	</repositories>


	<build>
		<finalName>hermesconsole</finalName>
	</build>
</project>

Step 3 – Change web.xml

Add the JSF faces servlet in the web.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
	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 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" >
	
   	
    <context-param>
        <param-name>primefaces.skin</param-name>
        <param-value>none</param-value>
    </context-param>
	
       
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.jsf</url-pattern>
    </servlet-mapping>
	
    
</web-app>

Step 4 – Add a simple xhtml file – home.xhtml

Now let us see Prime faces in action, by adding a simple JSF snippet with 1 control from this library.

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:p="http://primefaces.prime.com.tr/ui">

<f:view contentType="text/html">

	<h:head>
		<title>Hermes Console - Trying PrimeFaces</title>
		
	
		
	</h:head>
	
	<h:body>
		<h:form>
			<p:commandButton value="Ajax Submit" />
		</h:form>
		
		
		
	</h:body>
	


</f:view>
</html>

Step 5 – Build and deloy

Now that we are done, the next step is to build and create the war file and deploy it in Tomcat 6. Then point your browser to - http://localhost:8080/hermesconsole/home.jsf

You will see the following command button on your browser:

Load your Spring beans as plug-ins

2010-07-06T22:35:00.001-07:00

There are different ways of loading Spring beans in a web application – viz using the dispatcher servlet or the context loader listener. A more modular and flexible approach (which also allows you to minimize coupling and dependencies in your applications) is to load the barebones of your application with the core context loaders and load the rest of your beans in a pluggable way. For example you may be interested in loading your page controllers, business tier and data access code as three separate modules. Off course you can do this and then use import in a main spring config file or a comma separate list in your web.xml where you configure the spring bean definition xmls. But what if you just wanted to drop in a jar with Spring beans and be sure they will be loaded and registered in the container. This also eases the pain of swapping an implementation. The goal is to put all your Spring beans in a particular layer, package it as a jar with one or more configuration file(with one following a special naming convention which is used to load them). You can also choose to go for feature based plugin – for example for show employee details use case you can package your view (freemarker template + javascript + css = I will show you how to do this in a later post), page controller (Spring MVC annotated controller), business service (interface + pojo implementation) and data access (interface + implementation) in a jar with configuration file. But my experience with this is if you go for feature based plugin – you can very soon land up with tons of plugins difficult to manage. For the moment lets just focus on the class that makes this pluggable design possible.

/**
 * @author dhrubo
 */
package com.middlewareteam.spring.web.context;

import java.io.IOException;

import javax.servlet.ServletConfig;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.web.context.support.XmlWebApplicationContext;

/**
 * @author dhrubo
 * 
 */
public class PluggableXmlWebApplicationContext extends XmlWebApplicationContext {
	
	public static final String PLUGIN_CONTEXT_CONFIG_NAME = "pluginContextConfigName";
	
	private final Logger log = LoggerFactory.getLogger(PluggableXmlWebApplicationContext.class);

	@Override
	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader)
			throws IOException {

		super.loadBeanDefinitions(reader);

		log.info("Loading plugin application contexts.");
		log.info("Seeking plugin application context configuration name from servlet config ");
				
		ServletConfig config = this.getServletConfig();
		String resourceName = null;
		if(config != null) {
		
			resourceName = this.getServletConfig().getInitParameter(PLUGIN_CONTEXT_CONFIG_NAME);
			log.info("Configured plugin resource name : {}",resourceName);
		}
		
		if(StringUtils.isEmpty(resourceName)) {
			log.info("Seeking plugin application context configuration name from servlet context/web app context.");
			resourceName = this.getServletContext().getInitParameter(PLUGIN_CONTEXT_CONFIG_NAME);
		}
		
		log.info("Final plugin resouce name : {}",resourceName);
		
		ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
		try {
			Resource[] configResources = resourcePatternResolver
					.getResources(resourceName);
			
			
			if (configResources.length != 0) {
				log.info("Plugins found");
				for (Resource resource : configResources) {
					log.info("Resource == " + resource);

				}
				reader.loadBeanDefinitions(configResources);
			} else {
				log.info("No Plugins found.");
			}
		} catch (IOException e) {
			throw new RuntimeException("Error loading plugin definitions",e);
		}

	}

}

Now this is how you should configure this class in your Spring bean loading mechanism.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="dms" version="2.5">
	<display-name>oollaasweb</display-name>
	<context-param>
		<param-name>log4jConfigLocation</param-name>
		<param-value>/WEB-INF/config/log4j.xml</param-value>
	</context-param>

	<!-- security beans are here -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
          /WEB-INF/config/spring-security.xml
     </param-value>
	</context-param>
	
	<context-param>
		<param-name>contextClass</param-name>
		<param-value>
          com.middlewareteam.spring.web.context.PluggableXmlWebApplicationContext
     </param-value>
	</context-param>
	
	<context-param>
		<param-name>pluginContextConfigName</param-name>
		<param-value>
          classpath*:pluginRootApplicationContext.xml
     </param-value>
	</context-param>
	

	<listener>
		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>


	<!-- Root web application context -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- Spring security filters -->
	<filter>
		<filter-name>springSecurityFilterChain</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>springSecurityFilterChain</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<servlet>
		<servlet-name>staticresourceservlet</servlet-name>
		<servlet-class>com.middlewareteam.spring.web.servlet.ResourceServlet</servlet-class>
		<load-on-startup>0</load-on-startup>
	</servlet>

	<servlet>
		<servlet-name>dmsservlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/config/spring-web.xml</param-value>
		</init-param>
		<init-param>
			<param-name>contextClass</param-name>
			<param-value>com.middlewareteam.spring.web.context.PluggableXmlWebApplicationContext</param-value>
		</init-param>
		<init-param>
			<param-name>pluginContextConfigName</param-name>
			<param-value>classpath*:pluginApplicationContext.xml</param-value>
		</init-param>

		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>staticresourceservlet</servlet-name>
		<url-pattern>/resources/*</url-pattern>
	</servlet-mapping>
	
	<servlet-mapping>
		<servlet-name>dmsservlet</servlet-name>
		<url-pattern>/index.html</url-pattern>
	</servlet-mapping>
	
	
	<servlet-mapping>
		<servlet-name>dmsservlet</servlet-name>
		<url-pattern>*.html</url-pattern>
	</servlet-mapping>
	
	
	<servlet-mapping>
		<servlet-name>dmsservlet</servlet-name>
		<url-pattern>*.json</url-pattern>
	</servlet-mapping>
	
	
	<welcome-file-list>
		
		<welcome-file>index.html</welcome-file>
		
	</welcome-file-list>

</web-app>

Now just put your spring config xml with the name pluginRootApplicationContext.xml in the root of the jar and you are ready to roll out pluggable modules. You can use multiple configuration file here too. Just import them in the pluginRootApplicationContext.xml. Also if you use Maven 2 put the pluginRootApplicationContext.xml in the src/main/resources folder. Things will be much easier to package and deploy if you are using Maven.

There are few limitations to this model though. Since Spring does not yet support hot deployment (application context is read only at run time you cannot add beans while your app is running, you can refresh though but it is risky) you have to re-start your applications for the plugins to get listed in the Spring container. As I wrote earlier this is in line with Eclipse plugin architecture. Another limitation is we do not yet have a versioning. What this means is what if you are using application layer plugins and you have just modified a handful of classes. In that case you like that your plugin system can identify and register the new version and retire the old version during an application restart. However you can always delete the old jar and replace it with the new one till we have the version management.

CKEDITOR 3.x - Simplest Ajax Submit Plugin

2010-06-26T06:27:00.001-07:00

I have assumed that you have downloaded and got started with CKEDITOR.

Step 1 – The html file is shown below:

<html>
<head>
<title>Writer</title>
<meta content="text/html; charset=utf-8" http-equiv="content-type" />
<script type="text/javascript" src="ckeditor/ckeditor.js"></script>
<script type="text/javascript" src="js/jquery-1.4.2.min.js"></script>
<style>

.cke_contents {
height: 400px !important;
}

</style>
</head>
<body>


<form action="sample_posteddata.php" method="post">


<textarea id="editor" > </textarea>


<script type="text/javascript">
//<![CDATA[




CKEDITOR.replace( 'editor',
{
fullPage : true,
uiColor : '#9AB8F3',
toolbar : 'MyToolbar'


});




//]]>
</script>

</form>

</body>
</html>

Note that the jquery js file is part of this html page.

Step 2: Create a folder called ‘ajaxsave’ under the plugin folder and save the plugin.js file in it. The source of this file is shown below:

CKEDITOR.plugins.add('ajaxsave',
{
init: function(editor)
{
var pluginName = 'ajaxsave';


editor.addCommand( pluginName,
{
exec : function( editor )
{
alert( "Executing a command for the editor name - " + editor.checkDirty() );


$.post("http://localhost:8080/test/TestServlet", { name: "John", time: "2pm" } );

alert('after ajax post');
},
canUndo : true
});

/*
editor.addCommand(pluginName, 
new CKEDITOR.dialogCommand(pluginName)

);
*/

editor.ui.addButton('Ajaxsave',
{
label: 'Save Ajax',
command: pluginName,
className : 'cke_button_save'
});
}
});

Thats all. You will now need to add this new button to the CKEDITOR toolbar. This is added in the config.js under ckeditor folder as shown below:



CKEDITOR.editorConfig = function( config )
{
// Define changes to default configuration here. For example:
// config.language = 'fr';
// config.uiColor = '#AADC6E';

config.uiColor = '#AADC6E';
config.resize_enabled = false;




config.toolbar = 'MyToolbar';

config.toolbar_MyToolbar =
[
['NewPage','Preview'],
['Cut','Copy','Paste','PasteText','PasteFromWord','-','Scayt'],
['Undo','Redo','-','Find','Replace','-','SelectAll','RemoveFormat'],
['Image','Flash','Table','HorizontalRule','Smiley','SpecialChar','PageBreak'],
'/',
['Styles','Format'],
['Bold','Italic','Strike'],
['NumberedList','BulletedList','-','Outdent','Indent','Blockquote'],
['Link','Unlink','Anchor','Ajaxsave'],
['Maximize','-','About']
];


config.extraPlugins = 'ajaxsave';

};

Part V : A Simple and Smart Result Mapper

2010-05-29T21:44:00.001-07:00

The examples so far only deal with single table. But it is very much possible to join multiple tables and still use this mapper. As an example consider three entities as shown below:

T_REPOSITORY
REPOSITORY_ID	int
REPOSITORY_NAME	varchar
CONNECTOR_ID	int

T_CONNECTOR
CONNECTOR_ID	int
CONNECTOR_NAME	varchar
URL	varchar
OWNER_ID	int

T_OWNER
OWNER_ID	int
OWNER_NAME	varchar
OWNER_KEY	varchar

The relationship is clear - a repository has a connector and a connector has a owner. So how can you populate a Repository object containing a Connector Object which in turn has an Owner object. This is just simple. Execute this query.

SELECT r.repository_id "repositoryId", r.repository_name "repositoryName",
c.connector_id "connector.connectorId",
c.connector_name "connector.connectorName",
c.url "connector.url",
o.owner_id "connector.owner.ownerId",
o.owner_name "connector.owner.ownerName",
o.owner_key "connector.owner.ownerKey"
FROM
t_repository r,t_connector c, t_owner o
WHERE
r.repository_id = ?
AND   c.connector_id = r.connector_id
AND   o.owner_id = c.owner_id

The mapper automatically checks if the child object exists, if not it creates one and then populates the properties. The Javabeans are listed below for reference.
Listing - Repository.java

import org.apache.commons.lang.builder.ToStringBuilder;
public class Repository {
private int repositoryId;
private String repositoryName;
private Connector connector;
/**
* @return the repositoryId
*/
public int getRepositoryId() {
return repositoryId;
}
/**
* @param repositoryId the repositoryId to set
*/
public void setRepositoryId(int repositoryId) {
this.repositoryId = repositoryId;
}
/**
* @return the repositoryName
*/
public String getRepositoryName() {
return repositoryName;
}
/**
* @param repositoryName the repositoryName to set
*/
public void setRepositoryName(String repositoryName) {
this.repositoryName = repositoryName;
}
/**
* @return the connector
*/
public Connector getConnector() {
return connector;
}
/**
* @param connector the connector to set
*/
public void setConnector(Connector connector) {
this.connector = connector;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {

return ToStringBuilder.reflectionToString(this);
}


}

Listing - Connector.java

import org.apache.commons.lang.builder.ToStringBuilder;
public class Connector {
private int connectorId;
private String connectorName;
private String url;
private Owner owner;
/**
* @return the connectorId
*/
public int getConnectorId() {
return connectorId;
}
/**
* @param connectorId the connectorId to set
*/
public void setConnectorId(int connectorId) {
this.connectorId = connectorId;
}
/**
* @return the connectorName
*/
public String getConnectorName() {
return connectorName;
}
/**
* @param connectorName the connectorName to set
*/
public void setConnectorName(String connectorName) {
this.connectorName = connectorName;
}
/**
* @return the url
*/
public String getUrl() {
return url;
}
/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}


/**
* @return the owner
*/
public Owner getOwner() {
return owner;
}
/**
* @param owner the owner to set
*/
public void setOwner(Owner owner) {
this.owner = owner;
}

/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {

return ToStringBuilder.reflectionToString(this);
}
}

Listing - Owner.java

import org.apache.commons.lang.builder.ToStringBuilder;


/**
* @author dhrubo
* 
*/
public class Owner {
private long ownerId;
private String ownerName;
private String ownerKey;



/**
* @return the ownerId
*/
public long getOwnerId() {
return ownerId;
}



/**
* @param ownerId the ownerId to set
*/
public void setOwnerId(long ownerId) {
this.ownerId = ownerId;
}



/**
* @return the ownerName
*/
public String getOwnerName() {
return ownerName;
}



/**
* @param ownerName the ownerName to set
*/
public void setOwnerName(String ownerName) {
this.ownerName = ownerName;
}



/**
* @return the ownerKey
*/
public String getOwnerKey() {
return ownerKey;
}



/**
* @param ownerKey the ownerKey to set
*/
public void setOwnerKey(String ownerKey) {
this.ownerKey = ownerKey;
}



@Override
public String toString() {

return ToStringBuilder.reflectionToString(this);
}
}

Part IV : A Simple and Smart Result Mapper

2010-05-29T21:40:00.001-07:00

In my last post, I have shown how the dao support class changed to convert list of maps to list of domain objects. Now the DAO implementation class must also change to use these new methods. Here is the modified DAO class.
Listing – UserDaoImpl.java

package net.sf.dms.security.dao.impl;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.sf.dms.security.dao.api.UserDao;
import net.sf.dms.security.domain.User;
import net.sf.spring.dao.AbstractBaseDaoSupport;

/**
* @author dhrubo
* 
*/
public class UserDaoImpl extends AbstractBaseDaoSupport implements UserDao {

private Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);
@Override
public List<User> listUsers() {
return (List<User>)this.queryForList("listUsers", User.class);
}

@Override
public void save(User user) {
this.insert("saveUser", user.getEmail(),
user.getPassword(), user.getFirstName(), user.getLastName());
}

@Override
public void update(User user) {

}
@Override
public User findUserByUserName(String username) {
logger.debug("Loading user details as part of authentication");
return (User)this.queryForObject("findUserByUserName", User.class, username);  
}

@Override
public List<User> findUsersStartingWith(String nameStartsWith) {
return (List<User>)this.queryForList("findUsersStartingWith", User.class, nameStartsWith + "%");  
}
}

Now you can see clearly that the list or finder queries have been reduced to just 1 line. I guess this code reduction is same as in any ORM or datamapper. Now let us see how the SQL has changed. I have tested this code on Postgresql 8.3 and should work with any sensible database available.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<bean id="secSqlMap" class="org.springframework.beans.factory.config.MapFactoryBean">
<property name="sourceMap">
<map>
<entry key="listUsers">
<value>
<![CDATA[
SELECT first_name "firstName",last_name "lastName",email "userCode",user_id "userId" FROM t_user

]]>

</value>

</entry>

<entry key="saveUser">
<value>
<![CDATA[
INSERT INTO t_user(user_id, email, password, first_name,last_name) VALUES (nextval('t_user_seq'), ?, ?, ?, ?)

]]>

</value>

</entry>

<entry key="findUserByUserName">
<value>
<![CDATA[
SELECT first_name "firstName",last_name "latName",email "userCode",user_id "userId" FROM t_user WHERE email = ?

]]>

</value>

</entry>

<entry key="findUsersStartingWith">
<value>
<![CDATA[
SELECT first_name "firstName",last_name "latName",email "userCode",user_id "userId" FROM t_user 
WHERE first_name LIKE ?;

]]>

</value>

</entry>

</map>


</property>
</bean>

</beans>

Now you can see my source of meta data and how I use them to run this simple data mapper and move towards my goal of lightweight persistence and database independence.

Part III : A Simple and Smart Result Mapper

2010-05-29T21:20:00.001-07:00

Now a days we make extensive use of Annotations. Whether it is a good or bad practice to mix configuration meta data with code is debatable, but its better than proprietary XML tags. Since we are so used to mixing meta data in our Java code, why not make use of same tactics in building our data mapper.
SQL statements in all databases supports something called an alias for column names. I will use this to map a SQL result column to a property in my bean. This is better because even if my column name changes but my alias remains same my bean will be populated properly.
I use JODD bean utils. You can download the JODD distribution here. A problem with JODD is that it is not available in any of the global maven repositories. So you need install the same in your local repository by running the following command
C:\>mvn install:install-file -Dfile=jodd-3.0.9.jar  -DgroupId=jodd -DartifactId=
jodd -Dversion=3.0.9 -Dpackaging=jar
Use the GUI screens if you are using Archiva repository manager.
I am on windows and I have kept my jar is located at C:\jodd-3.0.9.jar. It has no other dependencies.

Correction - As pointed out below in the comments section JODD is now available on Maven.

<dependency>
    <groupId>org.jodd</groupId>
    <artifactId>jodd-wot</artifactId>
    <version>3.1.0</version>
</dependency>

Here is the modified abstract dao support class.

package net.breezeware.spring.dao;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import jodd.bean.BeanUtil;


import org.apache.commons.lang.reflect.ConstructorUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;

/**
* @author dhrubo
*
*/
public abstract class AbstractBaseDaoSupport extends SimpleJdbcDaoSupport{
private Logger logger = LoggerFactory.getLogger(AbstractBaseDaoSupport.class);

private Map<String, String> sqlMap;


protected List<?> queryForList(String id, Class primaryType, Object ...params) {
String sql = sqlMap.get(id);
List<Map<String, Object>> mappedResultList = this.getSimpleJdbcTemplate().queryForList(sql, params);

return this.preapreList(mappedResultList, primaryType);
}

protected List<?> queryForList(String id, Class primaryType) {
List<Object> result = new ArrayList<Object>();
String sql = sqlMap.get(id);

List<Map<String, Object>> mappedResultList = this.getSimpleJdbcTemplate().queryForList(sql, new HashMap());
return this.preapreList(mappedResultList, primaryType);
}


protected Object queryForObject(String id, Class type, Object ...params) {
String sql = sqlMap.get(id);
Map<String, ?> dataMap = this.getSimpleJdbcTemplate().queryForMap(
sql, params);

return prepareObject(dataMap,type);
}

protected void insert(String id, Object ...params ) {
String sql = sqlMap.get(id);
this.getSimpleJdbcTemplate().update(sql, params);
}

private List<?> preapreList(List<Map<String, Object>> mappedResultList,Class primaryType) {
List<Object> result = new ArrayList<Object>();
Object holder = null;
for(Map<String, Object> resultMap : mappedResultList) {
holder = prepareObject(resultMap,primaryType);
result.add(holder); 
}

return result;
}
private Object prepareObject(Map<String, ?> resultMap, Class primaryType) {
Iterator<String> it = resultMap.keySet().iterator();
Object holder = getNewObjectInstance(primaryType);

String name = null;
Object value = null;

//set all the properties
while(it.hasNext()) {


name = it.next();
value = resultMap.get(name);

logger.debug("Mapping property = {}, value = {}",name,value);

BeanUtil.setPropertyForcedSilent(holder, name, value);
}

return holder;

}



private Object getNewObjectInstance(Class clazz) {
Object object = null;
try {
object = ConstructorUtils.invokeExactConstructor(clazz, null);
} catch (Exception e) {
throw new RuntimeException(e);
}
return object;
}

/**
* @param sqlMap the sqlMap to set
*/
public void setSqlMap(Map<String, String> sqlMap) {
this.sqlMap = sqlMap;
}


}

This class is by no means complete and is evolving. But it has the essential methods to get the ball rolling. This class uses the Spring JDBC to execute the SQL statements. The SQL statements are picked up from the externalized cache. It utilizes the meta data or column names in the SQL result set retrieved and populated by Spring JDBC as keys in those row maps. Note that in case a column does not have corresponding bean property, it will escape silently. With smart configuration (will show examples soon), this can support nested properties.

Part II : A Simple and Smart Result Mapper

2010-05-29T08:07:00.001-07:00

I am a big fan of Spring JDBC. The reasons are simple -

Full control over SQL. I can optimize, tweak and tune them to my free will. Let me think in terms of those tables and not objects.
Cuts down my DAO code significantly.
Takes care of all boilerplate code.
Integrates well with other parts of my application which mostly uses other Spring components.
Simple and easy to setup and get running at high speed
Minimal learning curve

One area where Spring framework does not do a good job is that of list/finder queries returning n number of records. Lets say you want to find the employees in a certain department. The query is executed and you get a map of records, but then you need to return a list of domain objects to the business tier. You will loop through the map list returned by Spring JDBC, for each of your record create a Javabean populate each field and then add to another list which will be finally returned. So there is lot of boilerplate code here. Look at the example code below, which fetches all users in my system.

public List<User> listUsers() {
String SQL_LIST_USER = "SELECT first_name,last_name,email,user_id FROM t_user";
        List<Map<String,Object>> users = this.getSimpleJdbcTemplate().queryForList(SQL_LIST_USERS,new HashMap());
        List<User> userList = new ArrayList<User>();
        User userHolder = null;
        for(Map<String,Object> user : users) {
            userHolder = new User();
            userHolder.setFirstName((String)user.get("first_name"));
            userHolder.setLastName((String)user.get("last_name"));
            userHolder.setUserCode((String)user.get("email"));
            userHolder.setUserId((Integer)user.get("user_id"));
            userList.add(userHolder);
        }
        return userList;
    }

There is significant redundant code here. If you notice carefully, if a column name changes this code will lead to errors. You may consider this mapping and listing in a row mapper, but still you need to write this code and unnecessarily add new classes per such list method for Spring JDBC callbacks.
So I looked for a data mapper. The best solution in this regard is iBatis. It is much simpler and has less learning curve compared to ORM and tries to do limited things. While playing with it I was once again struck by XML meta data hell. This time mapping each SQL with different maps. This could be some XML to maintain in a decently large project. Also it queries database multiple time if I need to populate object graphs. Also my attempts to integrate iBatis 3 with Maven 2 and Spring 3 failed with ClassNotFoundException. Hence my journey with iBatis ended very abruptly. I was looking for a smarter solution, which I could configure very easily, should be very simple, no learning curve, efficient and intuitive.
The solution was in Spring framework, bit of SQL trick and an external super efficient bean manipulation library called JODD - http://jodd.org/doc/beanutil.html
As a first step towards building this simple and smart data mapper, I want to externalize my SQLs. So I introduce an abstract dao support class which does load externalized SQLs from a Spring configuration file. Note I am not using any additional XML file for this. This will again lead same problems as in iBatis. Instead its better to stick to what I know best. Here is the first version of this abstract class.
Listing – AbstractBaseDaoSupport.java

package net.sf.webplug.spring.dao;  
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;  
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;  
/**
* @author dhrubo
*
*/
public abstract class AbstractBaseDaoSupport extends SimpleJdbcDaoSupport{
    private Logger logger = LoggerFactory.getLogger(AbstractBaseDaoSupport.class);
    private Map<String, String> sqlMap;  
    /**
     * @param sqlMap the sqlMap to set
     */
    public void setSqlMap(Map<String, String> sqlMap) {
        this.sqlMap = sqlMap;
    }
    public String getSql(String id) {

return this.sqlMap.get(id);
    }
}

Now I change my Dao class to use this abstract class instead.
Listing – UserDaoImpl.java

package net.sf.dms.security.dao.impl;  
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;  
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;  
import net.sf.dms.security.dao.api.UserDao;
import net.sf.dms.security.domain.User;  
/**
* @author dhrubo
* 
*/
public class UserDaoImpl extends AbstractBaseDaoSupport implements UserDao {  
    private Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);  
    @Override
    public List<User> listUsers() {
        String sql = this.getSql("listUsers");
        List<Map<String,Object>> users = this.getSimpleJdbcTemplate().queryForList(sql,new HashMap());
        List<User> userList = new ArrayList<User>();
        User userHolder = null;
        for(Map<String,Object> user : users) {
            userHolder = new User();
            userHolder.setFirstName((String)user.get("first_name"));
            userHolder.setLastName((String)user.get("last_name"));
            userHolder.setUserCode((String)user.get("email"));
            userHolder.setUserId((Integer)user.get("user_id"));
            userList.add(userHolder);
        }
        return userList;
    }  
}

The sql is now moved to an Spring config file (separate just for SQLs)
Listing – sql-repository.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
    <bean id="secSqlMap" class="org.springframework.beans.factory.config.MapFactoryBean">
        <property name="sourceMap">
            <map>
                <entry key="listUsers">
                    <value>
                        <![CDATA[
                            SELECT first_name ,last_name ,email ,user_id  FROM t_user
                        ]]>
                    </value>
                </entry>
                
            </map>
        </property>
    </bean>  
</beans>

Now that I have externalized the SQLs, its time to look into the main configuration file. There is something interesting here too.
Listing – applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <import resource="sql-repository.xml"/>
       <bean id="secDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="org.postgresql.Driver"/>
        <property name="url" value="jdbc:postgresql://localhost:5432/dms"/>
        <property name="username" value="postgres"/>
        <property name="password" value="postgres"/>
    </bean>
    <bean id="abstractSecBaseDaoSupport" class="net.sf.spring.dao.AbstractBaseDaoSupport" abstract="true">
            <property name="dataSource" ref="secDataSource"/>
            <property name="sqlMap" ref="secSqlMap"/>
    </bean>
    <bean id="userDao" class="net.sf.dms.security.dao.impl.UserDaoImpl" parent="abstractSecBaseDaoSupport" />
    <bean id="roleDao" class="net.sf.dms.security.dao.impl.RoleDaoImpl" parent="abstractSecBaseDaoSupport"/>
    <bean id="userRoleDao" class="net.sf.dms.security.dao.impl.UserRoleDaoImpl" parent="abstractSecBaseDaoSupport"/>
</beans>

Note the abstract class configuration. I do not need to configure the data source property for each dao class anymore. This ends my first step of clean up. In the next post I will show how to extend the abstract class to provide mapper functions.

Part I : A Simple and Smart SQL Result Mapper

2010-05-29T06:04:00.001-07:00

I am not at all a fan of ORM solutions/frameworks like Hibernate. I have already written and presented my view on different forums and discussions the reasons for my disliking. I truly empathize with Ted Neward that ORM are “Vietnam of Computer Science”.
http://www.codinghorror.com/blog/2006/06/object-relational-mapping-is-the-vietnam-of-computer-science.html
http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.aspx
Followup - http://blogs.tedneward.com/2006/06/27/Thoughts+On+Vietnam+Commentary.aspx
http://stackoverflow.com/questions/404083/is-orm-still-the-vietnam-of-computer-science
Some counter punches
http://www.codeproject.com/KB/architecture/ORM_Vietnam.aspx?display=Print

I am not convinced as to why should I learn HQL or similar QLs provided by other OR Mapping solutions? Why should I not write and benefit from SQLs which have been proven to be so powerful over the ages and often outlive the lifetime of an application. So many times I have seen SQLs and Stored procedures being reused as applications moved from say .NET to Java and vice-versa.
There is significant learning curve to an ORM add to those fancy concepts like lazy loading(if you need lazy loading you must first think that there is some problem, why are you afraid of object creation with modern day JVM and hardware or is it that you fear you will create too many objects?).
Why do I generate, tweak so many XMLs worry about so much XML based syntaxes, how do I efficiently manage these XMLs and alter later if required? There are too many XML elements and attributes some hidden undocumented? Oh this is real pain. Annotations solve some of the meta data hell, but I am still in a dilemma if mixing meta data with code is a good practice?
Why do think of my joins in terms of objects when they are best done with relational tables? Sorry I can only think of joining tables and not my objects.Live and let them live in their own world.
There is no doubt ORMs are powerful and tries to make life easy. But the learning curve and deadline pressures often forces developers with somehow acquired knowledge by reading few articles and getting started guides from here and there to code and then finally when issues crop up especially too many objects, JVM crashes and sever performance worries the application falls apart and you focus more on solving these than business logic.
Even dangerous trend that I see these days is the advent of ORM specific profilers. What does this imply? Yes the ORMs are serious cause for performance bottlenecks in your applications. I know someone came to me few months back, asking why his JVM crashes when he is running his search queries and paging? His table just had about 150k records and JVM heap was 2GB. Not a bad setting at all? Is it because the ORM was fetching a significant subset of the records based on the search criteria,first to application server before starting pagination? or my friend had a bad QL statement?
I know ORMs can help with optimistic lock? But do they help with phantom records problem?
Why should I cache on application server and allow or create a slightest possibility of my JVM to burst? Does caching on JVM really increase the application performance? I always knew and still continue to believe the best place to cache database records is in the database memory. Can we not gain on performance by keeping these data to where it belongs, which have been long tuned and proven to optimize performance, reducing network trips, setting tips to bulk fetch data when required, fetch data in optimal blocks? You may be tempted to use caching systems which hides behind the ORM. But think in case of an issue you have the pain of learning another framework and then fixing your errors, if Googling does not help.
How does your ORM populate the object graph? Does it fire query after query going down the graph? If yes think about the domain model? Or think about your ORM implementation? Is there any way out? My answer is yes, smart SQL + smart mapping. I will try to show this with an example.
However, ORMs are good, if you have indepth knowledge of the framework under consideration. Then with an ORM you can significantly cut down code in your DAO layer. This is also a myth. With Spring JDBC you can reduce your code even more or equal to what you can with an ORM. You can read an article I wrote long back on OTN(actually wrote in erstwhile BEA DEV2DEV) here to start thinking about this - http://www.oracle.com/technology/pub/articles/dev2arch/2006/10/spring-jdbc-dao.html
One area I thought I might use ORM is when I design a product which needs to support multiple databases. But then I realised this is not true, if we manage to externalize our SQL and have an efficient strategy to map SQL result set to our domain object we can achieve database independence. 99% of the applications are not meant to be db independent. If your customer has investment so much money to procure license, build competency buy hardware for that big blackbox for Java developers called RDBMS why would he want that box of money, time and effort go down the drain by replacing it with another. So if you are trying to sell me an ORM for db independence I will not simply not buy in.
ORMs dependent on several 3rd party libraries. Do I need to increase 3rd party dependencies? Yes you will need 3rd party jars but we must make effort to keep them to minimal. There may be version collisions between 3rd party libraries used by your ORM and main framework.

A custom plug-in system for web applications

2010-05-20T02:39:00.001-07:00

Recently I was trying to put together a plugin system for web applications. The idea is similar to Eclipse plugins. Where you bundle your extension in a jar and then drop them in Eclipse-Home/plugins folder, restart Eclipse and you are ready to use it. Note that Eclipse plugins are OSGi plugins.

So my initial effort was to see if I could build a pluggable web application with OSGi. After few experiments with Equinox (the Eclipse OSGi engine) and Felix, I moved on to check out Spring DM as well as Spring DM server. But all I all I felt that

OSGi / DM involves significant learning curve.
The web server bundles are “probably” not of enterprise strength.
Still trying to gel with JEE.
Significant extra effort required to port applications to OSGi platform.

All in all OSGi / DM has to go few more miles before we build Enterprise server apps using those containers / bundles. But its a very good start and promises a lot in the future.

So what to do? I started digging dip into Spring framework for a while and soon came up with an idea of a simple plug-in system for web applications. This plug-in system should allow you to package your application components(controllers,business objects, data acccess) in a jar file with mandatory Spring config file. This jar file should be dropped in WEB-INF/lib and should be ready for use once the web container is restarted or this application is restarted. It should also allow you to package your view components as well in the jar.

In the next few posts I will try to show how such a simple yet effective system can be build by extending the Spring framework. I will also show some good practices that I learnt while building applications with this framework extension which I call WebPlug. The code and documentation will be available soon on Sourceforge.

SecurityContextPersistenceFilter

2010-04-24T08:10:00.001-07:00

This bean is configured as shown below:
<bean id="securityContextPersistenceFilter" class="org.springframework.security.web.context.SecurityContextPersistenceFilter"/>
This bean has two main tasks and they are very important

In a typical web application like Skyphoto the user will login once and then subsequently do several operations or click several links and buttons generating several authenticated requests to the server. Since the user was authenticated once it is important to store the security context somewhere and by some means. Otherwise he/she has to authenticate for each request and will sooner or later never use Skyphoto. In a typical web application you will store an user object in HttpSession and each time a request comes in, the server identifies this session with a session id and you get the user object. It is the responsibility of the server to cache/store and manage these session objects during the lifetime of the session.

“In Spring Security, the responsibility for storing the SecurityContext between requests falls to the SecurityContextPersistenceFilter, which by default stores the context as an HttpSession attribute between HTTP requests. It restores the context to the SecurityContextHolder for each request….”

The SecurityContextPersistenceFilter stores the security context in ThreadLocal for the current execution. Hence it is essential to clear this thread local object in a web application as the server uses a pool of thread and chances are that this thread will be reused. If this security context is not cleared there is a high possibility that the set information will be used for request from a different user leading to unpredictable results and possible violation of security.

The SecurityContextPersistenceFilter takes care of clearing the security context object from thread local once the request completes.

This filter MUST be executed BEFORE any authentication processing filter. Authentication processing mechanisms used in those filters expect the SecurityContextHolder to contain a valid SecurityContext by the time they execute.
The task of saving and retrieving the security context is delegated to a separate strategy interface SecurityContextRepository. The interface is shown below:
public interface SecurityContextRepository {
SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder);
void saveContext(SecurityContext context, HttpServletRequest request,
HttpServletResponse response);
}
“The HttpRequestResponseHolder is simply a container for the incoming request and response objects, allowing the implementation to replace these with wrapper classes. The returned contents will be passed to the filter chain.”
The default implementation of SecurityContextRepository is the HttpSessionSecurityContextRepository class. As the name suggests it stores the security context as an HttpSession attribute.This class has an important attribute - allowSessionCreation which by default is set to true. Hence this class can create a new session if it needs to for storing security context of an authenticated user. Note that session is only created after authentication is done and contents of security context now has been changed with authenticated user information. If you want to prevent session creation, then set this parameter to false. A sample configuration is shown below.
<bean id="securityContextPersistenceFilter" class="org.springframework.security.web.context.SecurityContextPersistenceFilter"> <property name='securityContextRepository'>
<bean class='org.springframework.security.web.context.HttpSessionSecurityContextRepository'> <property name='allowSessionCreation' value='false' />
</bean>
</property>
</bean>

How the filter chain works?

2010-04-24T06:06:00.001-07:00

Going back to the filter chain configuration in my last post, you can see a chain filters configured as shown below:
<bean id="springSecurityFilterChain" class="org.springframework.security.web.FilterChainProxy">
<sec:filter-chain-map path-type="ant">
<sec:filter-chain pattern="/SkyPhotoWeb/**" filters=" securityContextPersistenceFilterWithASCFalse, basicAuthenticationFilter, exceptionTranslationFilter, filterSecurityInterceptor" />
<sec:filter-chain pattern="/**" filters=" securityContextPersistenceFilterWithASCTrue, formLoginFilter, exceptionTranslationFilter, filterSecurityInterceptor" />
</sec:filter-chain-map>
</bean>
Let us assume that a request is send as http://www.skyphoto.com/SkyPhotoWeb/dosomething.html the request runs through the filters as shown in picture below:

In my next post I will explain all these and few other important filters in greater detail.

Let us look at the Spring security filter chain

2010-03-27T00:15:00.001-07:00

DelegatingFilterProxy

The DelegatingFilterProxy is a special filter provided by the Spring framework.It acts as a bridge connecting
the web container and spring application container. In other words it helps pipeline request processing
from the web container filter to a bean in Spring web application context.

DelegatingFilterProxy is configured in the web.xml as shown below:

<filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>

<filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>


DelegatingFilterProxy is essentially a dumb filter and implements no logic. Its sole responsibility is to delegate the Filter's methods through to a bean which is obtained from the Spring application context. This enables the bean to benefit from the Spring web application context lifecycle support and configuration flexibility.
This bean must implement javax.servlet.Filter and it must have the same name as that in the filter-name element.

FilterChainProxy

DelegatingFilterProxy is actually connected to a FilterChainProxy in the Spring application context.
The FilterChainProxy bean has the same name as the filter name in the web.xml
You all must be very bored hearing this again again. I am trying to get this deep into your head
as it is one area of common configuration mistake and subsequent head banging. Trivial errors are
always difficult to locate.

In our case the FilterChainProxy was configured by the namespace configuration. A typical FilterChainProxy
would look like this:

<bean id="springSecurityFilterChain" class="org.springframework.security.web.FilterChainProxy">
<sec:filter-chain-map path-type="ant">
     <sec:filter-chain pattern="/SkyPhotoWeb/**" filters="
           securityContextPersistenceFilterWithASCFalse,
           basicAuthenticationFilter,
           exceptionTranslationFilter,
           filterSecurityInterceptor" />
     <sec:filter-chain pattern="/**" filters="
           securityContextPersistenceFilterWithASCTrue,
           formLoginFilter,
           exceptionTranslationFilter,
           filterSecurityInterceptor" />
</sec:filter-chain-map>
</bean>

Now from the documentation -
"The namespace element filter-chain-map is used to set up the security filter chain(s) which are required within the application.
It maps a particular URL pattern to a chain of filters built up from the bean names specified in the filters element.
Both regular expressions and Ant Paths are supported, and the most specific URIs appear first.
At runtime the FilterChainProxy will locate the first URI pattern that matches the current web request and the list of filter beans specified
by the filters attribute will be applied to that request.
The filters will be invoked in the order they are defined, so you have complete control over the filter chain which is applied to a particular URL."

As you may have already guessed the bean names in the filters atrribute is a comma separate list of
bean names configured in the Spring context. For the moment assume that they are there. I will come back to put them into action and lecture
more about them.

Now let us look into the lifecycle aspect of the FilterChainProxy.Today being a weekend, I am feeling a bit lazy so will
copy and paste again from the official documentation which gives very good information on the lifecycle aspects.

"In relation to lifecycle issues, the FilterChainProxy will always delegate init(FilterConfig) and destroy()
methods through to the underlaying Filters if such methods are called against FilterChainProxy itself.
In this case, FilterChainProxy guarantees to only initialize and destroy each Filter bean once,
no matter how many times it is declared in the filter chain(s).
You control the overall choice as to whether these methods are called or not via the targetFilterLifecycle initialization parameter
of DelegatingFilterProxy.
By default this property is false and servlet container lifecycle invocations are not delegated through DelegatingFilterProxy."

Thats it for now. I know you guys are getting bored with theory. Please be patient, I will drop in few more theory session, and
soon get back to hands on stuff.

Pause - lets look inside Spring Security

2010-03-14T22:39:00.000-07:00

So far we have been quick to setup Spring Security and apply it in our application. But behind that minimal configuration and non-invasive behavior lot has been happening behind the scenes.
It is time to uncover the activities under hood, draw some diagrams to understand the framework and move ahead in style. I will not draw out all the balls from the magic box now. Instead will slowly take out one ball at a time to make it slow and easy to comprehend and assimilate.

Let us go back to the web.xml configuration. You will see that we have configured a DelegatingFilterProxy. This filter is named 'springSecurityFilterChain'. The delegating filter proxy looks for a bean named 'springSecurityFilterChain' in the root Spring web application context. So note that this name is kind of a reserved bean name and should not be used elsewhere. The delegating filter proxy as the name suggests delegates the entire security processing then to the beans declared in the Spring web application context/ or security context. Now the question in your mind is that you never declared a bean with name - 'springSecurityFilterChain' , then from where on earth did the delegating filter proxy get it and the framework started running? Well the 'springSecurityFilterChain' bean is created by the declaration <http>....</http>

There is a lot to learn and understand with this namespace configuration - <http&gt. So it needs a be enjoyed slowly like a good whisky.

You must have already understood that Spring Security is based on servlet filters. This is what the official documentation says - "Spring Security's web infrastructure is based entirely on standard servlet filters. It doesn't use servlets or any other servlet-based frameworks (such as Spring MVC) internally, so it has no strong links to any particular web technology. It deals in HttpServletRequests and HttpServletResponses and doesn't care whether the requests come from a browser, a web service client, an HttpInvoker or an AJAX application. Spring Security maintains a filter chain internally where each of the filters has a particular responsibility and filters are added or removed from the configuration depending on which services are required. The ordering of the filters is important as there are dependencies between them. "

Just to extract the keywords - irrespective of the source of http request the intercepting filter (configured as a delegating filter proxy in web.xml) hands over the actual security processing to a filter chain configured internally or Spring web application context. The request passes through each of the internal filters and is processed depending on what are the security requirements of the application or what customization has been done. Note you can very well introduce your own filter.Also note that the order of the filter in the filter chain is very important and there may be dependencies between filters in the chain. A filter coming later in the chain may depend on some data produced by filter coming earlier in the chain. I will dig deep into all these and also take indepth look into different filters that are available out of the box and also try to show the use of a custom filter in the chain.

Since we used the new namespace based configuration, the required filters are automatically configured and no bean needs to be explicitly configured. But sometimes fine grained control is required (and these may not be supported in namespace based configuration). In this case it is very well possible to get full control over the filter chain and the filters.

Now I leave you with a big picture of Spring security. In my next post I will to uncover more details about Spring security and its filters. I will blow out that yellow box more in the next post.

Adding anonymous or guest access

2010-03-13T21:38:00.001-08:00

As you have seen in my previous post the access to index.html was restricted. Whenever the user tries to access this page they were redirected to the login page. But this should not be case. The logical index.html page should be accessible to guest users as well as authenticated users.
Turning this on is just a matter of configuration. This is shown in the modified spring-security.xml file.

Listing 1 - spring.security.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans:beans xmlns="http://www.springframework.org/schema/security"
xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.0.xsd">

<http auto-config='true'>
<intercept-url pattern="/index.html" access="IS_AUTHENTICATED_ANONYMOUSLY" />
<intercept-url pattern="/**" access="ROLE_USER" />
</http>


<authentication-manager>
<authentication-provider>
<user-service>
<user name="jimi" password="jimispassword" authorities="ROLE_USER, ROLE_ADMIN" />
<user name="bob" password="bobspassword" authorities="ROLE_USER" />
</user-service>
</authentication-provider>
</authentication-manager>


</beans:beans>

I have now added a new intercept url line.

<intercept-url pattern="/index.html" access="IS_AUTHENTICATED_ANONYMOUSLY" />

This line makes it possible to access index.html as a guest user. Now when you click on any link on the index.html page
you will redirected to the login page in case you have not signed in.

In my next post I will try to get into some theoritical details / framework internals before
proceeding to the next round of coding and adding additional features.

Enabling Spring Security

2010-03-12T20:05:00.000-08:00

1> Add few more jars in your WEB-INF/lib folder.
The current view of jars is shown in the figure below.

2> Add a new member named - spring-security.xml in the WEB-INF/config folder. The contents of this file is shown in Listing 1 below:

Listing 1 - spring-security.xml


<?xml version="1.0" encoding="UTF-8"?>

<beans:beans xmlns="http://www.springframework.org/schema/security"
 xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/security
        http://www.springframework.org/schema/security/spring-security-3.0.xsd">

 <http auto-config='true'>
     <intercept-url pattern="/**" access="ROLE_USER" />
 </http>


 <authentication-manager>
     <authentication-provider>
         <user-service>
             <user name="jimi" password="jimispassword" authorities="ROLE_USER, ROLE_ADMIN" />
             <user name="bob" password="bobspassword" authorities="ROLE_USER" />
         </user-service>
     </authentication-provider>
 </authentication-manager>


</beans:beans>

This is the bare minimum configuration you need to do to get Spring Security started. This is a great relief for those of you who had worked with earlier versions of Spring Security or its ancestor Acegi Security. You had to explicitly configure the entire filter chain. That was tedious and very cumbersome leading to lot of errors and time and effort going down the drain. Thanks Ben and team for this good change. I will explain the different elements in this configuration in future posts as the intention of this post is to quickly get started with Spring Security as promised earlier.

Step 3 - wire everything now in the web.xml. The modified web.xml looks like the one shown below.


<?xml version="1.0" encoding="UTF-8"?>
<web-app id="SkyPhotoWeb" version="2.4"
 xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 <display-name>SkyPhotoWeb</display-name>

 <!-- Log4j config location -->
 <context-param>
     <param-name>log4jConfigLocation</param-name>
     <param-value>/WEB-INF/config/log4j.xml</param-value>
 </context-param>

 <!-- security beans are here -->
 <context-param>
     <param-name>contextConfigLocation</param-name>
     <param-value>
          /WEB-INF/config/spring-security.xml
     </param-value>
 </context-param>


 <!-- Log4j listener -->
 <listener>
     <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
 </listener>


 <!-- Root web application context -->
 <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>



 <!-- Spring security filters -->
 <filter>
     <filter-name>springSecurityFilterChain</filter-name>
     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
 </filter>

 <filter-mapping>
     <filter-name>springSecurityFilterChain</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>


 <!-- Spring MVC Frontcontroller servlet -->
 <servlet>
     <servlet-name>skyphotoservlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>
            /WEB-INF/config/spring-web.xml          
   </param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
     <servlet-name>skyphotoservlet</servlet-name>
     <url-pattern>*.html</url-pattern>
 </servlet-mapping>


</web-app>

There are a few things to note here.

We have setup DelegatingFilterProxy which will look for a bean springSecurityFilterChain in the spring root web application context.
The springSecurityFilterChain bean is setup automatically by the tag.
The DispatcherServlet only has a specific web application context and hence you need to load the root web application context using the ContextLoaderListener. For now this listener only loads the security related beans in the root web application context.
The ContextLoaderListener must be configured after the log4j listener if the later is used.
If you do not use the ContextLoaderListener you will encounter the following exception

java.lang.IllegalStateException: No WebApplicationContext found: no ContextLoaderListener registered?

Now that we are all set its time for testing. So launch your favorite browser (mine is Mozilla Firefox) and type the following:
http://localhost:8080/SkyPhotoWeb/index.html

** By the way I am deploying on Tomcat 6 running on JRE 6.

You will be redirected to a login page shown in figure below.

This is a Spring security framework generated login page. Although the desired result is not what we intended (we donot want that the index page is accessed securily rather by all users and guests) but it is clear that Spring Security is up and running, integrated into our Spring MVC application. I will try to correct this in my future post.Also I will show how you how you can add a custom your application specific login page.

Now let us supply the user id and password (jimi/jimispassword) and see what happens. You will be redirected to the index.html page. So it also suggests that Spring Security remembers what you tried prior to signing in.

Thats all for today hopefully. If I find time between watching Indial Premier League and World Field Hockey Finals I will try to clarify a few concepts later in the day.

Getting the security less application ready

2010-03-12T03:39:00.000-08:00

1> Add jstl.jar (version 1.1 i guess) to your WEB-INF/lib folder
2> Modify index.jsp as shown below
Listing 1 - index.jsp


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Sky Photos home</title>
</head>
<body>
<h1>Welcome to Sky Photos</h1>
<p>Not an user yet? <a href="#">Register</a></p>
<p><a href="viewphotoupload.html">Upload Photo</a></p>
</body>
</html>

3> Add a controller for the landing or index page.
Listing 2 - EntryController.java


/**
*
*/
package org.opengarage.skyphoto.web.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
* @author dhrubo
*
*/
@Controller
public class EntryController {
 
 @RequestMapping("/index")
 public String viewLanding(){
  return "index";
 }
}

4> Add a controller for the upload page view
Listing 3 - UploadController.java
/**
*
*/
package org.opengarage.skyphoto.web.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
* @author dhrubo
*
*/
@Controller
public class UploadController {
@RequestMapping("/viewphotoupload")
public String viewPhotoUpload(){
return "upload";
}
}

5> Time to launch the browser and test it on the browser.

6> Click on upload photo, you will see it is accessible to any one. But only logged on users should be able to access that page.

In the next post I will start with the first step to ensure that a user is logged in / signed in before he or she can access the upload photo page.

Adding few more JSPs and Security Requirements

2010-03-11T21:18:00.000-08:00

Now I will add two more JSPs – one is the home page showing some dashboard information and the other is the file upload JSP which will be used to upload photos.

Listing 1 – home.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Sky Photo - Home</title>
</head>
<body>
<h1>Dashboard</h1>
</body>
</html>

Listing 2 – upload.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Sky Photo - Upload</title>
</head>
<body>
<h1>Upload A Photo</h1>
</body>
</html>

Requirement

index.jsp should be accessible without any security filtering
home.jsp should be accessible only to registered users
upload.jsp should only be accessible to registered users

Since the JSPs are placed under WEB-INF in any case no one can directly access it. So in the next post I will try to add a few page controllers to the scheme of things to make these pages accessible without any application security credentials.

Setting up Spring MVC 3 Web Application

2010-03-11T06:25:00.000-08:00

Now its time to code a bit in Skyphoto. So launch Eclipe and create a dynamic web project ready to be deployed on Tomcat 6. I am assuming that readers are atleast familiar with this. Next we will do a bit of configuration and throw in some Spring 3 jar files into the WEB-INF/lib folder.

Step 1 - Configure Spring Servlets and log4j in the web application deployment descriptor.


<?xml version="1.0" encoding="UTF-8"?>
<web-app id="SkyPhotoWeb" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>SkyPhotoWeb</display-name>

<!-- Log4j config location -->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/config/log4j.xml</param-value>
</context-param>
<!-- Log4j listener -->
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

<!-- Spring MVC Frontcontroller servlet -->
<servlet>
<servlet-name>skyphotoservlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
        
            /WEB-INF/config/spring-web.xml
         
   </param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>skyphotoservlet</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>



</web-app>

Step 2 - log4j.xml
The log4j configuration will be very useful later to see all framework and application messages. I have set it to debug level to help understand the framework better.


<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<!-- ====================================================================== -->
<!-- A P P E N D E R S                                                      -->
<!-- ====================================================================== -->

<!-- console -->
<appender name="console" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
   <param name="ConversionPattern" value="%d{dd.MM.yyyy HH:mm:ss} *%-5p* %c{1}: %M - %m - (%F, line %L)%n"/>
</layout>
</appender>


<appender name="file" class="org.apache.log4j.FileAppender">
<param name="File" value="C:/logs/skyphotos.log"/>
<layout class="org.apache.log4j.PatternLayout">
   <param name="ConversionPattern" value="%d{dd.MM.yyyy HH:mm:ss} *%-5p* %c{1}: %m (%F, line %L)%n"/>
</layout>
</appender>

<!-- ====================================================================== -->
<!-- L O G G E R S                                                          -->
<!-- ====================================================================== -->

<root>
<level value="debug" />
<appender-ref ref="console"/>
<appender-ref ref="file"/>
</root>

</log4j:configuration>

Step 3 - Setting up a bare minimal spring configuration file Listing 3 - spring-web.xml



<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">


<context:component-scan base-package="org.opengarage.skyphoto.web.controller" />


<bean id="jstlviewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView"></property>
<property name="prefix" value="/WEB-INF/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>

<bean id="annotationMapper"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
</bean>

<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver" />

<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>


</beans>

Step 4 - setup a simple jsp Listing 4 - index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Sky Photos Home</title>
</head>
<body>
<h1>Welcome to Sky Photos</h1>
<a href="#">Login</a>
</body>
</html>

Finally here is a view of the Eclipse project. You can very well make out the jar files you need for the time being.

Note 1 - that I am storing all configuration files under /WEB-INF/config

Note 2 - donot forget to download Spring framework and Security security distributions from their respective websites.

Exploring Spring Security 3

2010-03-11T06:12:00.000-08:00

I am finally back to writing again after an absence of almost year and half. I will try to be more regular from now now. In this edition I will start with Spring Security 3. This will be a series of posts where I will try to build a very simple photo uploading and sharing service. This is actually my PoC with Spring Security 3.

Spring Security unlike most Spring product portfolio is a not at all well documented. The tutorials available on googling are mostly outdated. Spring Security 3 certainly by look of things seems to be a very good feature rich product yet hefty beast. So here is my attempt to conquer it.

Skyphoto Basic Requirements

Securely upload photos into your account
Download photos
Share photos with friends and other application

In the course of this simple application development I will try to uncover most of the features of Spring Security. I will use Restful services support provided by Spring MVC so that I can expose a simple API for external applications which will consume the services of Skyphoto.

Changing the root web application in Tomcat 6

2008-12-30T08:10:00.001-08:00

These days I am very busy developing a large and complex web application, which is nearing its first release. This web based product runs on Tomcat 6 and will be deployed on http://www.mydomain.com

But if I deploy my web application on Tomcat 6, I need to specify the context root. Well this is no good, why will the users of this website be willing to remember the context root. What if the context root changes. In other words the users would not be interest in typing the following - http://www.mydomain.com/myappcontext to visit this site.

Hence it is necessary that I change the default / root web application of Tomcat and point it to my application. I wanted to try and test this on localhost first. As always I Googled and found a number of posts and none seem to work. I also read the documentation it was helpful in understanding the concepts but was not effective as I could not get it working. Finally after few hours of trial and error one of my colleague Joyeeta Majumdar found the solution. Here it is step by step account.

1> I use Maven 2 + Eclipse 3.4 to build my web application. If I run the Maven 'install' goal the web application is generated in the target folder. It is available both as .war file and in exploded form. In my case it generated as Jing-Web-0.0.1-SNAPSHOT and Jing-Web-0.0.1-SNAPSHOT.war in the folder c:\jingworkspace\Jing-Web-Main\Jing-Web\target

2> Create a folder <engine>/<hostname>. In my case - Catalina\localhost. This folder is created under <Tomcat_Home>/conf. In my case this is C:\tomcat6\conf.

3> Create a file named ROOT.xml (case-sensitive) in the C:\tomcat6\conf\Catalina\localhost folder.

4> Here is the content of my ROOT.xml file

<?xml version='1.0' encoding='utf-8'?>

You will need to change the docBase attribute to the location of the exploded web application.

No changes to be made either in server.xml or context.xml located in c:\tomcat6\conf folder.

Now try http://localhost:8080/ and it should take us to Jing-Web application. You may need to delete the contents of your browser cache(press F5) to view the changes. You may also need to delete the contents of <Tomcat_Home>/work directory to get this working.

Consuming a JMS Message from ActiveMQ using Spring Message Driven POJO

2008-12-21T02:32:00.001-08:00

In my last post, I had shown how you can post a JMS message to a ActiveMQ queue. In this post I will show the reverse process. I will not try to consume this message using a Spring Message Driven POJO. I assume your familiarity with Spring MDP. If not you can look here - http://static.springframework.org/spring/docs/2.5.x/reference/jms.html

The operation that I intend to carry out is depicted in Figure 1.

Figure 1 - Consuming JMS message using Spring MDP

Step 1 - Create the message listener.

Listing 1 - EventMessageConsumer.java

/**
*
*/
package org.opengarage.pingscape.mq.consumer;

import javax.jms.Message;
import javax.jms.MessageListener;

/**
* @author dhrubo
*
*/
public class EventMessageConsumer implements MessageListener {

    /* (non-Javadoc)
     * @see javax.jms.MessageListener#onMessage(javax.jms.Message)
     */
    public void onMessage(Message message) {
        System.out.println("Message Consumed -"+message);
        //TODO : Take some action.... invoke service method

//NOTE : Service object is injected by Spring framework

}

}

Step 2 - Wire up the bean in Spring configuration

Listing 2 - spring-activemq-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL">
            <value>tcp://localhost:61616</value>
        </property>
    </bean>
    <bean id="queue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg>
            <value>queue.opengarage</value>
        </constructor-arg>
    </bean>
   
   <bean id="connectionFactory"
        class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory">
            <ref local="jmsFactory" />
        </property>
    </bean>
    
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
    </bean>
    
    <bean id="messageProducer"
        class="org.opengarage.pingscape.mq.producer.EventInvitationMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate" />
        <property name="queue" ref="queue" />
        <property name="messageCreator">
            <bean class="org.opengarage.pingscape.mq.producer.EventMessageCreator" />
        </property>
    </bean>
    
    
    <bean id="messageListener"
        class="org.opengarage.pingscape.mq.consumer.EventMessageConsumer" />

<bean id="jmsContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="queue" />
        <property name="messageListener" ref="messageListener" />
    </bean>
</beans>

Step 3 - Test

Finally you can see the results of message produced and consumed in the Admin web console as shown in Figure 2.

Figure 2 - Queue statistics

Sending JMS message to ActiveMQ using Spring 2.5 from a web application

2008-12-21T01:03:00.001-08:00

In this post I will show how you can send JMS message to ActiveMQ from your Spring web application. I have a Spring 2.5 + JBOSS Richfaces based web application that runs on Tomcat 6 running on JDK 5. Figure 1. depicts what I intend to do.

Figure 1. - Send JMS Message to ActiveMQ using Spring from a web application.

Step 1: Drop in the following jars to WEB-INF/lib

activemq-core-5.2.0.jar
jms.jar
geronimo-j2ee-management_1.0_spec-1.0.jar

Step 2: Create the destination/Queue using the ActiveMQ admin web application.

Launch your browser and point it to - http://localhost:8161/admin/

Figure 2. - ActiveMQ admin console.

Click on 'Queues' to navigate to queue list and create screen. You will need to supply the queue name and click on 'Create' to create a new queue destination on ActiveMQ server. This is shown in Figure 3.

Figure 3 - Create a new Queue.

Step 3. Create a message producer interface.

This may not be necessary, but since I prefer to implement Program to Interface in my application i define a message producer interface. This is shown in Listing 1.

Listing 1 - MessageProducer.java

/**
*
*/
package org.opengarage.pingscape.mq.producer;

/**
* @author dhrubo
*
*/
public interface MessageProducer {
public void send(Object message);
}

This interface defines a single method(can have more, but for now this will suffice) which accepts an object (Java bean) which will be passed to the Queue.

Step 4. An implementation of the MessageProducer interface

This class is responsible for sending a particular Javabean object to the queue (your goal may be different / may want to send something different).

Listing 2 - EventInvitationMessageProducer.java

/**
*
*/
package org.opengarage.pingscape.mq.producer;

import javax.jms.Queue;

import org.opengarage.pingscape.bean.Event;
import org.springframework.jms.core.JmsTemplate;

/**
* @author dhrubo
*
*/
public class EventInvitationMessageProducer implements MessageProducer{
    private JmsTemplate jmsTemplate;
    private Queue queue;
    private EventMessageCreator messageCreator;
    /**
     * @param jmsTemplate the jmsTemplate to set
     */
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
    /**
     * @param queue the queue to set
     */
    public void setQueue(Queue queue) {
        this.queue = queue;
    }

    /**
     * @param messageCreator the messageCreator to set
     */
    public void setMessageCreator(EventMessageCreator messageCreator) {
        this.messageCreator = messageCreator;
    }

    public void send(Object message) {
        this.messageCreator.setEvent((Event)message);
        this.jmsTemplate.send(this.queue, this.messageCreator);
    }

}

The key is the send method. It uses a MessageCreator to consume the supplied Event object. It then uses the JmsTemplate to send this message to the destination.

Step 5. Provide the message creator implementation

Listing 3 - EventMessageCreator.java

/**
*
*/
package org.opengarage.pingscape.mq.producer;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;

import org.opengarage.pingscape.bean.Event;
import org.springframework.jms.core.MessageCreator;

/**
* @author dhrubo
*
*/
public class EventMessageCreator implements MessageCreator {
    private Event event;
    /* (non-Javadoc)
     * @see org.springframework.jms.core.MessageCreator#createMessage(javax.jms.Session)
     */
    public Message createMessage(Session session) throws JMSException {
        ObjectMessage objectMsg = session.createObjectMessage();
        objectMsg.setObject(event);
        return objectMsg;
    }
    /**
     * @param event the event to set
     */
    public void setEvent(Event event) {
        this.event = event;
    }

}

Step 6 - Wire up in Spring configuration

Listing 4 - spring-activemq-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL">
            <value>tcp://localhost:61616</value>
        </property>
    </bean>
    <bean id="queue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg>
            <value>queue.opengarage</value>
        </constructor-arg>
    </bean>
    
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory">
      
            <bean class="org.springframework.jms.connection.SingleConnectionFactory">
                <property name="targetConnectionFactory">
                    <ref local="jmsFactory" />
                </property>
            </bean>
        </property>
    </bean>
    
    <bean id="messageProducer" class="org.opengarage.pingscape.mq.producer.EventInvitationMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate"/>
        <property name="queue" ref="queue"/>
        <property name="messageCreator">
            <bean class="org.opengarage.pingscape.mq.producer.EventMessageCreator"/>
        </property>
    </bean>
</beans>

Step 7 - Client of the message producer

Now we need a client to use the message producer. The Event business service class will use this message producer. This is shown in Listing 5.

Listing 5 - EventServiceImpl.java

/**
*
*/
package org.opengarage.pingscape.service.impl;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.opengarage.pingscape.bean.Event;
import org.opengarage.pingscape.business.api.EventService;
import org.opengarage.pingscape.mq.producer.MessageProducer;

/**
* @author dhrubo
*
*/
public class EventServiceImpl implements EventService {
    private static final Log _LOG = LogFactory.getLog(EventServiceImpl.class);

    private MessageProducer messageProducer;

    /* (non-Javadoc)
     * @see org.opengarage.pingscape.business.api.EventService#saveEvent(org.opengarage.pingscape.bean.Event)
     */
    public void saveEvent(Event event) {
        messageProducer.send(event);
    }

     /**
     * @param messageProducer the messageProducer to set
     */
    public void setMessageProducer(MessageProducer messageProducer) {
        this.messageProducer = messageProducer;
    }

}

Step 8 - Configure in Spring application context.

The message producer is injected by the Spring framework. Here is the configuration snippet from the service configuration.

Listing 6 - spring-service-config.xml

Step 9 - Test for message

Finally I restart my Tomcat when everything is ready, launch the event entry form, fill in data and click on Send button in the screen. The event details are now in the queue. You can test this in the ActiveMQ admin web console as shown in the Figure - 4 below.

Figure 4 - New message now in the Queue.

Initializing static fields of Spring beans

2008-11-04T08:08:00.001-08:00

This solution is courtesy Chris Harris UK.

Step 1: Create a bean factory post processor as shown in Listing 1

Listing 1 : StaticInitializerBeanFactoryPostProcessor .java

/**
*
*/
package org.opengarage.spring.postprocessor;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.Map;

import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.BeansException;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

/**
* @author dhrubo
*
*/
public class StaticInitializerBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
private Map classes;
private BeanWrapperImpl bri;

    public StaticInitializerBeanFactoryPostProcessor() {
        bri = new BeanWrapperImpl();
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        for (Iterator classIterator = classes.keySet().iterator(); classIterator.hasNext(); ) {
            String className = (String)classIterator.next();
            //System.out.println("Class " + className + ":");
            Map vars = (Map)classes.get(className);
            Class c = null;
            try {
                c = Class.forName(className);
            } catch (ClassNotFoundException e) {
                throw new NoSuchBeanDefinitionException("Class not found for " + className);
            }
            Method[] methods = c.getMethods();
            for (Iterator fieldIterator = vars.keySet().iterator(); fieldIterator.hasNext(); ) {
                String fieldName = (String)fieldIterator.next();
                Object value = vars.get(fieldName);
                Method method = findStaticSetter(methods, fieldName);
                if (method == null) {
                    throw new RuntimeException("No static setter method found for class " +
                            className + ", field " + fieldName,null);
                }
                //System.out.println("\tFound method " + method.getName() + " for field " + fieldName + ", value " + value);
                Object newValue = bri.doTypeConversionIfNecessary(value, getPropertyType(method));
                try {
                    method.invoke(null, new Object[] {newValue});
                } catch (Exception e) {
                    throw new RuntimeException("Invocation of method " + method.getName() +
                            " on class " + className + " with value " + value + " failed.", e);
                }
            }
        }
    }

    private Class getPropertyType(Method setter) {
        Class params[] = setter.getParameterTypes();
        if (params.length != 1) {
            throw new RuntimeException("bad write method arg count: " + setter);
        }
        return params[0];
    }

    /**
     * Look for a static setter method for field named fieldName in Method[].
     * Return null if none found.
     * @param methods
     * @param fieldName
     * @return
     */
    private Method findStaticSetter(Method[] methods, String fieldName) {
        String methodName = setterName(fieldName);
        for (int i=0; i<methods.length; i++) {
            if (methods[i].getName().equals(methodName) &&
                                                Modifier.isStatic(methods[i].getModifiers())) {
                return methods[i];
            }
        }
        return null;
    }

    /**
     * return the standard setter name for field fieldName
     * @param fieldName
     * @return
     */
    private String setterName(String fieldName) {
        String nameToUse = null;
        if (fieldName.length() == 1) {
            if (Character.isLowerCase(fieldName.charAt(0))) {
                nameToUse = fieldName.toUpperCase();
            } else {
                nameToUse = fieldName;
            }
        } else {
            if (Character.isLowerCase(fieldName.charAt(0)) && Character.isLowerCase(fieldName.charAt(1))) {
                nameToUse = fieldName.substring(0,1).toUpperCase() + fieldName.substring(1);
            } else {
                nameToUse = fieldName;
            }
        }
        return "set" + nameToUse;
    }

    public void setClasses(Map classes) {
        this.classes = classes;
    }
}

Step 2 : Create your simple test class

Listing 2 : Test.java

/**
*
*/
package org.opengarage.spring.test;

import java.util.Properties;

/**
* @author dhrubo
*
*/
public class Test {
private static Properties properties;

    /**
     * @return the properties
     */
    public static Properties getProperties() {
        return properties;
    }

    /**
     * @param properties the properties to set
     */
    public static void setProperties(Properties properties) {
        Test.properties = properties;
    }
}

Step 3 : Finally wire up everything in Spring configuration file

Listing 3 - Spring-config.xml

<bean class="org.opengarage.spring.postprocessor.StaticInitializerBeanFactoryPostProcessor">
        <property name="classes">
            <map>
                <entry key="org.opengarage.pingscape.test.Test">
                    <map>
                        <entry key="properties">
                            <bean class="org.springframework.beans.factory.config.PropertiesFactoryBean">
                                <property name="locations">
                                    <value>classpath:org/opengarage/spring/test/jdbc.properties</value>
                                </property>
                            </bean>
                        </entry>
                    </map>
                </entry>
            </map>
        </property>
    </bean>