Configuring DWR 3.0 with spring using annotations

February 21st, 2009 | Tags: Ajax, dwr, Spring, spring dwr integration

I’m a fan of the spring framework and I have recently become a fan of DWR as well. Both of them together are just unstoppable, they take ajax and bean exposure through javascript to a new level. I have written about my experiences integrating the two and about validating forms using ajax. I’d advise you to read at least the integration article before continuing.

Using annotations to configure the spring container is a very useful feature, a majority of developers prefer to use annotations rather than XML files. However, annotation driven configuration of DWR through spring was not possible in older versions of DWR. The new version however, allows such configuration and with ease I might add. You can now use DWR with spring with almost no configuration in your XML files(a little bit of configuration is required but it doesn’t go beyond 10 lines or so). The best part however is that you don’t need to configure a seperate servlet for DWR at all, all calls to dwr can be routed through the spring dispatcher servlet which helps cut down configuration even more.

First the bean which we want to expose :

@Service
@RemoteProxy
public class MyBean {

	@RemoteMethod
	public List<Integer> getStuff() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 100; i++) {
			list.add(i);
		}
		return list;
	}

}

The @Service annotation tells spring to initialize this bean as a service. The @RemoteProxy annotation is what tells DWR that we want to expose this bean to the client. Notice the @RemoteMethod annotation, thats what tells DWR to expose this particular method. Only those methods which have this annotation will be exposed by DWR, nothing else. You are free to use as many annotations as you’d like, you can make the bean transactional as well with the @Transactional annotation and still have the bean exposed.

Next comes the web.xml configuration :

<servlet>
	<servlet-name>dwrexample</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<load-on-startup>1</load-on-startup>
</servlet>
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

<servlet-mapping>
	<servlet-name>dwrexample</servlet-name>
	<url-pattern>*.html</url-pattern>
</servlet-mapping>

<servlet-mapping>
	<servlet-name>dwrexample</servlet-name>
	<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

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

Notice how we do not initialize the org.directwebremoting.spring.DwrSpringServlet or the org.directwebremoting.servlet.DwrServlet. Previous configurations, which required you to list the classes to scan for annotations, are no longer required due to the namespace support provided in the latest versions. Also note how we map all requests to /dwr/* to the spring dispatcher servlet.

Next comes the configuration required by the DispatcherServlet, dwrexample-servlet.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
	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
	    http://www.directwebremoting.org/schema/spring-dwr  http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd">

	<context:annotation-config />
	<tx:annotation-driven />
	<dwr:configuration />
	<dwr:annotation-config />
	<dwr:url-mapping />
	<dwr:controller id="dwrController" debug="true" />
	<context:component-scan base-package="com.codercorp.dwr,com.codercorp.displaytag" />
	<bean
		class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
		<property name="order" value="1" />
	</bean>
	<bean
		class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
		<property name="order" value="2" />
	</bean>
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView" />
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>
</beans>

I’m not going to explain the spring related configurationm but just the DWR related config.

<dwr:annotation-config />

asks dwr to scan spring managed classes for annotation related to its configuration, @RemoteProxy and @RemoteMethod. Remember that the element will NOT scan any classes not managed by spring. The element

<dwr:url-mapping />

asks DWR to map the util.js and engine.js files to the dwrController. The element

<dwr:controller id="dwrController" debug="true" />

defines the dwrController. The line

<dwr:configuration />

is not required in this particular instance since we aren’t going to configure any beans which aren’t managed by spring but if you need to do so, you must specify such configuration under this element.

Do note the order properties which have been added to the spring config beans, these properties are required for proper functioning of the example. One last thing, the dwr test page which lists out your exposed beans etc no longer works. However, the test pages for the actual beans do work. So if the page http://YOUR-SERVER/YOUR-APP/dwr/ shows blank, don’t panic, just browse over to, http://YOUR-SERVER/YOUR-APP/dwr/test/YOUR-BEAN-NAME and you’ll see the list of exposed methods.

Thats it, you’re good to go. I was stumped by the test page not displaying for a little while so it took me a day to get all this working. Feel free to leave a comment if this has made your life any easier or if you have any questions.

Share and Enjoy: