PermGen error

GWT 2, JSONP and Javascript Overlays with JsonpRequestBuilder

admin — Thu, 22 Apr 2010 12:24:22 +0000

In one of my earlier posts I discussed the topic of making cross site requests with Google Web toolkit.

Since that post Google have updated Web toolkit, currently version 2.0.3 and has now made it easier to make cross site requests through the use of their new JsonpRequestBuilder object and the Javascript object overlay types for result encapsulation.

This is a quick tutorial update on how to make use of the object overlay types. The application contacts the Geonames webservice. For the example I shall use the ‘Placename lookup with postalcode (JSON)’ function by making the following call:

http://ws.geonames.org/postalCodeLookupJSON?postalcode=M1&country=GB&maxRows=4

This returns location details for places matching the M1 post code so central Manchester in the United Kingdom.

The results this request return are as follows:

{"postalcodes":[
{"adminCode3":"BN","adminName3":"Manchester District (B)","adminCode2":"00","postalcode":"M1 1AD","adminCode1":"ENG","countryCode":"GB","lng":-2.24521599415295,"placeName":"City Centre Ward","lat":53.4838491117407,"adminName1":"England"},
{"adminCode3":"BN","adminName3":"Manchester District (B)","adminCode2":"00","postalcode":"M1 1AE","adminCode1":"ENG","countryCode":"GB","lng":-2.23116928236428,"placeName":"Ancoats and Clayton Ward","lat":53.4834816441844,"adminName1":"England"}
]}

If you look at the previous JSON data it seems we have a list of ‘postalcodes‘ and each postal code has various fields such as adminName3, placeName etc.

Using GWT Javascript object overlays we can represent this structure. Within your GWT client directory create a new class called PostcodeEntry and add the following:

import com.google.gwt.core.client.JavaScriptObject;
 
public class PostcodeEntry extends JavaScriptObject {
 
	protected PostcodeEntry() {}
 
	public final native String getAdminCode3() /*-{
		return this.adminCode3;
	}-*/;
 
	public final native void setNumberPlaceHolderId(String adminCode3) /*-{
		this.adminCode3 = adminCode3;
	}-*/;
 
	public final native String getAdminName3() /*-{
		return this.adminName3;
	}-*/;
 
	public final native void setAdminName3(String adminName3) /*-{
		this.adminName3 = adminName3;
	}-*/;
 
	public final native String getPostalcode() /*-{
		return this.postalcode;
	}-*/;
 
	public final native void setPostalcode(String postalcode) /*-{
		this.postalcode = postalcode;
	}-*/;
 
	public final native String getPlaceName() /*-{
		return this.placeName;
	}-*/;
 
	public final native void setPlaceName(String placeName) /*-{
		this.placeName = placeName;
	}-*/;
}

Each PostcodeEntry represents one postalcode as you can see we have the functions for the various properties of a postalcode. Also note we extend the GWT JavascriptObject. In the above example you’ll notice I haven’t implemented every property. This is by choice I have only implemented a few of the properties.

Now we need to build an object that maintains the collection of PostcodeEntry object. Essentially the object that represents the postalcodes array. Create a new Java object called ‘PostalCodes‘. Add the following content:

import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsArray;
 
 
public class PostalCodes extends JavaScriptObject {
 
	protected PostalCodes() {}
 
	public final native JsArray<PostcodeEntry> getPostalCodes() /*-{
    	return this.postalcodes;
  	}-*/;
 
}

The object quite simply has one method called getPostalCodes which you’ll notice is a collection of PostcodeEntry objects and the native method simply called this.postalcodes which if you remember was the name of the array in the JSON response.

Those two objects wrap up the Geonames JSON response.

Finally we just need to write the code that invokes the service using the JsonpRequestBuilder object.

Locate your GWT entry point and add the following code.

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.jsonp.client.JsonpRequestBuilder;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.VerticalPanel;
 
/**
 * Entry point classes define onModuleLoad().
 */
public class JsonpExample implements EntryPoint {
    /**
     * This is the entry point method.
     */
    public void onModuleLoad() {
        //
	// http://ws.geonames.org/postalCodeLookupJSON?postalcode=M1&country=GB&maxRows=4
	//
	JsonpRequestBuilder jsonp = new JsonpRequestBuilder();
 
        String url = "http://ws.geonames.org/postalCodeLookupJSON?postalcode=M1&country=GB&maxRows=4";
 
	jsonp.requestObject(url, new AsyncCallback<PostalCodes>() {
	    @Override
	    public void onFailure(Throwable caught) {
                Window.alert("Failure:" + caught.getMessage());
            }
 
            @Override
            public void onSuccess(PostalCodes result) {
                VerticalPanel vp = new VerticalPanel();
		if(result.getPostalCodes() != null ) {
                    for( int count = 0; count < result.getPostalCodes().length(); count++) {
			PostcodeEntry entry = result.getPostalCodes().get(count);
			HorizontalPanel hp = new HorizontalPanel();
			hp.setSpacing(10);
			hp.add(new Label(entry.getPostalcode()));
			hp.add(new Label(entry.getPlaceName()));
			vp.add(hp);
		   }
               }
               RootPanel.get().add(vp);
           }
       });
    }
}

