Cómo generar XML

Ahora que se ha configurado la estructura de la aplicación y se ha escrito todo el código de red, debe escribirse el código que genera y analiza XML. En primer lugar, escriba el código que genera el mensaje de registro XML SC_CALLBACK_REG.

Un mensaje SC_CALLBACK_REG está formado por un tipo de registro (ADD_CLIENT, REMOVE_CLIENT, ADD_EVENTS , or REMOVE_EVENTS), un puerto de rellamada y una lista de eventos de interés. Cada evento consta de una clase y una subclase, seguidos de una lista de pares de nombres y valores.

En esta parte del ejemplo, se escribe una clase CallbackReg que guarda el tipo de registro, el puerto de rellamada y la lista de eventos de registro. Esta clase también puede serializarse para un mensaje de XML SC_CALLBACK_REG.

Un método interesante de esta clase es el convertToXml, que crea una cadena de mensaje de XML SC_CALLBACK_REG a partir de los miembros de la clase. La documentación de JAXP ubicada en http://java.sun.com/xml/jaxp/index.html describe de forma más detallada el código de este método.

La implementación de la clase Event se muestra en el siguiente código de ejemplo. Tenga en cuenta que la clase CallbackReg utiliza una clase Event, que permite almacenar un evento y convertirlo en un elemento, Element, XML.

Pasos

1. Crear el código Java que aplica la lógica anterior.

   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. Implemente las clases Event y NVPair.

   Tenga en cuenta que la clase CallbackReg utiliza Event, que a su vez utiliza una clase NVPair .

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