Spring and Hessian for Fast, Easy Java Remoting : Page 2

Spring Hessian Integration

When implementing Hessian in a Spring application, the original Hessian API does not apply. Luckily, the Spring team realized the value of Hessian a long time ago and provided solid integration for creating Hessian components as simple Java objects—without the need to extend specialized servlets.

To demonstrate Spring's Hessian integration, this section walks you through setting up some common interfaces. First, use the following two classes to create a service that will allow saving/updating/deleting a simple Person POJO:

public class Person implements Serializable {
   
   private Integer id;
   private String firstName;
   private String lastName;
   private Calendar birthDate;

   public Person() {
      super();
   }
   public Person(String firstName, String lastName, Calendar birthDate) {
      super();
      this.firstName = firstName;
      this.lastName = lastName;
      this.birthDate = birthDate;
     ...getters and setters...
   }
}

Person DAO service:

                                

public interface IPersonService {
   Person get(Integer id);
   Person add(Person person);
   void delete(Integer personId);
   void update(Person person);
}

Both these classes are part of a common library shared on both endpoints.

Setting Up the Server Endpoint

In the Spring server-side application, create a regular Java component that implements your service interface. Here's an example of how to do that:

@Service("personService")
public class PersonService implements IPersonService {

   //map used for simulating data storage
     private static Map<Integer,Person> people = new ConcurrentHashMap<Integer, Person>();
   private static AtomicInteger keyGenerator = new AtomicInteger(0);
   
   @Override
   public Person add(Person person) {
      if (person.getId() == null) {
         Integer id = keyGenerator.addAndGet(1);
         person.setId(id);
         people.put(id,person);
         return person;
      } else {
         throw new RuntimeException("Person already exists!");
      }
      
   }

   @Override
   public void update(Person person) {
      if (person.getId() != null) {
         people.put(person.getId(), person);
      } else {
         throw new RuntimeException("Person must be saved first!");
      }
   }
   
   @Override
   public void delete(Integer personId) {
      people.remove(personId);
   }

   @Override
   public Person get(Integer id) {
      return people.get(id);
   }

}

As you can see, this component does not need to extend the previously mentioned Hessian servlet. Also, the @Service Spring stereotype annotation eliminates the need to explicitly define the bean in an XML configuration. However, exposing the component via Spring does involve a series of steps.

First, in web.xml, add the Spring remoting servlet and map it to a URI:

<servlet>
      <servlet-name>remoting</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
      <servlet-name>remoting</servlet-name>
      <url-pattern>/remoting/*</url-pattern>
   </servlet-mapping>

The Spring remoting servlet will expect a new Spring application context file, which is usually called remoting-servlet.xml (separate from the usual beans.xml used by the rest of the application). In the context file, you have to expose your service via a HessianServiceExporter class:

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

   <context:annotation-config />
   <context:component-scan base-package="com.devx.hessian.server"/>

   <bean name="/PersonService"
      class="org.springframework.remoting.caucho.HessianServiceExporter">
      <property name="service" ref="personService" />
      <property name="serviceInterface" value="com.dexv.hessian.IPersonService"/>
   </bean>
</beans>

The context elements activate Spring's new annotation-based context support (to avoid unnecessary XML configuration) and tell it which package to use as the base for searching for components. The PersonService implementation is then injected into the HessianServiceExporter class instance.

If you run the server app (from the code sample attached to this article) and access the /remoting/PersonService URI via a regular browser, you will get a notice that Hessian is listening, although unable to process a typical browser request:

HTTP ERROR: 405
HessianServiceExporter only supports POST requests
RequestURI=/remoting/PersonService

Previous Page

Next Page