There are few important areas of this code to take note.

First of all note the use of the JsonpRequestBuilder object. We simply give this a Url which in this case is the Geoname service url. Those who are familiar with cross site requests will notice that the URL I specified doesn’t contain the ‘callback’ parameter. The JsonpRequestBuilder automatically appends this to the end of the URL for us so we have &callback=gwt_IOSucess appended to the request. It defaults the parameter name to ‘callback’ but if the service requires a different parameter name you can change this by calling setCallbackParam.

Next we simply call requestObject that takes an Async callback which is of our Postalcodes type. This clears up why we use object overlays.

Finally the onSuccess method takes in the Postalcodes as an argument and we are then free to pick away at the response and the various postalcode entries in the result.

I hope this has helped people to start making use of the new GWT JSONP functions and object overlays.

You can also download the source code for this example.

Please any comments welcome…..

Spring annotation based AOP and intercepting the ball

admin — Wed, 03 Feb 2010 10:13:33 +0000

Spring AOP and Annotation based AspectJ

The concept

Recently I had to work on a requirement that asked that logs be kept when anyone performs certain actions upon the database.

For example if some chose to remove an item from the database – the action, who performed it, when it was performed and any extra information should be noted in the database.

Implementing this can be performed in a variety of ways. We could have simply told developers to call a function within any database methods to log the action. However Spring AOP provides a better way of doing this.

The idea

To make it easier to store the logs I wanted users to simply be able to annotate any methods they felt needed logging in the message.

Then using AspectJ we would have code that would intercept the methods and log the action in the database. All developers would need to do is very simply annotate their methods.

The Annotation

First of all I had to create the Java Method annotation that can be placed above the required methods.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogAction {
	String actionPerformed();
}

The annotation simply has one parameter that allows the developer to specify the action performed such as ‘object deleted’ etc.

The aspect class

Next was to write the Spring aspect class which will perform the actual logging of the action

First of all we write a simple class and add the @Aspect annotation before the class

@Aspect
public class MyAspect

Next we need to define the Pointcut. As a Spring defintion a Pointcut is:

Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name). The concept of join points as matched by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut expression language by default.

I’m writing a simple point cut that matches any public methods. This is coded like so:

@Pointcut(value="execution(public * *(..))")
public void anyPublicMethod() { }

The last part of the Aspect class is the Advice. Spring defines the advice as:

Advice: action taken by an aspect at a particular join point. Different types of advice include “around,” “before” and “after” advice. Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors around the join point.

I need my advice to handle the “around” advice and only methods with my @LogAction annotation

To do this I used the following method:

@Around("anyPublicMethod() && @annotation(logAction)")
public Object logAction(ProceedingJoinPoint pjp, LogAction logAction) throws Throwable {
}

The method uses my anyPublicMethod Pointcut and the @annotation(logAction) to match only public methods with the LogAction annotation specified.

I have also included the ProceedingJoinPoint parameter so I can access the various arguments in the annotated method.

The final Aspect class is as follows:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
 
@Aspect
public class MyAspect{
 
	@Pointcut(value="execution(public * *(..))")
	public void anyPublicMethod() {
	}
 
	@Around("anyPublicMethod() && @annotation(logAction)")
	public Object logAction(ProceedingJoinPoint pjp, LogAction logAction) throws Throwable {
 
		// Do what you want with the actionperformed
		String actionPerformed = logAction.actionPerformed();
 
		// Do what you want with the join point arguments
		for ( Object object : pjp.getArgs()) {
			System.out.println(object);
		}
 
		return pjp.proceed();
	}
}

Updating the Spring app config

To ensure that our @Aspect annotated class is picked up by Spring you simply need to add the following to your app-config.xml

/>
 id="myAspect" class="package.to.my.MyAspect" />

This assumes that you have the aop namespace within your app-config beans definition like so

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

Setting up intercepted methods

The final step is to mark the methods we want to be intercepted

This is as easy as doing the following

@LogAction(actionPerformed="doSomething")
public void doSomething(MyObject someParameter) {
}

Now whenever that method is executed we will firstly execute our Aspect code.

Spring JS – Lack of an API or Documentation

admin — Fri, 22 Jan 2010 13:42:12 +0000

Hi all,

This is a bit of a call out to the readers of the blog. In particular any Spring developers.

Recently I have been attempting to use Spring Web Flow and in particular it’s Spring JS implementation to Ajaxify applications I am working on.

However the documentation on Spring 3 and its Javascript support is quite lacking. In fact it seems to only consist of:

http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch11s04.html

Literally that is all the ‘official’ documentation I can find the rest seems to be forum posts by the Spring community.

Can anyone share any experience? Or give any feedback on the framework? Could we (as a community) look to help the development of this documentation?

By the way this shouldn’t put anyone off using Spring for the web application development. As a whole the framework is very useful and effective!!

Spring 3 RESTful Web Services

admin — Sun, 03 Jan 2010 10:00:31 +0000

Step One – Project Creation with Maven

