So generieren Sie die XML

Nachdem Sie nun die Struktur der Anwendung eingerichtet und den gesamten Netzwerkcode geschrieben haben, müssen Sie den Code schreiben, der die XML generiert und parst. Beginnen Sie damit, den Code, mit dem die SC_CALLBACK_REG-XML-Registrierungsmeldung generiert wird, zu schreiben.

Eine SC_CALLBACK_REG-Meldung besteht aus einem Registrierungstyp (ADD_CLIENT, REMOVE_CLIENT, ADD_EVENTS oder REMOVE_EVENTS), einem Rückruf-Port und einer Liste mit wichtigen Ereignissen. Jedes Ereignis besteht aus einer Klasse und einer Unterklasse, gefolgt von einer Liste der Namens- und Wertepaare.

In diesem Teil des Beispiels schreiben Sie eine CallbackReg-Klasse, die den Registrierungstyp, den Rückmelde-Port und die Liste der Registrierungsereignisse speichert. Diese Klasse kann sich auch selbst in eine SC_CALLBACK_REG-XML-Meldung serialisieren.

Eine interessante Methode dieser Klasse ist die convertToXml-Methode, die eine SC_CALLBACK_REG-XML-Meldungszeichenkette aus den Klassenmitgliedern erstellt. In der JAXP-Dokumentation unter http://java.sun.com/xml/jaxp/index.html wird der Code dieser Methode detailliert beschrieben.

Die Implementierung der Event-Klasse wird im folgenden Beispielcode dargestellt. Beachten Sie, dass die CallbackReg-Klasse eine Event-Klasse verwendet, das ein Ereignis speichert und das dieses Ereignis in ein XML- Element konvertieren kann.

Schritte

1. Erstellen Sie den Java-Code, der die vorstehende Logik implementiert.

   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. Implementieren Sie die Event- und NVPair-Klassen.

   Beachten Sie, dass die CallbackReg-Klasse eine Event-Klasse verwendet, die wiederum eine NVPair -Klasse verwendet.

   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;
   }