Spring

copyright 2009 Trainologic LTD
Abstracting the Protocols

Spring Remoting
Spring Remoting
Introduction
Remoting by RMI
Remoting by Hessian or Burlap
Remoting by HTTP Invokers
Web Services
Remoting by JMS
Introduction
3
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
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
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
Spring Remoting
Introduction
Remoting by RMI
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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());
}
Spring Remoting
Introduction
Remoting by RMI
Web Services
Remoting by JMS
26
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
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
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
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
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">
</bean>
</beans>
31
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">
value="http://remotehost:8080/remoting/samplehessian.do" />
<property name="serviceInterface" value="...Echo" />
</bean>
class="org.springframework.remoting.caucho.BurlapProxyFactoryBean">
value="http://remotehost:8080/remoting/sampleburlap.do" />
</bean>
Spring Remoting
Introduction
Remoting by RMI
Web Services
Remoting by JMS
33
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
Spring Remoting
Example
34
<bean name="/remoting/samplehttpinvoker.do class="org
remoting.httpinvoker.HttpInvokerServiceExporter">
</bean>
Server side:
Client side:
class="orgremoting.httpinvoker.HttpInvokerProxyFactoryBean">
value="http://remotehost:8080/remoting/samplehttpinvoker.do" />
</bean>
35
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
Spring Remoting
Introduction
Remoting by RMI
Web Services
Remoting by JMS
Web Services
37
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
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
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
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
Spring Remoting
Like before, accessing a Web Service is done by a

dedicated ProxyFactorybean.
Example:
Accessing a Web Service
41
class="orgremoting.jaxws.JaxWsPortProxyFactoryBean ">
<property name=wsdlDocumentUrl"
value="http://remotehost:8080/remoting/samplews?wsdl" />
<property name=namespaceURI"
value=http://www.trainologic.com/examples/ws" />
<property name="serviceName" value=EchoService" />
<property name=portName" value=EchoPort" />
</bean>
Spring Remoting
Introduction
Remoting by RMI
Web Services
Remoting by JMS Remoting by JMS
43
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
Spring Remoting
Server Side Configuration
44

<bean id="sampleJMSService"
class="org.springframework.jms.remoting.JmsInvokerServiceExporter">
<property name="service">
<bean class="...EchoImpl" />
</property>
</bean>

<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
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>

Spring

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Spring

Hochgeladen von

Copyright:

Verfügbare Formate

copyright 2009 Trainologic LTD

Abstracting the Protocols

Remoting is an application feature by which an object is

As we are going to see, Spring supports several

Remoting is easily done with Spring; it usually requires

Without Spring, the remoting logic is mixed with the

For example, when using RMI, the remote object needs

It also needs to be exposed by using the

The same goes for the other protocols.

Using the Spring framework for remoting introduces the

Protocol associated code doesnt appear in the source

The wiring logic appears solely in the XML

It is possible to switch between different 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

Hence, we cant have a direct reference to this object.

Making remote invocations is not a simple task.

You have to manage socket connections, serialization of

Moreover, an object sent as a parameter may be a large

RMI eliminates the need to handle serialization &

The RMI architecture:

As you can see, two classes implement the business

The remote object implementation (the business

What is this stub anyway?

The Stub represents the remote object on the client

The stub is responsible for the network transportation of

From the clients point-of-view, it invokes a local

The Stub communicates with the skeleton which is a

They are automatically generated.

How can the client get hold of the Stub?

By the use of rmiregistry.

The server should bind the remote object to the

Then, the client will lookup the object by the name.

Lets see how it works

As you can see, RMI has some rules:

The remote interface must extend java.rmi.Remote.

All remote interface methods must declare throwing

The parameter classes must be Serializable.

The implementation class must either extend

The client is very simple:

Spring allows you to expose a POJO by RMI.

This is done only in the xml configuration file.

Spring provides the RmiServiceExporter class which

Lets see an example

We are going to expose the following POJO:

The RmiServiceExporter has the following configuration

serviceName the name of the remote object by

service a reference to the Spring bean that is to be

serviceInterface specifies which interface to

registryPort the port on which the rmiregistry

Do I need to start a rmiregisty in order for the example

If Spring doesnt find a rmiregistry it will create a new

The default rmiregistry port is: 1099.

We finished writing the server.

When the ApplicationContext is created, the POJO will be

RMI clients can now safely work with the object.

However, if you are using Spring on the client side, it

Lets see how its done

The client code is simplicity itself:

Hessian is a binary web services protocol.

It was developed by Caucho.

The Hessian protocol is very compact and simple. Its

Burlap is the XML equivalent for the Hessian protocol.