This tutorial is slightly different to my previous examples. In recent development I have begun to use Maven to manage my project dependencies.

If you are comfortable with creating a Web application project and Maven please skip down to the example code.

First of all you will need to install the Maven 2 plugin for Eclipse.

After you have installed the plugin create a new ‘Dynamic Web Project’ in Eclipse. Call it ‘SpringRestfulExample’.

Click Next. On the next screen we need to edit the src folder and the output folder. First of all remove the current src folder and then click ‘Add Folder…’

On the Add folder dialog enter the value /src/main/java and click OK.

Then make sure the default output folder reads target/classes. Click next

On the change the Context directory to read /src/main/webapp. Continue on to create the project.

Next we need to introduce Maven. Assuming you have installed the Maven plugin correctly Right click the Project and you should see a Maven menu item.

Highlight Maven and click ‘Enable Dependency Management’.

The next screen will ask you a few Maven options leave everything as it is apart from Packaging – change this to war. Click Finish.

Now we need to ensure the project uses any Maven dependencies we setup. Right click the Project and choose Properties.

From the Properties menu click ‘Java EE Module Dependencies’. On the right hand pane you will see ‘Maven Dependencies’ simply add a tick in that box and click Apply

Step Two – Making the Web application work

Next we’re going to make sure the web application works OK before we introduce Spring and other requirements.

In your src/main/webapp folder create a file called index.jsp and add some sample content like below:

Spring RESTful Example

Your WebApplication is up and running....

(If you open your web.xml file you’ll see a list of welcome files we’re creating the index.jsp of that welcome file list)

I’ll assume you’re comfortable with setting up local servers in Eclipse. If you open up your Servers view in Eclipse and add your project to your server, then start you server. You should be able to visit http://localhost:8080/SpringRestfulExample/ and view the page you created.

Step Three – Introducing Spring

In the root of your project you’ll notice that there is a file called pom.xml – this manages all your Maven dependencies.

Open the file (choose the tab pom.xml in the editor if the file opens up in the Maven editor) and add the following content:

 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">
	>4.0.0>
	>SpringRestfulExample>
	>SpringRestfulExample>
	>war>
	>0.0.1-SNAPSHOT>
 
 	>
    	>3.0.0.RELEASE>
	>
 	>
 		>compile>
 		>target>
 		>src/main/java>
 		>target/classes>
 	>
 
	>
		>
			>org.springframework>
		  	>spring-core>
		  	>${org.springframework.version}>
		>
		>
	  		>org.springframework>
	  		>spring-expression>
	  		>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-beans>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-aop>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-context>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-context-support>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-web>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-webmvc>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-oxm>
  			>${org.springframework.version}>
		>
		>
			>org.slf4j>
			>slf4j-log4j12>
			>1.4.2>
		>
		>
			>org.apache.tiles>
			>tiles-api>
			>2.1.2>
		>
		>
			>org.apache.tiles>
			>tiles-core>
			>2.1.2>
		>
		>
			>org.apache.tiles>
			>tiles-jsp>
			>2.1.2>
		>
		>
			>javax.servlet>
			>jstl>
			>1.1.2>
		>
		>
			>taglibs>
			>standard>
			>1.1.2>
		>
 
	>
 
>

This Maven configuration includes all the required elements for the Spring example we’re going to be working with. If you need to read up more on Maven and Spring please see the SpringSource recent blog post.

Step Four – Configuring Spring MVC

Although we’re going to make an application that serves up RESTful XML we need to integrate Spring Web MVC. First of all we’ll create some basic Pojo objects that we shall represent.

Right click the src/main/java folder and create a new package called ‘com.spring.datasource’

Within that package create a new class called ‘Student’. Add the following content:

package com.spring.datasource;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
public class Student {
	private int id = -1;
	private String name = null;
 
	public Student() {
 
	}
 
	public Student(int id, String name) {
		this.id = id;
		this.name = name;
	}
 
	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
}

In the same package create a class called ‘Classroom’ and add the following:

package com.spring.datasource;
 
import java.util.ArrayList;
 
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
@XmlRootElement(name = "class")
public class Classroom {
 
	private String classId = null;
	private ArrayList<Student> students = null;
 
	public Classroom() {
 
	}
 
	public Classroom(String id) {
		this.classId = id;
		students = new ArrayList<Student>();
		Student studentOne = new Student(1, "Student One");
		Student studentTwo = new Student(2, "Student Two");
		students.add(studentOne);
		students.add(studentTwo);
	}
 
	/**
	 * @return the classId
	 */
	public String getClassId() {
		return classId;
	}
 
	/**
	 * @param classId the classId to set
	 */
	public void setClassId(String classId) {
		this.classId = classId;
	}
 
	/**
	 * @return the students
	 */
	@XmlElement(name="student")
	public ArrayList<Student> getStudents() {
		return students;
	}
 
	/**
	 * @param students the students to set
	 */
	public void setStudents(ArrayList<Student> students) {
		this.students = students;
	}
}

A classroom is just a collection of students – in this example I have hard coded two students but you can imagine that this may be a datasource. Also note the further use of the @XmlElement annotations.

