Java tips for coders, by coders

I like DWR, it’s a very strong framework for enriching your simple web application with ajax. It’s particularly useful for java developers because no one likes to write javascript to make XMLHttpRequest’s to call the server, parse the response and then set stuff in your jsp so that the response is displayed in a proper manner. You can effectively expose your entire class simply by defining it’s methods in your dwr.xml and then writing converter’s for your objects. The util.js that comes with dwr is very useful too even if you aren’t using dwr, it provides a lot of helpful methods to do stuff in javascript.

The debug page is probably what I loved the most about dwr. It lists out what classes have been exposed including their methods in a very simple manner. You can immediately test if you have configured dwr and if it’s working properly. You can also test out your exposed methods, with and without parameters, and see their responses. It’s lovely and I wish more applications would do this.

Running DWR with spring however is a totally different matter. There is so little material that is available on the internet that it boggles my mind. There is no clear cut example of how to integrate the two. There are some useful tutorials but they don’t list out enough configuration for them to be useful enough and unless you’re very good with the spring framework and know how it works inside out, you might be stuck for a long long time. The fact that there are threee versions of dwr, all with very different integration techniques, makes it even more difficult.

I decided to integrate spring 2.5.5 and dwr 2.0.5. My first mistake was to use DwrServlet instead of DwrSpringServlet. DwrServlet should only be used when you want DWR to manage and expose your beans. If you want DWR to expose your Spring-managed beans then you must use DwrSpringServlet.

First some spring configuration in your web.xml :

<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>log4jConfigLocation</param-name>
	<param-value>/WEB-INF/log4j.properties</param-value>
</context-param>
<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>

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

Then some dwr configuration in your web.xml:

<servlet>
	<servlet-name>dwr</servlet-name>
	<servlet-class>org.directwebremoting.spring.DwrSpringServlet</servlet-class>
	<init-param>
		<param-name>debug</param-name>
		<param-value>true</param-value>
	</init-param>
</servlet>

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

Thats it, your basic configuration is done. You can now run your webapp and see if everything works.

DWR 2.0 has spring namespace support so you don’t need to write a dwr.xml anymore. You can simply configure dwr exposure of your beans when you configure them in spring. A little bit of configuration is required before you do that though.

In your application-servlet.xml add the following :

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

Don’t forget to add the namespace first :

xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"

Now, add the following configuration to whatever bean you want to expose. Here I expose my dao and it’s methods getAllCountries() and getStatesForCountry() :

<bean id="generalDao" class="com.codercorp.dwr.JdbcGeneralDao">
	<property name="dataSource" ref="dataSource" />
	<dwr:remote javascript="generalDao">
		<dwr:include method="getAllCountries" />
		<dwr:include method="getStatesForCountry" />
		<dwr:convert type="bean" class="com.codercorp.dwr.Country">
			<dwr:include method="id" />
			<dwr:include method="name" />
		</dwr:convert>
		<dwr:convert type="bean" class="com.codercorp.dwr.State">
			<dwr:include method="id" />
			<dwr:include method="name" />
			<dwr:include method="country" />
		</dwr:convert>
	</dwr:remote>
</bean>

The converter tells DWR what properties of my beans should be used to convert the data it gets into that particular bean. Primitive data types are converted automatically but if you have a POJO that you want converted then you must state it’s properties explicitly.

That’s bascically it. Navigate to your the /dwr directory in your web application. The exposed pojo should show there like this (click on image to see it clearly)

The methods of generalDao are listed here along with how you should use it’s corresponding js file in your view (click on image to see it clearly)

You can click on the execute button to see what your method returns, great for seeing a list of your exposed methods as well as testing them out.

I hope this tutorial of sorts makes someone life’s easier, it took me a couple of days to figure out how to get all of this to work.

No related posts.