PermGen error » spring 3

Spring JS – Ajax Popup with list refresh

admin — Mon, 08 Nov 2010 09:49:06 +0000

The concept

I have been working with Spring-JS for a while now and have noticed that there doesn’t seem to be too many examples out there. This tutorial should hopefully address one common usage of Spring JS and its Ajax simplifications.

One common use of any Ajax framework is to have a page list a number of items. Then allow the user to add to those items. When adding an item a popup is displayed asking for the item details. Upon saving the item the popup is closed and the list underneath is refreshed. All actions working through Ajax and without changing page.

As a flow this would be:

User clicks to list items
User clicks to add items
Popup displayed asking for new item details
User clicks save within popup
If new details passes validation
List of items refreshed and popup closed

Getting hold of the sample code

I have hosted the completed project on GitHub. So please feel free to clone the repository @ git://github.com/eggsy84/SpringPopupRefreshList.git

Also if anyone has any contributions to add to the project please drop me an email or submit a request via GitHub for write access. The GitHub page is https://github.com/eggsy84/SpringPopupRefreshList. You can also download the project from this site. The rest of the tutorial will continue assuming you have grabbed the source code.

The servlet XML

We firstly need to configure our Spring MVC through the servlet-context.xml file. For Spring-JS and partial rendering to work we define the use of Apache Tiles as our view resolving mechanism. We can do this by simply configuring a few beans:

 id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
	 name="definitions">
    		>
      			>/WEB-INF/tile-defs/tile-defs.xml>
 		>
	>
>
 
 id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
	 name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
>

The main item to note here is the location of our tile defintions file. This shall be discussed shortly. The final thing to add to the servlet-xml file is to tell Spring to context scan our project for Spring controllers.


 />
 
 base-package="uk.co.eggsylife.controller" />

We’re informing Spring to scan the ‘uk.co.eggsylife.controller’ package. The complete servlet-context.xml can be seen online.

The configuration XML

For the purpose of this tutorial, the application lists students and allows the user to add students. The ‘students’ bean acts as an in-memory database that is added to at runtime. It is a simple Java ArrayList of Student model objects. Typically you will have your own model objects and different CRUD operations on those objects.

 id="students" class="java.util.ArrayList">
	>
		>
			 class="uk.co.eggsylife.persistent.Student">
				 name="studentNumber" value="1" />
				 name="firstName" value="John" />
				 name="lastName" value="Smith" />
			>
			 class="uk.co.eggsylife.persistent.Student">
				 name="studentNumber" value="2" />
				 name="firstName" value="Jane" />
				 name="lastName" value="Smith" />
			>
		>
	>
>

Within the application when a Student is added we also validate the details entered. A simple Student Validator is created and referenced from the configuration XML.

 id="studentValidator" class="uk.co.eggsylife.validation.StudentValidator" />

Finally we tell Spring the location of our ValidationMessages message properties file. If the user enter any details incorrectly we can raise an error for the field entered and specify a message code for the error. Spring will then look up that message code from the ValidationMessages.properties file

 id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
	 name="basenames">
		>
			>classpath:ValidationMessages>
		>
	>
	 name="cacheSeconds">
		>60>
	>
>

The app-config is now completed.

Tiles setup and JSP file

Earlier in the tutorial we referenced the location of the Tile definitions, ‘/WEB-INF/tile-defs/tile-defs.xml’. This file declares all the views the web application uses and is crucial to making Spring JS and partial rendering function correctly.

Firstly we define an overall template that can be be used for any views our application requires. Declaring a template allows you to re-use the styling across multiple views.

 name="template.view" template="/WEB-INF/pages/templates/template.jsp">
	 name="content" value="/WEB-INF/pages/blank.jsp" />
>

The ‘template.jsp’ file is pretty basic. It simple declares the HTML headers. Each time we change the ‘content’ of this Tile definition it will continue to be surrounded by the markup on the template.jsp.

Spring-JS Edit Dialog and Partial JS Example

Spring Edit Dialog and Partial Content Update Tutorial

This means that every page will have the title set as above and every page will have the ‘Spring Edit…..’ paragraph present. Also note we are including the various Spring required Javascript files. By default they are located in the /resources/ folder of the web application. They are required in order to make Spring-JS Ajax functions work.

In this example I have also included the Dojo Tundra theme to improve the look and feel of the sample application but this is by no means required.

The tutorial only has one screen which lists students and should look similar to figure 1.

Figure 1

This screen simply lists the students and provides a link for the user to add a new student. When a new student is added we don’t navigate away from the page we simply append the student to the bottom of the list.

 name="students.view" extends="template.view">
	 name="content" value="studentsList.view" />
>
 
 name="studentsList.view" template="/WEB-INF/pages/students.jsp">
	 name="studentsList" value="/WEB-INF/pages/studentList.jsp" />
	 name="studentEditDialog" value="/WEB-INF/pages/util/dialogClose.jsp" />
>

We firstly declare the overall ‘students.view’ which extends our default template as mentioned earlier. This view is actually a template itself and requires two entries – a list of students and a student edit dialog. The ‘students.jsp’ file is as follows:

<%@ include file="/WEB-INF/pages/include.jsp" %>

The ‘students.jsp’ doesn’t contain much other than the inclusion of the two areas of content. ‘studentList’ and ‘studentEditDialog’. First of all lets look at the ‘studentList.jsp’ file which we inject into the ‘studentsList’ attribute.

<%@ include file="/WEB-INF/pages/include.jsp" %>
 
 

	
				
		
			
				
					Student ID
				
				
					First name
				
				 
					Last name
				
			
		
		
			
					
						${student.studentNumber}
					
					
						${student.firstName}
					
					
						${student.lastName}
					
				
			
		
	
 
	
		Create new student

Student ID	First name	Last name
${student.studentNumber}	${student.firstName}	${student.lastName}

The view simply lists each student in a table and provides a link to be able to add students. There are two main things to note on this JSP. Firstly notice that it is wrapped in a ‘DIV’ element with the same id as the tiles attribute defintion, ‘studentsList’. This is crucial to making Spring partial refresh work. Also note the way in which we ‘decorate’ the ‘Create new student’ link with Spring Javascript.

Firstly we declare the ‘dojo.addOnLoad’ function. This means that this piece of Javascript will execute when the page loads. Next we use the ‘Spring.addDecoration’ method to add the Ajax decorations. This function takes a number of parameters. Firstly the ‘elementId’ This is the id of the element that we attach the decoration to. In this case we are attaching the decoration to the ‘Create new student’ link. The event is then specified. We want the Ajax actions to run when the link is clicked so we specify the ‘onclick’ event. Next we set the ‘popup’ variable to ‘true’. This means that whatever the response is we want it rendered as a popup dialog.

The final parameter is ‘fragments’. This identifies which areas of content we want refresh. We state that we want both the ‘studentsList’ and the ‘studentEditDialog’ updated. Notice the names match our tiles attributes and that we wrap the ‘studentsList.jsp’ in a DIV with the id of ‘studentsList’. This way Spring knows how to identify content and replace it.

Now lets look at the ‘studentEditDialog’ content. In this instance we are injecting a utility JSP file that closes any open dialogs. The JSP is basically a bit of Javascript that closes any open Dojo popup dialogs. When first listing the students it is not particularly useful as we haven’t got any open dialogs. However when we save a new student a redirect to the students list view the JSP’s use will become clear.

The last tile definition is the view that contains our full student edit dialog. The dialog allows users to create a new student, asking for the student name and id number.

 name="studentsListAndEditDialog.view" extends="studentsList.view">
	 name="studentsList" value="/WEB-INF/pages/blank.jsp" />
	 name="studentEditDialog" value="/WEB-INF/pages/studentEditDialog.jsp" />
>

The only difference with this definition is the that we switch out the ‘dialogClose.jsp’ with the actual student edit dialog. The student edit dialog is as follows:

<%@ include file="/WEB-INF/pages/include.jsp" %>
 
 

	Student Edit Dialog
 
	
		
			
				Student number
				
					
				
			
			
				First name
				
					
				
			
			
				
					
				
			
			
				Last name

Figure 2

Again, notice we wrap the content in a DIV element with the same id as our tiles attribute, ‘studentEditDialog’. We then go on to declare a Spring form. For now I won’t go on to discuss the Spring MVC and form bindings. Finally note we attach the Spring decorations again. The only difference is this time we specify a form id and remove the popup attribute. We attach the code to the ‘Save student’ button which is the submit button for the ‘studentForm’. This means that we want our Ajax events to be actioned when the form is submitted.

That concludes our view definitions. The tiles-defs.xml, students.jsp, studentsList.jsp, dialogClose.jsp and studentEditDialog.jsp.

Java Controllers

The tutorial only has one controller. The ‘StudentController’ handles the three primary functions of the application. It handles the showing of the students list (GET), the showing of the edit dialog (GET) and the adding of a student (POST).