Now create a new package called ‘com.spring.controller’.

This will contain our Spring MVC controller. Within that package create a new class called ‘StudentsController’ and add the following:

package com.spring.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
 
import com.spring.datasource.Classroom;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
@Controller
public class StudentsController {
 
	public static final String STUDENTS_VIEW_KEY = "studentsView";
 
	@RequestMapping(method=RequestMethod.GET,value="/students")
	public ModelAndView showStudentsPage() {
		Classroom classOfStudents = new Classroom("Class One");
		ModelAndView mav = new ModelAndView(STUDENTS_VIEW_KEY);
		mav.addObject("classRoom", classOfStudents);
		return mav;
	}
}

I’ll assume you are comfortable with the Spring controller annotations. If not you can have a quick lookover my previous Spring blog posts. We use the same controlller for REST requests as well as normal HTML requests. Also as you can see we always return the same view. In essence the controller doesn’t do anything special or anything different from previous controllers you may have written.

It is within the servlet.xml file configuration that takes over handling the REST requests.

 id="studentsView" class="org.springframework.web.servlet.view.xml.MarshallingView">
	 ref="jaxbMarshaller" />
>
 

 id="jaxbMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
	 name="classesToBeBound">
		>
			>com.spring.datasource.Classroom>
			>com.spring.datasource.Student>
		>
	>
>

Notice name a bean studentsView which is a Spring Mashalling view. This matches the view our controller returns. We then make use of another great Spring feature called the ContentNegotiatingViewResolver this bean allows us to handle XML requests and HTML requests and it basically makes decision on which view resolver to use. The bean is declared like so:

 class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
	 name="mediaTypes">
	    >
	         key="xml" value="application/xml"/>
	         key="html" value="text/html"/>
	    >
	>
	 name="viewResolvers">
	    >
	         class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
	         class="org.springframework.web.servlet.view.UrlBasedViewResolver">
			 name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
		>
	    >
	>
>

The content resolver declares two media types that we can handle (You can add more such as JSON) and then for the two media types we declare two View resolvers. For XML requests we use the BeanNameViewResolver so in practice we use the studentsView bean discussed earlier. Then for normal HTML requests we use the standard UrlBasedViewResolver configured with Tiles2 defintions.

The complete file is as shown below:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">
 
 
	 base-package="com.spring.controller" />
	 class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
	 class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
 
	 id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
		 name="definitions">
			>
      				>/WEB-INF/tiles-defs/templates.xml>
    			>
		>
	>
 
	 id="studentsView" class="org.springframework.web.servlet.view.xml.MarshallingView">
		 ref="jaxbMarshaller" />
	>
 
	
	 id="jaxbMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
		 name="classesToBeBound">
			>
				>com.spring.datasource.Classroom>
				>com.spring.datasource.Student>
			>
		>
	>
 
	 class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        	 name="mediaTypes">
            		>
                		 key="xml" value="application/xml"/>
				 key="html" value="text/html"/>
            		>
		>
        	 name="viewResolvers">
            		>
		                 class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
                		 class="org.springframework.web.servlet.view.UrlBasedViewResolver">
					 name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
				>
            		>
       		>
    	>
>

To complete the application we should create the required JSP’s and Tiles configuration. Under the /src/main/webapp create a new folder called ‘pages’ and create a file named ’students.jsp’ within it. Add the following content:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
Classroom of students
 

	${student.id} - ${student.name}

