Java(TM) Boutique - An Introduction to Remote Method Activation (ROA), Part 2

Tutorials : An Introduction to Remote Method Activation (ROA), Part 2 :

Register An Activation Group

Before you can create an activation group, you must register the group to the activation system.

First, create an ActivationGroupDesc object (like you just saw) and call the registerGroup method. This method has only one argument, which represents the group descriptor and returns the group identifier (an ActivationGroupID object). The registerGroup method is located in the ActivationSystem interface:

ActivationGroupID registerGroup(ActivationGroupDesc AGD) throws ActivationException,
RemoteException

To access the activation system, call the ActivationGroup.getSystem method:

public static ActivationSystem getSystem()throws ActivationException

This article's example uses the default activation group, and thus, the default group descriptor. The only system property you'll use is the java.security.policy, to set the security manager (12.policy file), which is required. After that, you must register the group.

Now, you can finally call the createGroup method:

�
Properties sys_prop=System.getProperties(); 
         sys_prop.put("java.security.policy","12.policy"); 
�
ActivationGroupDesc.CommandEnvironment AGD=null; 
ActivationGroupDesc group=new ActivationGroupDesc(sys_prop,AGD);
ActivationGroupID AGid=ActivationGroup.getSystem().registerGroup(group);
ActivationGroup.createGroup(AGid,group,0);
�

To include an activable remote object into an activation group, pass the corresponding group identifier (the ActivationGroupID returned by the registerGroup method) to the activation descriptor. For example:

�
ActivationDesc AD=new ActivationDesc(AGid,"PrinterImplActivatable",url,data);
�

Obviously, when you have only one activation group, you don't need to use the above form.

Initializing an Activable Remote Object Using the MarshalledObject Class

So far, the activable remote objects you've seen have been initialized with the null value. This is equivalent to "no initialization information".

These classes define streams of bytes that reflect the serialization of the received objects. The objects are passed to this class through its only constructor:

public MarshalledObject(Object obj) throws IOException

This is not just an initialization method, it is also a convenient way to conserve the persistent character of an activable remote object. The initialization information (an object state) can be stored so you can use it later for initialization of the object—when the object is activated/reactivated (an object can transit from passive to active and get initialize with it old state).

Most commonly, the initialization information is stored into a file and the information is retrieved to initialize the object when you want to activate or reactivate the corresponding activable remote object. For example, suppose you want to store the initialization information into a file called Init.txt:

�
MarshalledObject data=new MarshalledObject(new File(".//Init.txt"));
�

After you create the MarshalledObject, pass it as an argument to the activation descriptor (ActivationDesc) at the moment of its creation.

�
ActivationDesc AD=new ActivationDesc("PrinterImplActivatable",url,data);
�

When you try to activate or reactivate an activable remote object, you must first initialize it with the information from the corresponding file by calling the MarshalledObject.get method. This method returns a de-serialized copy of the serialized object. Because the get method returns an Object, you must do a cast conversion to a File object (just as an example). After that, you can call the File.exists method to verify whether the file exists or not.

If the file exists, you can read the information from it and use it to initialize the activable remote object. If the file doesn't exist, you must initialize the activable remote object manually—just like the first time. For example, suppose you want to keep the initialization information for a PrinterImplActivatable object in the Init.txt file, created in the current directory. The only initialization data that you keep is the value of the jobs variable (remember from Part 1 that this variable is counting the printer jobs). The activation/reactivation constructor becomes:

�
int jobs=0;                //counting the printer jobs
private File storage=null; //the file for storing the initialization information
�
//defining the activation/reactivation constructor for the activable remote object 
- this //constructor is called by the rmid
 public PrinterImplActivatable(ActivationID id,MarshalledObject data)
      throws RemoteException
       {
       super(id,0);

       try{
          //get the de-serialize form of the object
          storage=(File)data.get();

          //verify if the file exists
          if(storage.exists())
           {
           //the file exists -> initialization of the object
           this.restoreObject();
           }else
               {
               //the file doesn't exists -> manually initialization
               jobs=0;
               }
          }catch(IOException e)
              {System.out.println(e.getMessage());
          }catch(java.lang.ClassNotFoundException e)
              {System.out.println(e.getMessage());}    
       }
�

Here's the restoreObject method implementation:

�
private void restoreObject()
      {
	File F=storage;
	try
        {
	  FileInputStream FIS=new FileInputStream(F);
        ObjectInputStream OIS=new ObjectInputStream(FIS);
        jobs=(Integer)OIS.readObject();
        OIS.close();
	  }catch(IOException e)
           {System.out.println(e.getMessage());
        }catch(ClassNotFoundException e)
           {System.out.println(e.getMessage());}        
 }
�

Besides the method that reads the information from the file, you need a help method that upgrades the content of the file every time the jobs variable is affected. Normally, the jobs variable is affected only when the client calls either the setPrinterJobs or removePrinterJobs methods. This is demonstrated by the saveObject method below:

�
    private synchronized void saveObject()
        {
        FileOutputStream FOS=null;
        ObjectOutputStream OOS=null;

	    File F=storage;
	    try
            {
	  	FOS=new FileOutputStream(F);
		OOS=new ObjectOutputStream(FOS);		
	    	OOS.writeObject(jobs);
		OOS.close();
	      }catch(IOException e)
              {System.out.println(e.getMessage());}
   }
�

Listing 1 shows the complete source for the PrinterImplActivatable class and Listing 2 shows the source for the PrinterServerActivatable class.

Note: The MarshalledObject class can also be used to pass arguments to the activable remote objects.

Home / Articles / An Introduction to Remote Method Activation (ROA), Part 2) / 1 / 2 /

Applet Index
(sorted alphabetically)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z #s

The Java Source
(applets w/source code)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z

How to Add Java Applets to Your Site

New on the Java Boutique:

New Review:

Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling API boasts simplicity, ease-of-integration, a well-rounded feature set, and it's free!

New Applet:

Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA sequences into three useful formats.