copyright 2009 Trainologic LTD
Abstracting the Protocols
Spring Remoting
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Introduction
3
copyright 2009 Trainologic LTD
Spring Remoting
Remoting is an application feature by which an object is
exposed for remote invocations.
As we are going to see, Spring supports several
remoting protocols (e.g., RMI, JMS).
Remoting is easily done with Spring; it usually requires
changes only in the xml configuration file.
Remoting
3
4
copyright 2009 Trainologic LTD
Spring Remoting
Without Spring, the remoting logic is mixed with the
business logic.
For example, when using RMI, the remote object needs
to implement the Remote interface.
It also needs to be exposed by using the
UnicastRemoteObject.
The same goes for the other protocols.
Remoting without Spring
4
5
copyright 2009 Trainologic LTD
Spring Remoting
Using the Spring framework for remoting introduces the
following benefits:
Protocol associated code doesnt appear in the source
code.
The wiring logic appears solely in the XML
configuration files.
It is possible to switch between different remoting
protocols without changing the source code!
Using Springs Remoting
5
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Remoting by RMI
77
copyright 2008 trainologic LTD
Spring Remoting
RMI stands for: Remote Method Invocation.
RMI is used for making invocations on a remote object.
A remote object is an object which resides on a different
JVM than the calling object.
Hence, we cant have a direct reference to this object.
RMI Recap
7
77
copyright 2008 trainologic LTD
Spring Remoting
Making remote invocations is not a simple task.
You have to manage socket connections, serialization of
method parameters, deserialization and the same for the
returned value.
Moreover, an object sent as a parameter may be a large
object graph.
RMI eliminates the need to handle serialization &
networking for remote invocations.
Motivation for RMI
8
77
copyright 2008 trainologic LTD
Spring Remoting
The RMI architecture:
Diagram
9
Client Server
Interface Interface
Remote Object
S
k
e
l
e
t
o
n
S
t
u
b
77
copyright 2008 trainologic LTD
Spring Remoting
As you can see, two classes implement the business
interface:
The remote object implementation (the business
object).
The stub.
What is this stub anyway?
Discussion
10
77
copyright 2008 trainologic LTD
Spring Remoting
The Stub represents the remote object on the client
machine.
The stub is responsible for the network transportation of
the invocation.
From the clients point-of-view, it invokes a local
method.
The Stub communicates with the skeleton which is a
server-side proxy responsible for network management
& serialization at the server side.
They are automatically generated.
Stubs & Skeletons
11
77
copyright 2008 trainologic LTD
Spring Remoting
How can the client get hold of the Stub?
By the use of rmiregistry.
The server should bind the remote object to the
rmiregistry under a specific name.
Then, the client will lookup the object by the name.
Lets see how it works
The Registry
12
77
copyright 2008 trainologic LTD
Spring Remoting
The Server Side (without Spring)
13
// This is the remote object's interface
public interface Greeter extends Remote {
// / all methods must declared throwing RemoteException
String greet(User user) throws RemoteException;
}
// Extending the UnicastRemoteObject for network handling
public class GreeterImpl extends UnicastRemoteObject implements
Greeter {
// Must explicitly declare the constructor because of exception
// handling.
protected GreeterImpl() throws RemoteException {
super();
}
public String greet(User user) {
return "Hello " + user.getName();
}
}
77
copyright 2008 trainologic LTD
Spring Remoting
The Server Side (without Spring)
14
// Must be Serializable
public class User implements Serializable {
private String name;
private int age;
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}
public static void main(String[] args) throws Exception {
Greeter greet = new GreeterImpl();
Naming.bind("greeter", greet);
}
77
copyright 2008 trainologic LTD
Spring Remoting
As you can see, RMI has some rules:
The remote interface must extend java.rmi.Remote.
All remote interface methods must declare throwing
RemoteException.
The parameter classes must be Serializable.
The implementation class must either extend
UnicastRemoteObject (as shown) or, when creating
the object, the static method exportObject() should
be invoked.
Discussion
15
77
copyright 2008 trainologic LTD
Spring Remoting
The Client Side (without Spring)
16
public static void main(String[] args) throws Exception {
Greeter greeter = (Greeter) Naming.lookup("greeter");
User user = new User();
user.setAge(31);
user.setName("Shimi");
System.out.println(greeter.greet(user));
}
The client is very simple:
17
copyright 2009 Trainologic LTD
Spring Remoting
Spring allows you to expose a POJO by RMI.
This is done only in the xml configuration file.
Spring provides the RmiServiceExporter class which
exports the POJO over RMI.
Lets see an example
RMI with Spring
17
18
copyright 2009 Trainologic LTD
Spring Remoting
We are going to expose the following POJO:
The Remote Object
18
public interface Crier {
String cry();
}
public class CrierImpl implements Crier {
private String cry;
public void setCry(String cry) {
this.cry = cry;
}
@Override
public String cry() {
return cry;
}
}
19
copyright 2009 Trainologic LTD
Spring Remoting
The Configuration File
19
<beans >
<bean name="crier"
class="com.trainologic.examples.spring.remoting.CrierImpl">
<property name="cry" value="Wolf Wolf" />
</bean>
<bean class="org.springframework.remoting.rmi.RmiServiceExporter">
<property name="serviceName" value="CrierService" />
<property name="service" ref="crier" />
<property name="serviceInterface"
value="com.trainologic.examples.spring.remoting.Crier" />
<property name="registryPort" value="1199" />
</bean>
</beans>
20
copyright 2009 Trainologic LTD
Spring Remoting
The RmiServiceExporter has the following configuration
properties:
serviceName the name of the remote object by
which the binding in the rmiregistry will be done.
service a reference to the Spring bean that is to be
exported.
serviceInterface specifies which interface to
expose.
registryPort the port on which the rmiregistry
listens.
RmiServiceExporter
20
21
copyright 2009 Trainologic LTD
Spring Remoting
Wait a sec.
Do I need to start a rmiregisty in order for the example
to work?
Well, no!
If Spring doesnt find a rmiregistry it will create a new
one (you will see it in the log).
The default rmiregistry port is: 1099.
The rmiregistry
21
22
copyright 2009 Trainologic LTD
Spring Remoting
We finished writing the server.
When the ApplicationContext is created, the POJO will be
available by RMI.
RMI clients can now safely work with the object.
However, if you are using Spring on the client side, it
becomes very easy to consume the service.
Lets see how its done
The Client
22
23
copyright 2009 Trainologic LTD
Spring Remoting
The Client Configuration File
23
<beans >
<bean id="crierService"
class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
<property name="serviceUrl"
value="rmi://localhost:1199/CrierService" />
<property name="serviceInterface"
value="com.trainologic.examples.spring.remoting.Crier" />
</bean>
</beans>
24
copyright 2009 Trainologic LTD
Spring Remoting
The client code is simplicity itself:
The Client Code
24
public static void main(String[] args) {
BeanFactory factory = new FileSystemXmlApplicationContext(
"applicationContext.xml");
Crier c = (Crier) factory.getBean("crierService");
System.out.println(c.cry());
}
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Remoting by Hessian or Burlap
26
copyright 2009 Trainologic LTD
Spring Remoting
Hessian is a binary web services protocol.
It was developed by Caucho.
The Hessian protocol is very compact and simple. Its
well suited for applications that need high performance.
Burlap is the XML equivalent for the Hessian protocol.
Burlap is a simple subset of XML and its main purpose is
to allow EJBs to interoperable with non-Java servers.
The Hessian & Burlap Protocols
26
27
copyright 2009 Trainologic LTD
Spring Remoting
Because they work on HTTP, both Hessian and Burlap
require a Servlet container.
For exporting beans over the Hessian or Burlap
protocols, you need to use Spring MVC
DispatcherServlet (covered in the Spring MVC chapter).
Lets see an example of this definition in the web.xml
The Hessian & Burlap Protocols
27
28
copyright 2009 Trainologic LTD
Spring Remoting
Configuring the DispatcherServlet
28
<web-app ...>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/remoting/*</url-pattern>
</servlet-mapping>
</web-app>
29
copyright 2009 Trainologic LTD
Spring Remoting
In this example, the application context file will be
named: dispatcher-servlet.xml.
Now, we can export a bean in this file over the Hessian/
Burlap protocols.
Lets see an example of exporting a bean over both
protocols
Exporting our Beans
29
30
copyright 2009 Trainologic LTD
Spring Remoting
dispatcher-servlet.xml
30
<?xml version="1.0" encoding="UTF-8"?>
<beans >
<bean name="echo" class="com.trainologic...EchoImpl" />
<bean name="/remoting/samplehessian.do"
class="org.springframework.remoting.caucho.HessianServiceExporter">
<property name="service" ref="echo" />
<property name="serviceInterface" value="com.trainologicEcho" />
</bean>
<bean name="/remoting/sampleburlap.do"
class="org.springframework.remoting.caucho.BurlapServiceExporter">
<property name="service" ref="echo" />
<property name="serviceInterface" value="com.trainologicEcho" />
</bean>
</beans>
31
copyright 2009 Trainologic LTD
Spring Remoting
The same as with RMI, we use Springs proxy factory
beans to connect to Hessian/Burlap services:
Client Side
31
<bean id="echoService1"
class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
<property name="serviceUrl"
value="http://remotehost:8080/remoting/samplehessian.do" />
<property name="serviceInterface" value="...Echo" />
</bean>
<bean id="echoService2"
class="org.springframework.remoting.caucho.BurlapProxyFactoryBean">
<property name="serviceUrl"
value="http://remotehost:8080/remoting/sampleburlap.do" />
<property name="serviceInterface" value="...Echo" />
</bean>
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Remoting by HTTP Invokers
33
copyright 2009 Trainologic LTD
Spring Remoting
Hessian and Burlap are lightweight protocols.
They do not support serialization of complex object
graphs.
Springs HTTP Invokers rely on the standard Java
serialization and provides the serialization over HTTP.
Exposing the service and connecting from the client is
very similar to the previously shown protocols
HTTP Invokers
33
34
copyright 2009 Trainologic LTD
Spring Remoting
Example
34
<bean name="/remoting/samplehttpinvoker.do class="org
remoting.httpinvoker.HttpInvokerServiceExporter">
<property name="service" ref="echo" />
<property name="serviceInterface" value="com.trainologicEcho" />
</bean>
Server side:
Client side:
<bean id="echoService3"
class="orgremoting.httpinvoker.HttpInvokerProxyFactoryBean">
<property name="serviceUrl"
value="http://remotehost:8080/remoting/samplehttpinvoker.do" />
<property name="serviceInterface" value="...Echo" />
</bean>
35
copyright 2009 Trainologic LTD
Spring Remoting
Note that Http Invokers mandate not only a Java-to-Java
architecture, but also Spring on both sides.
Note that there are known issues in using Hessian/
Burlap with Hibernate objects that contain lazy-
initialized collections. Prefer Http Invokers in these
cases.
Discussion
35
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Web Services
37
copyright 2009 Trainologic LTD
Spring Remoting
Spring supports both JAX-RPC and JAX-WS standards.
JAX-RPC is the old Java standard which focuses on the
RPC aspect of web services.
In JavaEE 5 and JavaSE 6 it was replaced by JAX-WS.
We will focus on JAX-WS in this section.
For more information about Springs integration with
JAX-RPC, please consult the documentation.
Web Service & Spring
37
38
copyright 2009 Trainologic LTD
Spring Remoting
In order to export your bean as a JAX-WS Web Service,
you need to provide a dedicated endpoint class.
Lets see it by an example.
Were going to export the following class as a Web
Service:
Exporting a Service
38
public class EchoImpl implements Echo {
public String echo(String msg) {
System.out.println(msg);
return msg;
}
39
copyright 2009 Trainologic LTD
Spring Remoting
The Endpoint Class
39
@WebService(serviceName = "echoService")
public class WSSample extends SpringBeanAutowiringSupport {
@Autowired
private Echo echoImpl;
@WebMethod
public String echo(String msg) {
return echoImpl.echo(msg);
}
}
Spring provides a convenience utility class for providing
autowiring for your endpoint classes:
40
copyright 2009 Trainologic LTD
Spring Remoting
All that is left to do now is to start the Web Service.
Note that Spring doesnt come with its own JAX-WS
implementation.
So, whether you use JAX-WS RI, AXIS2, Apache CXF,
etc., you must consult the documentation regarding how
to start the Web Service.
It is important to remember that the JAX-WS framework
will manage the life-cycle of the Web Service.
Spring will provide the dependencies.
Exposing the Service
40
41
copyright 2009 Trainologic LTD
Spring Remoting
Like before, accessing a Web Service is done by a
dedicated ProxyFactorybean.
Example:
Accessing a Web Service
41
<bean id="echoService4"
class="orgremoting.jaxws.JaxWsPortProxyFactoryBean ">
<property name=wsdlDocumentUrl"
value="http://remotehost:8080/remoting/samplews?wsdl" />
<property name="serviceInterface" value="...Echo" />
<property name=namespaceURI"
value=http://www.trainologic.com/examples/ws" />
<property name="serviceName" value=EchoService" />
<property name=portName" value=EchoPort" />
</bean>
copyright 2009 Trainologic LTD
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS Remoting by JMS
43
copyright 2009 Trainologic LTD
Spring Remoting
Springs support for JMS is discussed in a separate
chapter.
Here well focus on JMS remoting.
The main advantages of using JMS for remoting is the
clustering support and load-balancing that is native to
the messaging software.
Note that Springs support is pretty basic and sending
and receiving is done on the same thread in the same
non-transactioned session.
JMS Remoting
43
44
copyright 2009 Trainologic LTD
Spring Remoting
Server Side Configuration
44
<!-- exporting the bean through JMS protocol -->
<bean id="sampleJMSService"
class="org.springframework.jms.remoting.JmsInvokerServiceExporter">
<property name="serviceInterface" value="...Echo" />
<property name="service">
<bean class="...EchoImpl" />
</property>
</bean>
<!--
creating the JMS listener container (elaborated in the JMS chapter)
-->
<bean class="orgjms.listener.SimpleMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queue" />
<property name="concurrentConsumers" value="3" />
<property name="messageListener" ref="sampleJMSService" />
</bean>
45
copyright 2009 Trainologic LTD
Spring Remoting
Client Side Configuration
45
<bean id=sampleJMSService"
class="orgjms.remoting.JmsInvokerProxyFactoryBean">
<property name="serviceInterface" value=Echo" />
<property name="connectionFactory" ref="connectionFactory" />
<property name="queue" ref="queue" />
</bean>