Finally we need to create the tiles defintion file the view. Create a new folder called ’tiles-defs’ in the WEB-INF folder and create a file called ‘templates.xml’ within it. (Notice this matches the location in our servlet.xml file

Add the following content to the templates.xml file:

 version="1.0" encoding="ISO-8859-1" ?>

       "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
 
>
 
	 name="studentsView" template="/pages/students.jsp">
	>
 
>

Step Five – Updating the web.xml

Finally we need to configure the web.xml to work with Spring Web MVC. Open your web.xml file (located in the webapp folder) and make sure it matches the following:

 version="1.0" encoding="UTF-8"?>
 id="WebApp_ID" 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">
	>SpringRestfulExample>
 
 
	>
		>SpringRestfulExample>
		>org.springframework.web.servlet.DispatcherServlet>
		>1>
	>
 
	>
    		>SpringRestfulExample>
    		>/app/*>
	>
 
	>
		>index.jsp>
	>
>

That should just about be it. If you start your webserver and visit the page http://localhost:8080/SpringRestfulExample/app/students you should see the JSP page you created with the two students listed.

However if you perform a curl request (mocking an XML request) you should see the XML representation of the classroom:

curl -H 'Accept: application/xml' http://localhost:8080/SpringRestfulExample/app/students

Project download

I have made the project available for download on Google’s Project hosting. You can get hold of it at http://code.google.com/p/eggsy-spring3-restful-example/ or via SVN on the URL http://eggsy-spring3-restful-example.googlecode.com/svn/trunk/

Resources

Spring forum post and help from user Toxic: http://forum.springsource.org/showthread.php?t=82146

REST in Spring 3 – Spring source blog : http://blog.springsource.com/2009/03/08/rest-in-spring-3-mvc/

Eyal Lupu’s Java Blog : http://www.jroller.com/eyallupu/entry/content_negotiation_using_spring_mvc

SpringSource.org – RESTful Services : http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18s02.html

Eclipse Galileo – Cannot nest src folder

admin — Sun, 20 Dec 2009 21:52:13 +0000

After recently working on a new web application project, it came to a stage where I had to download the project at home on my personal machine. So of course I logged into our SVN and grabbed a copy.

After getting the project there was an error in the project:

Cannot nest 'Project/src/main/java' inside library 'Project/src

I knew previously that this error wasn’t occuring. As far as the project classpath is concerned there was only one src path which correctly pointed at the folder Project/src/main/java

After searching through the project I found out the issue – in the .settings folder there is a file named:

org.eclipse.wst.common.component

You should find you have a line similar to the following:

deploy-path="/WEB-INF/classes" source-path="/src"/>

To fix simply remove that line (and if you don’t have it already, add the line):

deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>

Spring Forms, Dynamic Lists and Ajax

admin — Mon, 30 Nov 2009 09:11:15 +0000

Spring Forms and Dynamic Binding Lists

Introduction

After my recent posts on Spring forms and annotations – dynamic lists is logically another step to be discussed.

In the previous examples we use a form backing object – the form backing objects have tended to be very basic and primitive

Using dynamic lists within these objects makes them slightly more complicated. Suppose the following scenario:

Class enrolment example

User chooses to create a new class

User types in class name

User also has to specify one (or many) names of students in the class

Using that scenario you can imagine a form in which there is a class name field and then below that a simple student name field. When the user clicks add next to the student name – javascript should simply show another input field for a student name allowing a user to add one or more students.

Eventually when the form gets submitted to the server a list of students will be populated.

However if we don’t using Spring’s dynamic lists – specifically Spring’s AutoPopulatingList – we cannot perform such an action as we have out of bounds errors.

Configuring your build environment

Your workspace needs setting up as the previous examples. Using Eclipse create a new project. For your src directory enter the value /WEB-INF/src. For your output directory use the WEB-INF/classes directory.

Add a new lib directory in your WEB-INF folder. Under your WEB-INF directoy you will need the following JAR files (all of which can be obtained from the Spring download). Add the jars to your buildpath.

commons-beanutils.jar commons-collections.jar jstl.jar spring-core.jar spring-webmvc.jar spring.jar standard.jar tiles-api-2.0.6.jar tiles-core-2.0.6.jar tiles-jsp-2.0.6.jar

Next add the Spring servlet.xml to your application. Create a file called dynamiclists-servlet.xml in your WEB-INF folder. Add the following to the file:

version="1.0" encoding="UTF-8"?> xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> base-package="com.annotations.controller" /> class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/> class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/> class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" /> id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer"> name="definitions"> > >/WEB-INF/tiles-defs/templates.xml> > > > id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver"> name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/> > >

Next add your web.xml in the same location as your Spring servlet.xml file. Add the following contents:

version="1.0" encoding="ISO-8859-1"?> 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"> >Spring Dynamic Lists Example> > >dynamiclists> >org.springframework.web.servlet.DispatcherServlet> >1> > > >dynamiclists> >*.page> > >

Next add a new folder in your WEB-INF directory called tiles-defs and add a file called templates.xml within that. Add the following to the templates.xml file

version="1.0" encoding="ISO-8859-1" ?> "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN" "http://tiles.apache.org/dtds/tiles-config_2_0.dtd"> > name="form.view" template="/pages/form.jsp"> > name="formStudentInsert.view" template="/pages/formStudentInsert.jsp"> > name="formResult.view" template="/pages/formResult.jsp"> > >

That should be the workspace setup – next to create our form JSP pages

Form JSP pages and a touch of jQuery

Firstly create a new folder under your application called js. Next download jQuery and place the jQuery download within the folder.

Under your project create a new folder names pages and create a file named form.jsp within that.This will be our class creation form.

Add the following to your form.jsp file

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> <%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>

Class Name:

Students

Student name

This probably requires a bit of an explanation. The first two lines of the file include the required Spring tag libraries.

After that we include the link to our downloaded jQuery Javascript source. I’ll make an assumption that people are familiar with jQuery.

Next we use jQuery to add a click event listener to our form ‘Add’ button. When the user clicks add button we fire off an Ajax Get request to our server which sends an incremented number as part of its data string. This Ajax request hits our server which simply appends a new row to the form for another student name. We use the number for the index number in the collection of students.

The response is simply appended as a new row in our form before the form submit button. After that Javascript the rest is a basic Spring form.

Next create a new file called formStudentInsert.jsp in the same location as your form.jsp and add the following contents.

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> <%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>

As mentioned before this is JSP that gets appended to our form when we send the Ajax request.

The form should look similar to the image below.

Next create a JSP page that is displayed when the user submits the form. Create a new JSP called formResult.jsp and add the following contents.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
Class ${savedClass.className}

Students

${student.studentName}

The Form Backing Object

We next need to create the form backing objects that will be used for this example. Create a new Java class called Student and add the following contents:

/** * @author Eggsy - eggsy _at_ eggsylife.co.uk * */ public class Student{ private String studentName = null; public String getStudentName() { return studentName; } public void setStudentName(String studentName) { this.studentName = studentName; } }

This class is a simple Student object. Student objects will belong to a class object. Now we can go ahead and create the Class object.

Create a new class called ClassCommand and add the following:

import org.springframework.util.AutoPopulatingList; /** * @author Eggsy - eggsy _at_ eggsylife.co.uk * */ public class ClassCommand { private String className = null; private AutoPopulatingList students = null; public String getClassName() { return className; } public void setClassName(String className) { this.className = className; } public AutoPopulatingList getStudents() { return students; } public void setStudents(AutoPopulatingList students) { this.students = students; } }

The class command object is the backing object we shall use for our form. It simply has a class name. However it does also have a list of students. For this we could have used a basic java.util.ArrayList but this causes issues when attempting to bind the form. As the list wouldn’t (initially) have any contents we would experience IndexOutOfBounds exception messages. This is where we can use the incredibly helpful Spring AutopopulatingList.

Spring Annotated Form Controller

Finally we need to create the Spring Form controller that handles our various requests. Note in the servlet XML file we specified that we would scan the package com.annotations.controller package for controller annotations. Go ahead and create this package. (You can of course change this). Now create a class called ClassFormController containing the following:

import org.springframework.stereotype.Controller; import org.springframework.ui.ModelMap; import org.springframework.util.AutoPopulatingList; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; import com.annotations.command.ClassCommand; import com.annotations.command.Student; /** * @author Eggsy - eggsy _at_ eggsylife.co.uk */ @Controller public class ClassFormController { @ModelAttribute("classCommand") public ClassCommand getClassCommand() { ClassCommand classCommand = new ClassCommand(); classCommand.setStudents(new AutoPopulatingList(Student.class)); return classCommand; } /** *
Called when the form is initially displayed
* @param model * @return */ @RequestMapping(method = RequestMethod.GET, value="/processClassForm.page") protected String showNameForm(ModelMap model) { return "form.view"; } /** *
Called when the user clicks the add button
* @param fieldId * @param model * @return */ @RequestMapping(method = RequestMethod.GET, value="/appendStudentView.page") protected String appendStudentField(@RequestParam Integer fieldId, ModelMap model) { model.addAttribute("studentNumber", fieldId); return "formStudentInsert.view"; } /** *
Called when the user finally submits the class form
* @param classCommand * @param model * @return */ @RequestMapping(method = RequestMethod.POST, value="/processClassForm.page") protected String onSubmit( @ModelAttribute("classCommand") ClassCommand classCommand, ModelMap model ) { model.addAttribute("savedClass", classCommand); return "formResult.view"; } }

I’ll assume you’re comfortable with Spring annotations so I’ll just highlight the important parts. Firstly notice the way we declare our ClassCommand object. We new up the object then set the Students list as a new AutoPopulatingList of type Student.class. This is again so that we can ensure we experience no IndexOutOfBounds errors. The next method is called when we display our form simply returning the form.view. After that we have the method that gets called when the user clicks the Add button. This returns the small HTMl snippet that gets appended to our form. Finally we have the onSubmit method that gets called when we submit our form and returns the formResult view.

Ok so thats pretty much it. If you followed the examples word for word you after setting up your web application you should be able to visit http://localhost:8080/dynamiclists/processClassForm.page and test your web app.

You can also download the example project here within the project there is a docs folder that also includes a sample Tomcat context file for application deployment.

References: http://blog.richardadamdean.com/?page_id=119

Any comments or questions are always welcome!

Ajax Spring Forms with Annotations and jQuery

admin — Thu, 12 Nov 2009 10:30:48 +0000

In one of my previous posts we documented how to implement Spring Annotations with a form. If you haven’t got a copy of the project from that post you can grab it here.

Building on that example this guide shows how, using Spring and jQuery, you can Ajaxify your forms so that when submitted the user doesn’t have to be redirected to a new page

jQuery and required plugins

Create a new folder in the root of your project and call it ‘js’

Then grab a copy of jQuery. The minified version will be fine. Add the jQuery javascript file to your ‘js’ folder.

Currently it is at version 1.3.2 so I have a file called jquery-1.3.2.min.js in my js folder

Next download a very useful plugin the jQuery Form Plugin. Also place the plugin in your js folder.

Linking your JS

Open the form.jsp file and add the following lines:

Here we are linking to the two jQuery javascript files we have just downloaded. Note I reference /annotations/ that is my application name yours may however be different.

Convert the form to Ajax

This step involves using the jQuery form plugin to make your form submit via Ajax. After including the scripts add the following code:

<script type="text/javascript"> $(document).ready(function() { var formOptions = {target: '#nameFormResponse'}; $('#nameForm').ajaxForm(formOptions); }); script>

This assumes you are quite comfortable with jQuery but just to explain, in the above code we are saying that when the document is read fetch the form with the id of nameForm and convert it to an ajaxForm (The ajaxForm function is built into the form plugin we download). We are also specifying some options for the ajaxForm method namely the target. A target is an jQuery selector that the Ajax Form plugin will automatically populate with the response from your submit

After your form go ahead and add in the div with the same id as the target, in the case above id=”nameFormResponse”.

The whole form.jsp should now look like so:

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

Name:

That should be it – so now if you visit http://localhost:8080/annotations/processName.page and submit the form you will see that the page doesn’t change and we render the response of the form submit into our nameFormResponse div element.

You can grab a copy of this project here

Spring annotations User Principal

admin — Tue, 10 Nov 2009 16:03:55 +0000

In case anyone was wondering after reading the previous Spring Annotations guide you can also user various parameters to get hold of the current logged in user.

To get hold of the user principal simply add a new parameter to your Request annotated methods called:

org.springframework.web.context.request.WebRequest myWebRequest

Using the previous tutorial as an example your method should look like something similar to this:

@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) protected String showNameForm(WebRequest webRequest, ModelMap model) throws Exception { String username = webRequest.getUserPrincipal().getName(); //Do what you need with the username return "form.view"; }

Spring Form Annotations Project Download

admin — Mon, 09 Nov 2009 13:22:21 +0000

I have made the Spring Annotations project available for download.

I would recommend still using the tutorial and use the project for reference

Spring Form Annotations Project

Spring Annotations and Forms

admin — Fri, 06 Nov 2009 09:09:24 +0000

Since the release of Spring 2.5, the framework has allowed for MVC annotations for mapping your URL’s to your various controllers.

This tutorial gives an example of how the annotations can be used within your application.

Grab the Spring Framework

First of all grab the latest stable release of Spring (version 2.5.6)

I’m going to assume you’re comfortable in creating Web Application Java projects using Eclipse so I’ll ignore this step.

Configuring your build path

We simply need to add the following JAR’s to our build path. Add the Jars into your lib directory.

commons-beanutils.jar commons-collections.jar commons-digester.jar jstl.jar spring.jar spring-core.jar spring-webmvc.jar standard.jar tiles-api-2.0.6.jar tiles-core-2.0.6.jar tiles-jsp-2.0.6.jar

Note: This is the minimum amount of required libs for this example and all Jars can be taken from the Spring Framework download lib and dist directories.

JSP Form page creation

If you haven’t already create a new folder in your project called pages and add a file in it called form.jsp (Of course depending on configuration you can name the files however you like.

Add the following to the form.jsp file. This creates the simple JSP page that is our form

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

Name:

In the JSP you can see I’m using the Spring frameworks form tag library. Also note we specify and commandName, if you haven’t already encountered this – that is important. We specify the nameCommand and we shall be using that later.

Now add another JSP called formResult.jsp. This is the JSP that gets displayed when the form has been submitted. Add the following code:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
${formResult}

Configuring the web.xml

Next we can move onto the web.xml and what setup requirements we need to make our Web application work with Spring MVC

If you haven’t already create a web.xml file in your WEB-INF folder

Add the following into your web.xml

version="1.0" encoding="ISO-8859-1"?> 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"> >Spring Annotations Example> > >annotations> >org.springframework.web.servlet.DispatcherServlet> >1> > > >annotations> >*.page> > > >org.springframework.web.context.ContextLoaderListener> > > >contextConfigLocation> >classpath:applicationContext.xml> > >

To explain we’re going to create a web application under the context name annotations and then we’re mapping the Spring DispatcherServlet to it and Spring will handle any URL’s ending in .page

Again depending on configuration this doesn’t have to be .page it can be something of your choice.

Tiles configuration

For this example I am using Tiles for the ‘View’ part of our MVC

Under the WEB-INF folder create a new directory called ’tiles-defs’ and add a file in it called ‘templates.xml’.

Add the following to your templates.xml file

version="1.0" encoding="ISO-8859-1" ?> "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN" "http://tiles.apache.org/dtds/tiles-config_2_0.dtd"> > name="form.view" template="/pages/form.jsp"> > name="formResult.view" template="/pages/formResult.jsp"> > >

Very basically we are defining a new View called form.view that relates to our previously created form.jsp page and formResult.view that maps to the formResult.jsp

Spring MVC Servlet.xml

Now we can configure the Spring MVC servlet.xml file. Create a new file called annotations-servlet.xml and place it in the WEB-INF directory. (The same place as the web.xml.

Note: we call the file annotations-servlet.xml because of the servlet mapping named using in our web.xml – you can of course change this.

Add the following to the file

version="1.0" encoding="UTF-8"?> xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> base-package="com.annotations.controller" /> class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/> class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/> class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" /> id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer"> name="definitions"> > >/WEB-INF/tiles-defs/templates.xml> > > > id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver"> name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/> > >

This file sets up a few things – firstly you’ll notice that we use the context-component scan – this means that Spring will look through the package we specify for any annotations which means when we annotate our URL’s they will work. In this example I scan the com.annotations.controller package. We also setup the Spring annotation handlers.

The items after that basically configure our view resolver which in our case is Tiles and we specify the location of the templates.xml file we created in the previous steps

A bit of business logic

To make the tutorial a bit more relevant I’m going to include Springs applicationContext.xml file which would generally include a web applications database/business logic beans.

In the WEB-INF/src folder create a new file called ‘applicationContext.xml’

Add the following:

version="1.0" encoding="UTF-8"?> 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-2.5.xsd"> id="businessBean" class="com.annotations.business.BusinessLogicBeanImpl"> > >

Just define one business logic bean com.annotations.business.BusinessLogicBeanImpl which will code next.

The business logic bean

Go ahead and create and create a new java package under the path com.annotations.business

Add a new <> into this class called BusinessLogicBean and add the following code:

package com.annotations.business; /** * @author Eggsy - eggsy_at_eggsylife.co.uk */ public interface BusinessLogicBean { public String processName(String name); }

We’re defining a single business logic method that will handle the name the user has entered and do something with it

Create a new class in the same package called BusinessLogicBeanImpl and make it implement the BusinessLogicBean interface.

package com.annotations.business; /** * @author Eggsy - eggsy_at_eggsylife.co.uk */ public class BusinessLogicBeanImpl implements BusinessLogicBean { /* (non-Javadoc) * @see com.annotations.business.BusinessLogicBean#processName(java.lang.String) */ public String processName(String name) { if( name.equals("admin")) { return "Hello admin welcome"; } else { return "Hey you're not admin but Hi to " + name + " anyway!!"; } } }

I’ve defined a pretty useless business method but feel free to change this

The Form command Object

On the form JSP file in the form we mentioned an attribute called commandName and we gave it a value of nameCommand. This basically tells Spring what object to use behind the form. We can now go ahead and create that object.

Create a new package called com.annotations.command and place a new class in it called NameCommand. Add the following code:

package com.annotations.command; /** * @author Eggsy - eggsy_at_eggsylife.co.uk */ public class NameCommand { private String name = null; /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } }

Notice we have one class variable called name this maps to the name input field on our form

Finally…the annotated controller

If you remember in the servlet.xml file we stated that we would scan the com.annotations.controller package. Go ahead and create this package.

In the package create a new class called NameFormController

Just before the class defintion add the following annotations:

@Controller @RequestMapping("/processName.page")

The annotations mean that this controller will map any URL’s matching processName.page

Next within the class add a variable that is our BusinessLogicBean. Add the lines:

@Autowired protected BusinessLogicBean businessBean = null;

This introduces another annotation the @Autowired, this means Spring will automatically inject this object for us. Note the bean is given the name businessBean this identically matches our definition in the applicationContext file

Next we setup the form backing object which if you remember was the NameCommand this is done with a few more annotations like so:

@ModelAttribute("nameCommand") public NameCommand getProductCommand() { NameCommand nameCommand = new NameCommand(); return nameCommand; }

Again notice that tie we use an annotation of @ModelAttribute and give it a name of nameCommand which is used by the form on our JSP.

Next up is to add the annotated get method. This is the method that renders the view which should display the form.

@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) protected String showNameForm(ModelMap model) throws Exception { return "form.view"; }

Important to notice here is that we return “form.view” which matches the tiles definition we created earlier. Also note that we use the @RequestMapping method and we map this to the GET which is called to display the form

Finally we can go ahead and write the method that handles the form submit. Add the following to the class:

@RequestMapping(method = RequestMethod.POST) protected String onSubmit( @ModelAttribute("nameCommand") NameCommand nameCommand, ModelMap model ) { String formResult = businessBean.processName(nameCommand.getName()); model.addAttribute("formResult", formResult); return "formResult.view"; }

This method is slightly more complex. As before we use the @RequestMapping annotation but this time we map it to the POST. In the parameters however we use the @ModelAttribute annotation again but this time it specifies that from the form being submitted we will have a populated nameCommand object. Using our business logic bean we process the name entered.

If you remember the formResult.jsp we simply output an item called $formResult, using our model object we add the formResult to the model so that the JSP is able to access this and then we simply return the formResult tiles view

The whole class should look like this:

package com.annotations.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import com.annotations.business.BusinessLogicBean; import com.annotations.command.NameCommand; /** * @author Eggsy - eggsy_at_eggsylife.co.uk */ @Controller @RequestMapping("/processName.page") public class NameFormController { @Autowired protected BusinessLogicBean businessBean = null; @ModelAttribute("nameCommand") public NameCommand getProductCommand() { NameCommand nameCommand = new NameCommand(); return nameCommand; } @SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) protected String showNameForm(ModelMap model) throws Exception { return "form.view"; } @RequestMapping(method = RequestMethod.POST) protected String onSubmit( @ModelAttribute("nameCommand") NameCommand nameCommand, ModelMap model ) { String formResult = businessBean.processName(nameCommand.getName()); model.addAttribute("formResult", formResult); return "formResult.view"; } }

Testing…

Phew that should be it – assuming you have setup your application the same as mine and have configured your server environment such as Tomcat if you visit http://localhost:8080/annotations/processName.page you should see the form. Try submitting the form and you should see the response as dictated by our business logic.