11.3.1. A Shared Handler

The scheduler should allow clients to add and remove events. Clients can then query the scheduler for a list of all events in the queue. To make this more practical (and to have a task for the server to perform later), querying the current events returns them sorted by the time they occurred. An event for this example is simply a String event name and a time for the event (in a java.util.Date format). Though this is not a complete scheduler implementation, it can demonstrate how to let the server do behind-the-scenes work for clients.

package javaxml2;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Hashtable;
import java.util.Vector;

public class Scheduler {

    // Existing method implementations

    public Vector getListOfEvents( ) {     
        Vector list = new Vector( );
        
        // Create a Date Formatter
        SimpleDateFormat fmt = 
            new SimpleDateFormat("hh:mm a MM/dd/yyyy");        
        
        // Add each event to the list
        for (int i=0; i<events.size( ); i++) {
            String eventName = (String)events.elementAt(i);
            list.addElement("Event \"" + eventName + 
                            "\" scheduled for " +                           
                            fmt.format(
                                (Date)eventDetails.get(eventName)));
        }
        
        return list;
    }
}

package javaxml2;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public class Scheduler {
    
    /** List of event names (for sorting) */
    private static Vector events = new Vector( );
    
    /** Event details (name, time) */
    private static Hashtable eventDetails = new Hashtable( ); 
    
    /** Flag to indicate if events are sorted */
    private static boolean eventsSorted;

    // Existing method implementations

    private synchronized void sortEvents( ) {        
        if (eventsSorted) {
            return;
        }
      
        // Create array of events as they are (unsorted)
        String[] eventNames = new String[events.size( )];
        events.copyInto(eventNames);
                
        // Bubble sort these
        String tmpName;
        Date date1, date2;
        for (int i=0; i<eventNames.length - 1; i++) {
            for (int j=0; j<eventNames.length - i - 1; j++) {
                // Compare the dates for these events                
                date1 = (Date)eventDetails.get(eventNames[j]);
                date2 = (Date)eventDetails.get(eventNames[j+1]);
                if (date1.compareTo(date2) > 0) {
                    
                    // Swap if needed
                    tmpName = eventNames[j];
                    eventNames[j] = eventNames[j+1];
                    eventNames[j+1] = tmpName;
                      
                }
            }
        }
        
        // Put into new Vector (ordered)
        Vector sortedEvents = new Vector( );
        for (int i=0; i<eventNames.length; i++) {
            sortedEvents.addElement(eventNames[i]);
        }
        
        // Update the global events
        events = sortedEvents;
        eventsSorted = true;
     
    }
}

package javaxml2;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public class Scheduler {

    public Scheduler( ) {
        eventsSorted = true;
    }

    public boolean addEvent(String eventName, Date eventTime) {      
        // Add this event to the list of events
        if (!events.contains(eventName)) {
            events.addElement(eventName);
            eventDetails.put(eventName, eventTime);
            eventsSorted = false;            
        }
      
        return true;
    }

    // Other method implementations
}

package javaxml2;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public class Scheduler {

    // Existing variables and methods

    public boolean addEvent(String eventName, Date eventTime) {      
        // Add this event to the list of events
        if (!events.contains(eventName)) {
            events.addElement(eventName);
            eventDetails.put(eventName, eventTime);
            eventsSorted = false;
            
            // Start thread on server sorting
            SortEventsThread sorter = new SortEventsThread( );
            sorter.start( );                        
        }
      
        return true;
    }

    class SortEventsThread extends Thread {
        
        public void run( ) {
            sortEvents( );
        }    
    }
}

11.3.2. A Configurable Server

Nothing remarkable here. The code ensures that the required parameters are passed in and then starts the server on the requested port. It's now time to add in methods to load the handlers from a file, and then add those handlers one by one to the server.

Because each handler needs a name and an associated class, you can create a configuration file that has these two pieces of information. With Java, it is easy to load and instantiate a class with its complete package and name. This means you can completely represent a new handler with a pair of textual values. Within this file, you can add both the original HelloHandler class as well as the new Scheduler class. Since you are writing the file parser as well, it's safe to arbitrarily decide to use commas as delimiters and the pound sign (#) as a comment marker. In fact, you can use whatever format you wish as long as you write code that uses your conventions in parsing the file.

NOTE: You may be surprised that I'm not using an XML file format here. There are several reasons for this. First, I'm going to talk about SOAP in the next chapter, which uses XML throughout. Using a non-XML format here provides a good contrast between the two methodologies. Second, you're certainly prepared at this point to write your own XML parsing code, so this task is a good exercise. And third, I'm a realist; you'll be amazed at how many times "XML frameworks" and "XML applications" use non-XML formats. So get used to it now, as you're sure to encounter it time and time again.

For documentation purposes, I've specified the methods available to each handler in comments. This allows future maintainers of this configuration file to know what methods are available for each handler.

