Cajo project

From Wikipedia, the free encyclopedia
Jump to: navigation, search

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 proprietary applications that need distributed computing capabilities. It is capable of being used on 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.

History[edit]

The Cajo Project has been issued by the IANA port number 1198 and UDP Multicast address 224.0.23.162.

License[edit]

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

Usage[edit]

Overview[edit]

Using the Cajo Project, ordinary unmodified Java objects, can be remote using a single line of code:[1]

Itemserver.bind(someObject, "someName")

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

Static remote object usage[edit]

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

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

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

Static remote object usage is provided through a TransparentItemProxy.[2] 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[edit]

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 remote objects in a scripting.[3] A machine dynamically uses a remote object reference as follows:

// obtain reference

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

// typically obtained at runtime

String someMethod = "someMethod";

// also obtained at runtime

Object someArgs = new Object[...] { someArgs, ... };

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.[4] This technique lets machines interested to use remote 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.

Remote graphical user interfaces[edit]

The Cajo Project is also used to remote graphical user interfaces.[5] This allows an application to run its view on separate machines from its model, and even its controller objects.

See also[edit]

References[edit]

  1. ^ "Adding cajo to existing applications". Cajo project. 2007-08-04. Retrieved 2008-01-19. 
  2. ^ "Using remote objects as if they were local". Cajo project. 2007-08-04. Retrieved 2008-01-19. 
  3. ^ "Why script cajo?". Cajo project. 2007-08-04. Retrieved 2008-01-19. 
  4. ^ "Using cajo Multicasting". Cajo project. 2007-08-04. Retrieved 2008-01-19. 
  5. ^ "Using the cajo proxy mechanism". Cajo project. 2007-08-04. Retrieved 2008-01-19. 

External links[edit]