EJOE is a lightweight Java client/server component built to send and receive objects through pluggable (de)serialization mechanisms. It offers a high-performance, simple, and clean object request broker (whereby ORB is meant in its natural manner and not in its relation with CORBA), with server and client components for your client/server applications. It's an highly scaleable implementation of the common request-process-response pattern based on java NIO. It does support optional remote class loading to avoid redundant classpath entries, but doesn't require stubs and/or proxy objects.
EJOE offers three things - and ONLY these three things for you:
Basically EJOE follows a network based request-process-response pattern:
You integrate the client component into your frontend/client tier and the server component into your backend/server tier.
Your client(s) sends requests to the server. The EJOE client component and server component handle all the network stuff as well
as serialization/deserialization for you. The server component hands-over received requests to your business logic and sends
the return values back to the client. Not more, not less.
The interface between the EJOE server component and your business logic has a simple and clean design. That means your adapter
implementation has to decide what should happen with client requests.
For example it's a usual pattern to send java.util.Map objects as requests, put all parameters into the map and use a special
key identifying the required business logic to handle the request. Your adapter inspects the map and invokes the according
business logic for such an identifier. Instead of maps you can use all possible kinds of objects as requests and or responses.
Look at the getting started guide for a simple example how such a solution could work.
As for the moment EJOE is in a pre-production stage. That means it works already very well and seems to be stable but some major features are still missing.
