How to Generate the XML

Now that you have set up the structure of the application and have written all the networking code, you need to write the code that generates and parses the XML. Start by writing the code that generates the SC_CALLBACK_REG XML registration message.

An SC_CALLBACK_REG message consists of a registration type (ADD_CLIENT, REMOVE_CLIENT, ADD_EVENTS, or REMOVE_EVENTS), a callback port, and a list of events of interest. Each event consists of a class and a subclass, followed by a list of name and value pairs.

In this part of the example, you write a CallbackReg class that stores the registration type, callback port, and list of registration events. This class also can serialize itself to an SC_CALLBACK_REG XML message.

An interesting method of this class is the convertToXml method, which creates an SC_CALLBACK_REG XML message string from the class members. The JAXP documentation at http://java.sun.com/webservices/jaxp/ describes the code in this method in more detail.

The implementation of the Event class is shown in the following example code. Note that the CallbackReg class uses an Event class that stores one event and can convert that event to an XML Element.

1. Create the Java code that implements the preceding logic.

   class CallbackReg
   {
           public static final int ADD_CLIENT = 0;
           public static final int ADD_EVENTS = 1;
           public static final int REMOVE_EVENTS = 2;
           public static final int REMOVE_CLIENT = 3;
   
           public CallbackReg()
           {
                   port = null;
                   regType = null;
                   regEvents = new Vector();
           }
   
           public void setPort(String portIn)
           {
                   port = portIn;
           }
   
           public void setRegType(int regTypeIn)
           {
                   switch (regTypeIn) {
                   case ADD_CLIENT:
                           regType = "ADD_CLIENT";
                           break;
                   case ADD_EVENTS:
                           regType = "ADD_EVENTS";
                           break;
                   case REMOVE_CLIENT:
                           regType = "REMOVE_CLIENT";
                           break;
                   case REMOVE_EVENTS:
                           regType = "REMOVE_EVENTS";
                           break;
                   default:
                           System.out.println("Error, invalid regType " +
                               regTypeIn);
                           regType = "ADD_CLIENT";
                           break;
                   }
           }
   
           public void addRegEvent(Event regEvent)
           {
                   regEvents.add(regEvent);
           } 
   
           public String convertToXml()
           {
                   Document document = null;
                   DocumentBuilderFactory factory =
                       DocumentBuilderFactory.newInstance();
                   try {
                           DocumentBuilder builder = factory.newDocumentBuilder();
                           document = builder.newDocument(); 
                   } catch (ParserConfigurationException pce) {
                           // Parser with specified options can't be built
                           pce.printStackTrace();
                           System.exit(1);
                   }
   
                   // Create the root element
                   Element root = (Element) document.createElement("SC_CALLBACK_REG");
   
                   // Add the attributes
                   root.setAttribute("VERSION", "1.0");
                   root.setAttribute("PORT", port);
                   root.setAttribute("regType", regType);
   
                   // Add the events
                   for (int i = 0; i < regEvents.size(); i++) {
                           Event tempEvent = (Event)
                               (regEvents.elementAt(i));
                           root.appendChild(tempEvent.createXmlElement(document));
                   }
                   document.appendChild(root);
   
                   // Convert the whole thing to a string
                   DOMSource domSource = new DOMSource(document);
                   StringWriter strWrite = new StringWriter();
                   StreamResult streamResult = new StreamResult(strWrite);
                   TransformerFactory tf = TransformerFactory.newInstance();
                   try {
                           Transformer transformer = tf.newTransformer();
                           transformer.transform(domSource, streamResult);
                   } catch (TransformerException e) {
                           System.out.println(e.toString());
                           return ("");
                   }
                   return (strWrite.toString());
           }
   
           private String port;
           private String regType;
           private Vector regEvents;
   }

2. Implement the Event and NVPair classes.

   Note that the CallbackReg class uses an Event class, which itself uses an NVPair class.

   class Event
   {
   
           public Event()
           {
                   regClass = regSubclass = null;
                   nvpairs = new Vector();
           }
   
           public void setClass(String classIn)
           {
                   regClass = classIn;
           }
   
           public void setSubclass(String subclassIn)
           {
                   regSubclass = subclassIn;
           }
   
           public void addNvpair(NVPair nvpair)
           {
                   nvpairs.add(nvpair);
           }
   
           public Element createXmlElement(Document doc)
           {
                   Element event = (Element)
                       doc.createElement("SC_EVENT_REG");
                   event.setAttribute("CLASS", regClass);
                   if (regSubclass != null) {
                           event.setAttribute("SUBCLASS", regSubclass);
                   }
                   for (int i = 0; i < nvpairs.size(); i++) {
                        NVPair tempNv = (NVPair)
                            (nvpairs.elementAt(i));
                        event.appendChild(tempNv.createXmlElement(doc));
                   }
                   return (event);
           }
   
           private String regClass, regSubclass;
           private Vector nvpairs;
   }
   
   class NVPair
   {
           public NVPair()
           {
                   name = value = null;
           }
   
           public void setName(String nameIn)
           {
                   name = nameIn;
           }
   
           public void setValue(String valueIn)
           {
                   value = valueIn;
           }
   
           public Element createXmlElement(Document doc)
           {
                   Element nvpair = (Element)
                       doc.createElement("NVPAIR");
                   Element eName = doc.createElement("NAME");
                   Node nameData = doc.createCDATASection(name);
                   eName.appendChild(nameData);
                   nvpair.appendChild(eName);
                   Element eValue = doc.createElement("VALUE");
                   Node valueData = doc.createCDATASection(value);
                   eValue.appendChild(valueData);
                   nvpair.appendChild(eValue);
   
                   return (nvpair);
           }
   
           private String name, value;
   }