Simpler-than-JBoss way to have POJO RPC in Java with container session management

Question

Currently, I only know a way of doing RPC for POJOs in Java, and is with the very complex EJB/JBoss solution.

Is there any better way of providing a similar functionality with a thiner layer (within or without a Java EE container), using RMI or something that can serialize and send full blown objects over the wire?

I'm not currently interested in HTTP/JSON serialization BTW.

EDIT: For clarification: I'm trying to replace an old EJB 2.1/JBoss 4 solution with something more easy to manage at the container level. I need to have entire control over the database(planning to use iBATIS which would allow me to use fairly complex SQL very easily), but the only things I want to keep over the wire are:

• Invocation of lookup/data modification methods (automagic serialization goes here).
• Transparent session control (authentication/authorization). I still have to see how to accomplish this.

Both items have to work as a whole, of course. No access should be granted to users without credentials.

Because I'm not very fond of writing webapps, I plan to build a GUI (Swing or SWT) that would only manage POJOs, do some reporting and invoke methods from the container. I want the serialization to be as easy as possible.

Answer 1

As is nearly always the case, Spring comes to the rescue. From the reference documentation, you will want to read Chapter 17. Remoting and web services using Spring.

There are several methods to choose from. The beauty of Spring is that all your interfaces and implementations are vanilla POJOs. The wiring into RMI or whatever is handled by Spring. You can:

1. Export services using RMI: probably the simplest approach;
2. Use HTTP invoker: if remote access is an issue, this might be better for firewalls, etc than pure RMI; or
3. Use Web Services, in which case I would favour JAX-WS over JAX-RPC.

Spring has the additional benefit in that it can do the wiring for both the server and the client, easily and transparently.

Personally I would choose either (2) or (3). HTTP is network friendly. It's easy to deploy in a Web container. Jetty's long-lived connections give you the option over server push (effectively) over HTTP.

All of these methods allow complex objects to be sent across the wire but they are subtly different in this regard. You need to consider if your server and client are going to be distributed separately and whether it's an issue if you change the interface that you need to redistribute the class files. Or you can use a customized serialization solution (even XML) to avoid this. But that has issues as well.

Using a Web container will allow you to easily plug-in Spring Security, which can be a bit daunting at first just because there are so many options. Also, HttpSession can be used to provide state information between requests.