The JMS-DOF framework is intended to provide an alternative to technologies like CORBA and RMI in distributed applications that are centered around JMS-based communication.
A D V E R T I S E M E N T
The JMS-DOF is an experiment in supporting distributed object communication using the Java Messaging Service.
Scalability is one of the benefit of using JMS for distributed object communication. you may be providing a stateless data service to your clients. With JMS-DOF you can run multiple copies of the service. Each consuming messages from a common queue of requests. The services will pull requests from the JMS queue when this service is not busy and a request is available. Although the client request and the reply will be communicated using asynchronous JMS message, this clients sees a synchronous object interface. There are definite advantages to this loosely coupled approach. As system load increases new service replicas can be transparently added. If a replicated service crashes, it will not directly affect the client.
Some of the features of the DOF include:
Transparent synchronous calls to remote object.
Server-side exceptions propagated to the clients.
Object distribution does not requires application-specific classes.
Configurable multithreaded response handlings.
The asynchronous request/reply and request-only invocations.
Automatic and dynamic generation of the client-side proxies.
Only one client response queue required.
Object reference marshalling(as return values or method parameters)
MessageDrivenBean gateway for stateless session bean request/reply and HttpServlet gateway for stateless session bean request/reply features are added in version 0.2
Usage of DOF applications
DOF applications are organized as servers containing one or more distributed objects(also called services).
Writing a service:
A developer to implement a service in this distributed object framework, simply defines an interface and implements it. For example, a login/authentication service might provide the following interface:
The service implementer might define the implementation to be:
public class LoginServiceImpl
implements LoginService {
public AccessToken
authenticate(String user, String password)
throws
AuthenticationException
{
if (user.startsWith("X"))
{
return new AccessToken("ABCD");
} else {
throw new AuthenticationException("invalid user");
}
}
}
Accessing a service
A client would obtain a distributed object reference by some means to use the remote object. For this example, the client initialization routine creates the reference explicitly. The reference could also be provided through a distributed JNDI server or the other servers.
LoginService loginService; //
available to clients
public static void main(String[] args) {
// ... initialize JMS
JmsResponseDispatcher
responseDispatcher =
new
JmsResponseDispatcher(queueSession,
queueSession.createTemporaryQueue());
loginService =
(LoginService)DistributedObjectProxyFactory.create(
LoginService.class, "LoginService-1",
new JmsQueueTransport(responseDispatcher, queueSession, "LoginRequest"));