The list of students is handled by the ‘showStudentsList’ method.

private static final String STUDENTS_VIEW_KEY = "students.view";
 
@Autowired
protected ArrayList<Student> students = null
 
 
@RequestMapping(value="/students", method=RequestMethod.GET)
public String showStudentsList(ModelMap modelMap) {
	modelMap.put("students", students);
	return STUDENTS_VIEW_KEY;
}

It simply adds our list of students to the view and returns the ‘students.view’ tile definition. The list of students is Autowired from our Spring app-config file as defined earlier. It is wired to handle the URL ‘/students’.

Secondly there is the ‘showStudentEditForm’ method. This handles the URL ‘/students/edit’ and is called when the user clicks the ‘Create new student’ link.

 
private static final String STUDENT_EDIT_DIALOG_VIEW_KEY = "studentsListAndEditDialog.view";
 
@RequestMapping(value="/students/edit", method=RequestMethod.GET)
public String showStudentEditForm(ModelMap modelMap) {
 
	// Object class will be used as our
	// form backing object
	Student student = new Student();
	modelMap.addAttribute("student", student);
 
 
	return STUDENT_EDIT_DIALOG_VIEW_KEY;
}

It returns the ‘studentsListAndEditDialog.view’ and adds a new ‘Student’ object to the view for our form. This object is used as the form backing object. The Student object is a POJO and will be seen later. Finally we have the ‘saveStudentEdit’ method that is actioned when the form is submitted. If the form is submitted without errors then it simply returns the same view as the listing of the students. If the user submits the form and it contains errors then it returns the edit form view with details of the error.

 
@Autowired
protected StudentValidator studentValidator = null;
 
@RequestMapping(value="/students/edit", method=RequestMethod.POST)
public String saveStudentEdit(@ModelAttribute Student student, BindingResult errors, ModelMap modelMap) {
 
	studentValidator.validate(student, errors);
 
	if( errors.hasErrors() ) {
		return STUDENT_EDIT_DIALOG_VIEW_KEY;
	}
	else {
		students.add(student);
 
		modelMap.put("students", students);
 
		return STUDENTS_VIEW_KEY;
	}	
}

Notice if the form doesn’t have errors we add the student object back into the collection of students and update the list of students in the view. This is important so that the list of students is updated with the student that has just been added. The utility JSP that closes any open Dojo modal dialogs now comes into full use as it makes sure that the edit student dialog is closed after a student has been successfully added. The method responds to the POST request method so it is actioned when our form is ‘POSTED’. The complete StudentController includes all the above methods.

The Validator and Student POJO

To wrap things up the final two Java classes the application uses is the StudentValidator and the POJO Student object.

The validator simply checks that the user has entered both a first name and last name. The Student object encapsulates items a student has.

public class StudentValidator implements Validator {
 
	/* (non-Javadoc)
	 * @see org.springframework.validation.Validator#supports(java.lang.Class)
	 */
	@Override
	public boolean supports(Class clazz) {
		return Student.class.equals(clazz);
	}
 
	/* (non-Javadoc)
	 * @see org.springframework.validation.Validator#validate(java.lang.Object, org.springframework.validation.Errors)
	 */
	@Override
	public void validate(Object obj, Errors errors) {
		Student student = (Student)obj;
 
		if( student.getFirstName() == null || student.getFirstName().length() == 0 ) {
			errors.rejectValue("firstName", "student.first.name.empty");
		}
 
		if( student.getLastName() == null || student.getLastName().length() == 0 ) {
			errors.rejectValue("lastName", "student.last.name.empty");
		}
	}
 
}

public class Student {
 
	private Long studentNumber = null;
	private String firstName = null;
	private String lastName = null;
 
 
	public Long getStudentNumber() {
		return studentNumber;
	}
	public void setStudentNumber(Long studentNumber) {
		this.studentNumber = studentNumber;
	}
 
	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
 
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
}

Conclusion

That should have gave you a complete example on how to use Spring-JS alongside Spring MVC and perform partial refresh of the content. The key to understanding the tutorial is understanding the tie between between the tiles defintions, the identified DIV elements and the usage of Javascript to link the two together.

The project can be downloaded as a Zip from GitHub. For those familiar with Git you can also get the project from the Git Repository under the URL ‘git://github.com/eggsy84/SpringPopupRefreshList.git’. If anyone would like to comment or have anything to contribute to the codebase please let me know.

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