Java's I/O classes make it easy to load this file and read its contents. It's simple to create a helper method that reads the specified file and stores the pairs of values in a Java Hashtable. The object can then be passed on to another helper that loads and registers each handler. This example method does not do extensive error checking as a production-ready server might, and it simply ignores any line without a pair of comma-separated values. It is easy to add error handling if you want to use this code in your applications. Once it finds a line with a pair of values, the line is broken up and the class identifier and class name are stored as an entry within the Hashtable. Add the import statements for the required utility classes and then the new getHandlers( ) method to the LightweightServer class now:

package javaxml2;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Hashtable;

import helma.xmlrpc.XmlRpc;
import helma.xmlrpc.WebServer;

public class LightweightXmlRpcServer {

    // Existing method implementations

    private Hashtable getHandlers( ) throws IOException {

        Hashtable handlers = new Hashtable( );
        
        BufferedReader reader = 
            new BufferedReader(new FileReader(configFile));
        String line = null;
        
        while ((line = reader.readLine( )) != null) {
            // Syntax is "handlerName, handlerClass"
            int comma;
            
            // Skip comments
            if (line.startsWith("#")) {
                continue;
            }
            
            // Skip empty or useless lines            
            if ((comma = line.indexOf(",")) < 2) {
                continue;
            }
            
            // Add the handler name and the handler class
            handlers.put(line.substring(0, comma), 
                         line.substring(comma+1));
        }
        
        return handlers;        
    }
}

Instead of adding code to save the result of this method, you can use that result as input to a method that iterates through the Hashtable and adds each handler to the server. The code needed to accomplish this task is not complicated; the only notable thing is that the addHandler( ) method of WebServer requires an instantiated class as a parameter. The code is required to take the name of the class to register from the Hashtable, load that class into the JVM with Class.forName( ), and then instantiate that class with newInstance( ). This is the methodology used in class loaders and other dynamic applications in Java, but may be unfamiliar to you if you are new to Java or have not had to dynamically instantiate classes from a textual name before. Once the class is loaded in this way, it and the class identifier are passed to the addHandler( ) method, and the iteration continues. Once the contents of the Hashtable are loaded, the server is set up and ready to go. I've used the Enumeration class to cycle through the keys in the Hashtable, so you'll need to add this import statement to your source file:

package javaxml2;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;

import helma.xmlrpc.XmlRpc;
import helma.xmlrpc.WebServer;

public class LightweightXmlRpcServer {

    // Existing method implementations

    private void registerHandlers(Hashtable handlers) {        
        Enumeration handlerNames = handlers.keys( );
        
        // Loop through the requested handlers
        while (handlerNames.hasMoreElements( )) {
            String handlerName = (String)handlerNames.nextElement( );
            String handlerClass = (String)handlers.get(handlerName);
            
            // Add this handler to the server
            try {
                server.addHandler(handlerName, 
                    Class.forName(handlerClass).newInstance( ));
                
                System.out.println("Registered handler " + handlerName +
                                   " to class " + handlerClass);
            } catch (Exception e) {
                System.out.println("Could not register handler " + 
                                   handlerName + " with class " + 
                                   handlerClass);
            }
        }
    }
}

This is simply a complement to the getHandlers( ) method; in fact, it takes the result of that method as input. It uses the String values within the Hashtable and registers each. Now the server is running and will have any handlers in the configuration file loaded and available for remote calls. You could just as easily have consolidated these methods into one larger method. However, the purposes of the two methods are significantly different; while one, getHandlers( ), deals with parsing a file, the other, registerHandlers( ), deals with registering handlers once information about the handlers is available. With this methodology, you can change the way you parse the configuration file (or even have it read from a database or other medium) without having to worry about the way the handlers are registered.

Once you have added these two helper methods, add their invocation to the start( ) method of your server class:

    public void start( ) throws IOException {
        try {
            // Use Apache Xerces SAX Parser
            XmlRpc.setDriver("org.apache.xerces.parsers.SAXParser");

            System.out.println("Starting up XML-RPC Server...");
            server = new WebServer(port);                      
            
            // Register handlers
            registerHandlers(getHandlers( ));
            
        } catch (ClassNotFoundException e) {
            throw new IOException("Error loading SAX parser: " + 
                e.getMessage( ));
        }         
    }

11.3.3. A Useful Client

As you are entering this code, notice that the events are added in reverse order of the event time. The server rearranges these events with the sortEvents( ) method to facilitate correctly ordered results when the getListOfEvents( ) method is called. The server takes care of this sorting next.

11.3.4. Talk to Me (Again)

Finally, execute your client and see the results:

$ java javaxml2.SchedulerClient

Adding events...

Event added.
Event added.

Listing events...

Event "Submit final draft" scheduled for 10:55 AM 05/09/2001
Event "Proofread final draft" scheduled for 10:55 AM 06/08/2001