Cajo project

From Wikipedia, the free encyclopedia

The cajo project is a framework that enables multiple java applications that are spread across multiple machines to work together as one transparently and dynamically. This framework is useful for both open/free and propriety applications that need distributed computing capabilities and is capable of being used an almost any java-equipped platform (JRE/JME 1.2 or higher) (mobile phones, mainframes, servers, embedded devices, etc.). It is a “drop-in” framework, because it does not impose any structural requirements or source code changes and is 100% pure java with no XML code. It also is not dependent on any other frameworks and can work behind NAT, firewalls, even HTTP proxies.

Using the cajo project, ordinary unmodified Java objects, can be remoted using a single line of code:

   Itemserver.bind(someObject, "someName");

These can then be used by remote machines either statically, or dynamically.

Static remote object usage is typically performed when there exists one or more interfaces to the object, defining how the client may use it, known at compiletime. For example:

public interface SomeInterface {
   ... // method signatures
}

The remoted object implements this interface, and possibly others, then remotes the object as shown previously.

Static remote object usage is provided through the TransparentItemProxy. The user of a remote object can create a reference to this object, which actually implements the shared interface, as follows:

SomeInterface si = (SomeInterface)TransparentItemProxy.getItem(
   "//someHost:1198/someName", new Class[] { SomeInterface.class }
);

A remote machine may now invoke methods on the remote object, with the exact Java syntax and semantics, as if it were local.

Dynamic remote object usage is typically performed when the interface to an object will be determined at runtime. This is often the case when using cajo remoted objects in a scripting environment. A machine dynamically uses a remote object reference as follows:

Object object = Remote.getItem("//someHost:1198/someName"); // obtain reference

String someMethod = "someMethod"; // typically obtained at runtime

Object someArgs = new Object[] { someArgs, ... }; // also obtained at runtime

Object result = Remote.invoke(object, someMethod, someArgs);

This snippet invokes a method on a remote object, providing the arguments, (if any) and returning the result. (if any)

The cajo framework can allow a machine to remote its object reference using UDP/IP Multicast announcements. This technique lets machines interested to use remoted references, simply listen for the announcements. This provides a one-to-many linkage mechanism, where the users of the remote object do not need to know the TCP/IP address of the host machine.

The cajo project is also used to remote graphical user interfaces. This provides the ability for an application to run its view on separate machines from its model, and even its controller objects. (using terms of the Model-view-controller paradigm)

The source code is free under the LGPL, and the documentation is free under the GFDL

Wikipedia: cajo auf Deutsch