4th International Conference on Principles and Practices ... - MADOC

to use an existing object instance instead. For example, users of
our mechanism can write the following Java codes to persist a
UserClass object:
UserClass s = new UserClass();
encoder.setPersistenceDelegate(UserClass.class,
new UserClassDelegate() );
encoder.getInterpreter().defineVariable
("myUserClass", s);
encoder.setCacheEnabled(true);
encoder.writeObject(s, "//executescripthere"); ….
The result is shown in Figure 2. Note that the decision about using a
cached object is made in the encoding process. If the
setCacheEnabled(true) method is called by the encoder, the
decoder must call the corresponding readObject(true) method to
use the cached object in the decoding process.
...
UserClass0
myUserClass
…
...
myUserClass
// put script here
....
Figure 2. Enabling cache pool.
Name of the
Cached Object
Properties of the
Cached Object
Mapping of
Name Spaces
Before the encoder writes all the properties of the UserClass in the
XML text file, a hash table must be written. In the decoding stage,
the XMLDecoder will use this table to decide which object should
not be instantiated. It will then use an existing object instance from
the interpreter’s object pool instead, and reset all the properties of
the UserClass object. For users to get the UserClass object with new
properties in the decoding process, the Java codes may look like
this:
UserClass s = new UserClass();
decoder.getInterpreter().defineVariable
("myUserClass", s);
…
UserClass s1 = (UserClass)
decoder.readObject(true); ….
Here, the readObject(true) method is used to notify the
XMLDecoder that the object is cached and therefore it should not
try to instantiate a new object. In this manner, new properties
recorded in the XML text for this cached object will be set up, and
then returned. In the above example, the variables s and s1 refer to
the same object.
Note that because a Singleton object does not have a public
constructor, its instance cannot be persisted using the
XMLEncoder’s writeObject() method. On the other hand, users
cannot write a PersistenceDelegate class for a Singleton because in
order to let a PersistenceDelegate work, more than one instance of
the class must be created, which violate the nature of a Singleton.
Our mechanism can be used to solve this problem.
Users can write a wrapper class to access the Singleton object. The
wrapper object is used to hold all the properties of the Singleton
object in the encoding process so that the wrapper object is
persisted. In the decoding process, users can instantiate a wrapper
object bound to the Singleton, and cache it in the object pool.
Hence, all properties stored in the wrapper object can be retrieved
from the XML text and set for the Singleton object via running the
script (if any) along with the wrapper object. This process is
suitable for argument passing of Web services or remote procedure
calls. It can also be applied when an undo/redo function is added to
Java applications or Java integrated development environments.
4. API IMPLEMENTATION
This section presents the API implementation of the extensible
mechanism. The key features of the implementation are (1) an
interpreter is integrated with the XMLEncoder and the
XMLDecoder; (2) the name spaces of the XMLEncoder and the
interpreter are mapped; and (3) cached objects can be used, instead
of instantiating new objects.
The result of the implemented mechanism is a Java API package,
which is available for download publicly from the web site
http://sml-109.iis.sinica.edu.tw/eLTP/.
4.1 Integration of a Java source interpreter
In order to run scripts in the decoding process, a Java source code
interpreter must be utilized. Any interpreters that can interact with a
Java virtual machine are suitable; therefore we have designed an
interface XMLScriptInterpreter for these interpreters, as shown in
Figure 3. A concrete class that implements this interface is regarded
as a proxy of the practical interpreter.
The XMLScriptInterpreter interface defines five methods. The
interpret() method is used to run the script, the two defineVariable()
methods are used to define variables in the interpreter environment,
the setVariable() method is used to set the value of a variable, and
the getVariable() method is used to get the value of a specified
variable.
interface XMLScriptInterpreter
{
void interpret(String script);
void defineVariable(String var, Object obj);
void defineVariable(String var, Object obj, Class c);
void setVariable(String name, Object value);
Object getVariable(String name);
}
Figure 3. The XMLScriptInterpreter interface.
97