HK1067210A - System & method of mapping between software objects & structured language element-based documents - Google Patents

Description

System and method for mapping between software objects and structured language element based documents

Technical Field

The invention relates to the field of conversion or mapping between software objects and documents of structured language elements, particularly in relation to documents such as Java^TMMapping between various software objects of an object and an extensible markup language (XML) file.

Background

Extensible markup language (XML) is a truncated version of standard production markup language (SGML) designed specifically for web documents. It allows designers to create their own custom tags, providing functionality not provided by HTML. For example, XML supports links that can point to multiple documents, as opposed to HTML links that can reference only one document per link.

Because XML is a form of self-describing data (also referred to as structured language elements in the description of the present invention), it can be used in code for enhanced data models. Thus, XML can be used as a data exchange medium between different systems. Data such as legacy COBOL programs, databases, C + + programs, and the like may be published or published in XML in many types of systems. One commonly encountered business problem includes: how to map information from an XML file to other data formats and the reverse operation thereof, for example, once information is exchanged between instances of an XML file format, it may be necessary to map its information to Java objects, which can be used when making database or transactional requests.

An example of an XML/Java translation tool is disclosed in U.S. Pat. No. 6,125,391 to Meltzer et al, published 26/9/2000. To convert from XML to Java, Meltzer et al parses the XML file and raises an event. Specifically, one parser traverses an XML document and builds a tree representation in memory for querying, while another parser traverses an XML document and raises an event with information about the document (e.g., a start document event; a start element event with an element name, an element content, an end element event, an end document event, etc.).

To convert from Java to XML, Meltzer et al generates code that includes an accessor for each element. The accessor of elements comprises a loop that loops once per character. The loop contains switch statements that perform actions depending on why the character is. The action is to create a StringBuffer that contains the element fragments of the XML document. The solution of Meltzer et al does not provide support for processing code that converts Java to XML. In the Meltzer et al approach, all code is generated and is not easily editable by the user.

As a result, there is a need for a mapping framework to support mapping between software objects and structured language element based documents (e.g., XML) that can be efficiently implemented using standard tools.

Disclosure of Invention

The above-summarized shortcomings of the prior art are overcome in accordance with the exemplary method and system of the present invention, wherein a common framework is provided for mapping between files (e.g., XML files) and software objects (e.g., Java objects). The framework uses a processor to mask how attributes are obtained for mapping. This results in mapping code having a common appearance in both directions. The mapping between the elements of the XML file and the attributes of the Java object is contained in the mapper. The mapper maps from the XML document to the software object using a parser, such as a Document Object Model (DOM) of XML or a simple Application Program Interface (API) (SAX).

The mapping in the other direction (Java to XML) requires that the elements of the XML file be created in a special order to ensure the validity of the resulting XML file. For example, to ensure such effectiveness, exemplary embodiments of the present invention use JavaServer Pages^TM(JSP) creates an XML template file. Using JSP-based templates enables tags to be written in JSP with callbacks to get element and attribute values. JSP is completely documented with editor support, and templates can be created efficiently. Again, the content can be directed to the buffer or directly to the response stream of the servlet.

According to an aspect of the invention, there is provided a computer-implemented method of converting a data structure representing a software object into structured language elements of a file, the method comprising: (a) generating a structured language element template file; (b) reading attributes from the software object, the attributes being associated with structured language elements of the document; (c) using the attributes, obtaining a building block defined by the structured language element based on the association between the attributes and the structured language element; and (d) populating the structured language element template file with the components.

According to another aspect of the invention, there is provided a computer-implemented method of converting structured language elements of a document into a data structure representing a software object, the method comprising: (a) reading each structured language element of the document; (b) selecting from a set of available attributes defined by a data structure of the software object, determining attributes associated with structured language elements of the document; and (c) populating attributes of the data structure representing the software object with the structured language element values from the file.

According to another aspect of the present invention there is provided a system for converting a software object containing properties into a document defined by a structured language element, the system comprising: (a) a document template; (b) a processor interface for providing a representation of the structured language elements of the document in response to a callback of the document template; (c) the mapping module is communicated with the processor interface and converts the attribute of the software object into the structured language element identified by the file; and (d) outputting the target class, communicating with the mapping module, and writing the structured language elements generated in the step (c) into a file.

According to another aspect of the present invention, there is provided a system for converting a document containing structured language elements into software objects, the system comprising: (a) an analyzer for obtaining events representing characteristics of the file; (b) inputting a source class for reading a file; (c) a content handler class in communication with the input source class to implement a buffer for events acquired by the analyzer; and (d) a mapping module, in communication with the content handler class, that translates the events obtained by the parser into attributes of the software object.

According to another aspect of the present invention, there is provided a method of converting a software object having properties into a document represented by structured language elements, the method comprising: (a) providing the software object to an instance of the invoked mapping interface; (b) compiling and executing the template using the instance of the called container; and (c) writing the file to the particular output stream using the compiled template.

According to another aspect of the present invention, there is provided a method of converting a document containing structured language elements into a software object, the method comprising: (a) provisioning instances of the invoked mapping interface with a file; (b) registering the mapping interface as a content handler; (c) analyzing the file using the instance of the invoked analyzer; and (d) populating the software object with attributes associated with the structured language elements parsed from the file by the callback mapping interface.

According to another aspect of the present invention, there is provided a computer program product for converting a data structure representing a software object into structured language elements of a document, the computer program product comprising computer readable program code means for: (a) generating a structured language element template file; (b) reading attributes from the software object, the attributes being associated with structured language elements of the document; (c) using the attributes, obtaining a building block defined by the structured language element based on the association between the attributes and the structured language element; and (d) populating the structured language element template file with the components.

According to another aspect of the present invention, there is provided a computer program product for converting structured language elements of a document into a data structure representing a software object, the computer program product comprising computer readable program code means for: (a) reading each structured language element of the document; (b) selecting from a set of available attributes defined by a data structure of the software object, determining attributes associated with structured language elements of the document; and (c) populating attributes of the data structure representing the software object with the structured language element values from the file.

Other aspects and features of the present invention will become apparent to those ordinarily skilled in the art upon review of the following description of embodiments of the invention in conjunction with the accompanying figures.

Description of the drawings

Further features and advantages of the invention will be described in the detailed description which follows, taken in conjunction with the accompanying drawings, in which:

FIG. 1 is a block diagram of a computer system that may be used to implement the methods and apparatus of embodiments of the present invention;

FIG. 2 is a block diagram illustrating a framework for mapping between XML and Java objects and their reverse operations;

FIG. 3 is a flow chart illustrating a method of mapping an XML file to a software object using the framework of FIG. 2; and

FIG. 4 is a flow chart illustrating a method of mapping a software object to an XML file using the framework of FIG. 2.

Detailed Description

FIG. 1 and the associated description represent an example of a suitable computing environment in which the invention may be implemented. While the invention will be described generally in terms of computer-executable instructions of a computer program that executes on a personal computer, the invention can also be implemented in combination with other program modules.

Generally, the program modules include: routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The invention may further be practiced with other computer system configurations, including hand-held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both server and remote memory storage devices.

Referring to fig. 1, an exemplary system 10 includes: a conventional personal computer 20 includes a processing unit 22, a system memory 24, and a system bus 26 that couples various system components including the system memory 24 and the processing unit 22. The system bus 26 includes several types of bus structures, including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of conventional bus architectures (e.g., PCI, VESA, ISA, EISA, etc.).

The system memory 24 includes Read Only Memory (ROM)28 and Random Access Memory (RAM) 30. A basic input/output system (BIOS)32, containing the basic routines that help to transfer information between elements within the computer 20, such as during start-up, is stored in ROM 28. The computer 20 also includes a hard disk drive 34, a magnetic disk drive 36 (for reading from and writing to a removable magnetic disk 38), and an optical disk drive 40 (for reading a CD-ROM disk 42 or for reading from or writing to other optical media). The drives 34, 36, and 40 are connected to the system bus 26 by interfaces 44, 46, and 48, respectively.

The drives 34, 36, and 40 and their associated computer-readable media (38, 42) provide nonvolatile storage of computer 20 data, data structures, and computer-executable instructions. The storage medium of fig. 1 is only an example and is known to a person skilled in the art: other types of media that can be read by a computer (e.g., magnetic cassettes, flash memory cards, digital video disks, etc.) are also included.

Some program modules including an operating system 50, one or more application programs 52, other program modules 54, and program data 56 are stored in the drives 34, 36, and 40 and RAM 30. A user may enter commands and information into the computer 20 through keyboard 58 and input devices 60, such as a mouse, microphone, joystick, game pad, satellite dish, scanner, or the like. These devices (58 and 60) are connected to the processing unit 22 by a port interface 62 (e.g., serial port, parallel port, game port, Universal Serial Bus (USB), etc.) that is coupled to the bus 26. A monitor 64 or other type of display device is also connected to the bus 26 via an interface 66, such as a video converter.

The computer 20 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 68. The remote computer 68 may be a server, a router, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 20, although, for purposes of simplicity, only a memory storage device 70 has been illustrated. The logical connections depicted in FIG. 1 include a server network (LAN)72 and a Wide Area Network (WAN) 74. Such networking environments are commonplace in offices, enterprise-wide computer networks, enterprise networks, and the Internet.

When used in a LAN networking environment, the computer 20 is connected to the LAN 72 through a network interface or switch 76. When used in a WAN networking environment, the computer 20 typically includes a modem 78 or other means for establishing communications over the WAN 74, such as the Internet. The modem 54, which may be internal or external, is connected to the bus 26 via a port interface 62. In a networked environment, program modules depicted relative to the computer 20, or portions thereof, may be stored in the remote memory storage device 70.

The discussion of the method of the present invention is based on the aspects of conversion/mapping from XML to Java objects and from Java objects to XML. While supporting other data formats. For example, many legacy business applications are written in COBOL, C and PL 1. These applications are hosted, for example, by the CICS^TM(general Online transaction software) or IMS^TMA program in an Enterprise Information System (EIS) (information management system) or the like. The COBOL structure is used for the input and output of the COBOL program. There is a need for mappings from XML to COBOL and from COBOL to XML. The present invention can be used to perform these mappings, where an XML-to-object X mapping handler (discussed below) will populate the COBOL structure from the XML file, and an object X-to-XML mapping handler (discussed below) will extract data from the COBOL structure and be used by the template to populate the XML file.

By way of background, the mapping method of the present invention utilizes the following high level processing: (a) the glossaries group characters into words or tokens (called tokenization) that can be recognized by a particular system; (b) the parser parses the set of tokens to identify legitimate linguistic components; and (c) the code generator takes a set of legal language components and generates executable code. The functions defined by (a) - (c) may be mixed.

For example, for a mapping from XML to a Java object, each character in the XML file is parsed to identify legitimate XML tags such as start tags, attributes, end tags, and "CDATA" fields. Then, it must be verified that the tags form a legitimate XML construct. At the most basic level, verification will: all tags have matching open and close tags and the attributes are properly established under the open tags. If a Document Type Definition (DTD) or XML schema is available, it may be possible to determine that the XML constructs found during parsing are legal in terms of DTD or XML schema, while being XML in its full form. Finally, the data contained in the XML file will be used to do useful things (i.e., mapping to Java objects).

Some of the tasks indicated above may be performed, at least in part, by existing XML parsers. The XML parser handles the tasks of lexical and syntactic analysis. Two examples of parsing criteria are: SAX and DOM APIs (simple Application Programming Interface (API) for SAX-XML; DOM-document object model).

SAX is event based. An XML parser implementing SAX generates events corresponding to different properties found in the parsed XML file. The DOM API is an object model based API. An XML parser implementing DOM creates a generic object model in memory, representing the contents of an XML file. Once the XML parser has completed parsing, the memory will contain a DOM object tree to provide information about both the structure and the content of the XML document.

Fig. 2 is a schematic view of a frame 100 according to an embodiment of the invention. The framework 100 is particularly shown in an integration component 102, such as a Servlet, that may be executed on the system 10 of fig. 1. The integration component 102 includes a parser 104, implemented, for example, using DOM or SAX, that interacts with an XML-object mapping module 106. For clarity, in describing an implementation embodiment of the present invention, SAX will be discussed as an example of analyzer 104.

The XML-to-object mapping module 106 receives an input XML file 108 and produces an output Java object 110. The integration component 102 further includes (e.g., in accordance with JavaServer Pages)^TMJSP technology) XML document template module 112,which communicates with the object-to-XML mapping module 114. The object-to-XML mapping module 114 receives an input Java object 116 and produces an output XML file 118.

Mapping of XML to software objects

Referring to FIG. 2, the XML-object mapping module 106 includes the following components:

(a) an input source class 106-1(XML2xInputSource) to implement an input XML file 108;

(b) a buffer content handler class 106-2(XML2 xBufferContentHandler) to implement a buffer for SAX events generated by the parser 104;

(c) a mapping interface 106-3(XML2xMapping) to perform mapping and set input and output target streams; and

(d) a map class 106-4(XML2xMappingImpl) that provides a method to map from an input XML file 108 to an output Java object 110.

Further details of the various interfaces and classes are discussed below. In Java, the terms "class" and "interface" have special meaning. Java's class (abstract, internal or final) is a collection of data members and methods that define a particular object, while Java's interface is used to specify some function on the class that implements the interface (i.e., what the interface specifies the class must do). The interface is also used to provide constants that the class implementing the interface can use. An interface contains constant variables and method declarations, but the implementation of a method is left to the class that implements the interface. A class may implement any number of interfaces.

Table M106-1 summarizes the main functions (i.e., not all listed) of the input source class 106-1(XML2 xInputSource).

The XML file may be read from a byte stream, a character stream, or XML2 xBuffedcontentHandler 106-2 using XML2 xInputSource.

TABLE M106-1

Function(s)	Description of the invention
		available()	Returning the number of bytes that can be read from the input stream without blocking.
getBufferedHandler()	Processor for obtaining buffer of SAX event
		getByteStream()	Return byte stream
getCharacterStream()	Return character stream reader
		read()	Reading a lower byte of data from the input stream
skip()	Spanning input bytes from the input stream

Table M106-2 summarizes the main functions (i.e., not all) of the buffer content handler class 106-2(XML2 xBufferContentHandler). The processor class 106-2 also includes content processors to buffer SAX events from the analyzer 104. This allows the event to be regenerated. Examples of properties that can be used are: different parts of the XML file use different mapping handlers. Simple Object Access Protocol (SOAP) is an implementation example.

TABLE M106-2

Function(s)	Description of the invention
		Characters(char[]ch，int start，int length)；	Method annotation, where ch is a character from the XML file 108; start is the start position in the array; length is the number of characters read from the array.
Parse()	SAX events in execution buffers

SOAP is a lightweight protocol for exchanging information in a decentralized, distributed environment. It is a protocol based on XML, which is composed of three parts: (1) envelope, defining a framework to describe why and how messages are processed; (2) a set of encoding rules to express instances of application-defined data types; and (3) provisioning to represent remote procedure calls and responses. A SOAP message is an XML file that consists of a required SOAP envelope, an optional SOAP header, and a required SOAP body. In this case, it is possible for the envelope and the body to use different mapping processors.

Table M106-3 summarizes the main functions (i.e., not all listed) of mapping interface 106-3(XML2 xMapping). XML2xMapping performs the mapping and allows the configuration of InputStream.

TABLE M106-3

Function(s)	Description of the invention
		execute()	Creating a mapping of the format from the input XML file 108 is performed. A full example of execute () is provided below.
setInputStream()	Input stream is set-i.e., specifies the source of the mapped input XML file 108.

Table M106-4 summarizes the main functions (i.e., not all listed) of the mapping class 106-4(XML2 xMappinginImpl). As discussed above with respect to the definition of classes and interfaces, the XML2 xMappingiImpl class is not used directly, but rather is subclassed by adding content to the appropriate methods according to the file type definitions of the mapped output Java objects 110 and the input XML files 108 to be mapped.

TABLE M106-4

Function(s)	Description of the invention
		endElement()	An end notification of an element is received. The parser 104 will call this method at the end of each element in the input XML file 108. Each endElement has a corresponding startElement () event even when the element is empty.
execute()	Creating a mapping of the format from the input XML file 108 is performed.
		setDocumentLocator()	An object is received for locating the origin of a SAX file event.
setInputStream()	An input flow is set. Specifying the source of the XML file to be mapped.
		startElement()	A start notification of an element is received. The parser 104 calls this method at the beginning of each element in the input XML file 108. Each startElement () event has a corresponding endElement () event even when the element is an empty element. All element contents are reported sequentially before the corresponding endElement () event.

Referring to FIG. 3, a method 300 is illustrated in which the general steps performed to map an XML file 108 to a software object 110 (e.g., a Java Bean) are shown:

(a) obtain an instance of a mapping interface 106-4 (e.g., XML2 XMaping) for implementing the mapping from XML to object X in step 302;

(b) invoking the mapping interface 106-4 in step 304 and providing the input XML file 108 in step 306;

(c) the mapping interface 106-4 retrieves an instance of the event analyzer (e.g., analyzer 104) in step 308 and registers the mapping interface 106-4 as a content handler (e.g., buffer content handler class 106-2) in step 310;

(d) in step 312, the parser 104 is invoked on the XML file 108 (i.e., the file begins to be parsed);

(e) when step (d) is performed, calling back the mapping interface 106-4 in step 314 to call various methods (e.g., startDocument, startElement, characters, endElement, endDocument, etc.);

(f) at step 316, the mapping interface 106-4 creates the software object 110 in the startDocument and/or startElement methods; and

(g) in step 318, the mapping interface 106-4 sets the element in the software object 110 in the endElement method.

The SAX API discussed above includes many specifications known in the art. The invention relates to creating classes for implementing a "ContentHandler" interface, which is: when the SAX event is found in the XML file, the XML analyzer is used for notifying a callback interface of a program. This interface is used in conjunction with the XML2 xBufferContentHandler class 106-2 and the XML2xInputSource class 106-1. The SAX API also provides the "DefaultHandler" implementation class of the "ContentHandler" interface. Example I "XML-JAVA CUSTOME R" detailed below extends "DefaultHandler" to generate a customer Java Bean from a customer XML file.

Example I

XML-JAVAC USTOMER

The following (detailed) is part of example I:

(A) customer. xml: inputting a sample of the XML file 108;

(B) java: the analyzer 104 calls back the processor class 106-2. Which contains instructions for creating a customer object and setting up its value.

(C) Java: a program to execute mapping classes/interfaces 106-3, 106-4 that map from XML to Java and (as example II below) from Java to XML;

(D) customer. java: an exported customer Java Bean 110; and

(E) java: including integer constants and hash maps. The hash map is an integer constant used to map the tag name to xml2custom mapping.

A. The XML file (customer. XML) of the input is provided below.

∥START customer.xml

<？xml version＝”1.0”？>

<customer>

<FirstName>Jane</FirstName>

<LastName>Doe</LastName>

<CustId>xyz.123</CustId>

</customer>

∥FND customer.xml

B. A program (xml2custom mapping. java) to build a customer object and set its value is provided below, with some pruning for simplicity.

∥START XML2CustomerMapping.java    public class XML2CustomerMapping extends    com.xxx.xml2xmapping.XML2xMappinglmpl{      private StringBuffer fieldCurrent()ualifiedElementName＝new    StringBuffer(““)；        private Customer fieldCustomer；        private Stack elementStack；       *XMLCustomerInfo2RecordCustomerInfoMapper constructor comment.       public XML2CustomerMapping(){         super()；         elementStack＝new Stack()；       }       *characters method comment.       public void characters(char[]ch，int start，int length)throws       org.xml.sax.SAXException{         switch(this.fieldCurrentElementSymbol){         case CustomerSymbols.CUSTOMER_FIRSTNAME：         case CustomerSymbols.CUSTOMER_LASTNAME：         case CustomerSymbols.CUSTOMER_ID：         ((StringBuffer)elementStack.lastElement()).append(ch，start，length)；         break；         }       }       *endElement method comment.       public void endElement(String namespaceURI，String localName，       String rawName)throws org.xml.sax.SAXException{         String symbolName；<dp n="d11"/>    if(namespaceURI.equals(““))symbolName＝rawName；    else symbolName＝namespaceURI+“_”+localName；    this.fieldCurrentElement Symbol＝    CustomerSymbols.getSymbol(symbolName)；    ∥Get the value    String value＝    ((StringBuffer)elementStack.pop()).toString()；      switch(this.fieldCurrentElementSymbol){        case CustomerSymbols.CUSTOMER_FIRSTNAME：{          this.fieldCustomer.setFirstName(value)；          break；        }        case CustomerSymbols.CUSTOMER_LASTNAME：{         this.fieldCustomer.setLastName(value)；           break；        }        case CustomerSymbols.CUSTOMER_ID：{          this.fieldCustomer.setId(value)；          break；        }      }      this.fieldCurrentElementSymbol＝0；    }    *@return com.xxx.connector.mapping.xml.test.Customer    public Customer getCustomer(){<dp n="d12"/>      return this.fieldCustomer；    }    *startElernent method comment.    public void startElement(String namespaceURI，String localName，StringrawName，org.xml.sax.Attributes atts)throws    org.xml.sax.SAXException{      String symbolName；      if(namespaceURI.equals(““))symbolName＝rawName；      else symbolName＝namespaceURI+“_“+localName；       this.fieldCurrentElementSymbol＝      CustomerSymbols.getSymbol(symbolName)；      elementStack.push(new StringBuffer())；      switch(this.fieldCurrentElementSymbol){         case CustomerSyxribols.CUSTOMER：{                this.fieldCustomer＝new Customer()；                break；         }      }    }    }    ∥END XML2CustomerMapping.java

C. A program (execute. Java) to execute a mapping from XML to Java (and from Java to XML as detailed in example II below) is provided below, where pruning is done for brevity.

∥START execute.java<dp n="d13"/>    package com.xxx.xml2xmapping.sample.customer；    import java.io.*；    import org.xml.sax.*；    public class Execute{    *Execute constructor comment.    public Execute(){      super()；    }    *Starts the application.    *@param args an array of command-line arguments    public static void main(java.lang.String[]args)      int numIterations＝1；       XML2CustomerMapping inMapping＝new XML2CustomerMapping()；       Customer2XMLMapping outEventBasedMapping＝new    Customer2XMLMapping()；    ∥Create the XML2Customer handler and the Customer2XML handler    XML2CustomerMapping in Mapping＝new XML2CustomerMapping()；    Customer2XMLMapping outEventBasedMapping＝    new Customer2XMLMapping()；    ∥read in the customer.xml file    ByteArrayInputStream inStream＝null；    try{       FileInputSyteam fileInputStream＝new       FileInputStream(”customer.xml”)；       byte[]bytes＝new byte()[fileInputStream.available()]；       fileInputStream.read(bytes，0，       fileInputStream.available())；       inStream＝new ByteArrayInputStream(bytes)；    }catch(Exception e){       e.printStackTrace()；    }<dp n="d14"/>    ByteArrayOutputStream outStream＝new ByteArrayOutputStream()；     try{      long ts＝System.currentTimeMillis()；      for(int 1＝()；i＜numIterations；i++){      ∥inbound mapping      ∥map from XML document to customer Java Bean inStream.reset()；      inMapPing.setInputStream(inStream)；      inMapping.execute()；      ∥some execution，here a connector would be called      ∥get the customer object and print its contents      Customer aCustomer＝inMapping.getCustomer()；      System.out.println(”First name from XML document is“+aCustomer.getFirstName())；      System.out.println(”Lame name from XML documentis”+aCustomer.getLastName())；      System.out.println(”Customer idfrom XML documentis”+aCustomer.getId())；      ∥Change the values on the customer object      aCustomer.setFirstName(“James”)；      aCustomer.setLastName(”Bond "); accustomer. setid ("007"); /out ground mapping/map from Java to XML out EventBasedmapping. /outeventbasedmappingsetoutputstream (outStream); seteventaedmapping. setoutputstream (system.out); execlute (); long te ═ system. Print ln ("Average time" ten (te-ts)/numIterations + "ms."); great face (approach e) }catch (approach e)<dp n="d15"/>    e.printStackTrace()；    }    }    }    }    ∥END execute.java

D. Details of the customer Java Bean (customer. Java) are described below. The Java Bean is a reusable component that conforms to the standard design architecture of the prior art. A Bean is a class object that may or may not be visible during execution. Javabeans provide a component architecture, a standard framework for developing components.

∥START customer.java    package com.xxx.xml2xmapping.sample.customer；    public class Customer{      private java.lang.String fieldFirstName＝new String()；      private java.lang.String fieldLastName＝new String()；      private java.lang.String fieldId＝new String()；    *Customer constructor comment.    public Customer(){      super()，    }    *Gets the FIRSTNAMEproperty (java.lang.String)value.    *@return The FIRSTNAMEproperty value.    *@see#setFirstName    public java.lang.String getFirstName(){      return fieldFirstName；    }    *Gets the id property(java.lang.String)value.    *@return The id property value.    *@see#setId    public java.lang.String getId(){      return fieldId；    }    *Gets the lastName property(java.lang.String)value.    *@return The lastName property value.    *@see#setLastName    public java.lang.String getLastName(){      retum fieldLastName；    }    *Sets the firstName property (java.lang.String)value.    *@param firstName The new value for the property.    *@see#getFirstName<dp n="d17"/>    public void setFirstName(java.lang.String firstName){      fieldfirstName＝firstName；    }    *Sets the id property(java.lang.String)value.    *@paramid The new value for the property.    *@see#getId    public void setId(java.lang.String_ID){      fieldId＝id；    }    /**    *Sets the lastName property(java.lang.String)value.    *@param lastName The new value for the property.    *@see#getLastName    public void setLastName(java.lang.String lastName){       fieldLastName＝lastName；    }    }    ∥END customer.java

As shown in example I, mapping from XML to Java is efficient because the parser 104 handles all events that start, factor, and end tags, thereby improving the tracking of events.

As a further example, consider the extension of a single customer XML file into a customer array. To generate an array of customer java beans, the following procedure is followed:

(i) creating a vector using startElement of Customers;

(ii) creating a Customer object in the startElement of each Customer; and

(iii) populating the Customer object with FirstName, LastName, and startElement, getElement, endElement events for the Customer, inserting the Customer object into a vector using the endElement of the Customer, and creating a Customers array from the vector using the endElement of the Customers and setting it in the manipulated Java object.

Parser 104 maintains a stack for recursive XML structures (i.e., XML elements of lists representing lists). Each startElement creates an object. The stack may be used to retain state as required. Once a child element is created, it can be set in its parent.

Mapping of software objects to XML

Referring to FIG. 2, the object-to-XML mapping module 114 includes the following components:

(a) a processor interface 114-1(X2XMLHandler) to manage analytic events;

(b) a mapping interface 114-2(X2XMLMapping) for performing mapping and setting an output target stream;

(c) a mapping class 114-3(X2 XMLMapppingImpl) that provides a method to map from an input Java object 116 to an output XML file 118; and

(d) the output target class 114-4(X2XMLOutputTarget) is used to implement the output XML file 118.

Table M114-1 summarizes the main functions (i.e., not all listed) of the processor interface 114-1(X2 XMLHandler). The mapping module 114 implements the interface 114-1 and registers instances in the JSP container. For substantially document-related events, such as the beginning and end of an element and the taking of an element value, the document template 112 will call back the mapping module 114.

TABLE M114-1

Function(s)	Description of the invention
		getElementValue()	The value of the element is returned. For when operating in a simple type that is not within the start and end element tags.
endElement()	An end notification of an element is received. When operating with complex types, to maintain state.
		getElementAttribute()	The specified attribute values are returned. For when in the beginningAnd ending complex type operations within the scope of the element tag.
getElementRepetitions()	For repeated elements, the number of repeats will be returned.
		isOptionalAttributePresent()	If an optional attribute is present, true is returned, otherwise false is returned. This is used in the XML document template (JSP)112 to control whether names and values for optional attributes are generated in the XML document 118. For when operating with complex types within the start and end element tags.
startElement()	A start notification of an element is received. When operating with complex types, to maintain state.

In general, a container is an instance that provides lifecycle management, security, deployment, and execution time services to components. There are many specific types of containers (web pages, JSPs, servlets, applets, etc.) that can provide services specific to a component. A Servlet container is a container that provides web services to transmit requests and responses, decode requests, and format responses. A JSP container is a container that provides the same services as a servlet container plus an engine that interprets and processes JSP pages into servlets.

The X2XMLHandler 114-1 provides a mirror image (but not the same) of the analysis events of the results produced by the analyzer 104. In effect, the structure provided by parser 104 is a mirror image of the path from X2 XML.

When the analyzer 104 is implemented using SAX, the event is received by the processor 106-2 that processes the event (i.e., in effect, the callback mechanism). In this example, the handler 106-2 is used to populate Java classes.

When the template 112 is called, the X2XMLHandler interface 114-1 will be recalled. The processor 114-1 processes the callback by retrieving the requested data and maintaining the state of the analysis.

Although the processor interface 114-1 is similar in the various functions performed by the XML-object mapping module 106, there are certain differences. Element names are generated or manually written, rather than taken from schemas with "namespace" support. Each element may have a unique element name. Thus, the startElement and endElement methods only require a name parameter.

When the XML-object mapping module 106 performs the mapping, the input source class 106-1 (i.e., the XML reader) returns the element name as a string. In the mapping classes/interfaces 106-3, 106-4, the element names are assigned unique numbers. The number is used for switching statements for processing of control elements. In the object-XML module 114, the process is optimized and the encoding assistance is improved by defining primitive names as integer constants. Thus, the callbacks of these methods use integer constants rather than strings.

The order of events in the processor interface 114-1 reflects the information order of the objects 116 themselves.

The XML document template 112 (written in JavaServer Pages technology) uses an encoding style detailed below. The JSP technology separates the user interface from the content generation, thus enabling the underlying dynamic content to be changed without altering the overall page layout. As is known in the art, JavaServer Pages is an extension of Java Servlet technology.

XML document template 112-JSP coding style paradigm

Callbacks are encoded for the start and end tags and the complex type of file 118. This allows the processor 114-1 to maintain state. In the JSP XML file template 112, the start and end tags are also directly encoded to point to the target output stream. When operating in a simple type, no encoding call-backs are needed, but the encoding start and end tags are still needed in order to point them to the target output stream.

If the complex or simple type is optional, the conditional clause in the template 112 uses ispationalelementpresent () to control whether to generate an optional element.

If the attribute is optional, ispositionalttributepresent (intelmentname) is used in the complex type, and ispositionalttributepresent (int elementName, int attributeName) is used in the simple type. If the element type is a repeated simple type, an ispositionattributpresent (int index, int elementName, int attributeName) method is used to determine whether the element type contains optional attributes.

For repeated elements, the getelementrepetition method is used to return the number of repeated elements. This is used to create a loop in the template 112 for processing each element. For simple types, template 112 should contain start and end tags and call getElementValue (int index, int elementName) to get its value. For complex types, since the state must be maintained, template 112 should call startElement (int index, int elementName) and endElement (int index, intementName) methods.

Table M114-2 summarizes the main functions (i.e., not all listed) of mapping interface 114-2(X2 XMLMaping). The mapping interface 114-2 performs the mapping function (between Java and XML) and sets up the output object stream. The mapping interface 114-2 extends the processor interface 114-1 to provide the file template 112 callback method required to generate the output XML file 118.

TABLE M114-2

Function(s)	Description of the invention
		execute()	A mapping is performed to create the output XML file 118.
setOutputStream()	The output stream is set to what the output XML file 118 will produce.

Table M114-3 summarizes the main functions (i.e., not all) of mapping class 114-3(X2 XMLMapppingImpl). The mapping class 114-3 provides a method for mapping from an input Java object 116 to an output XML file 118. As discussed above with respect to the definition of classes and interfaces, the X2 XMLMappgImpl class 114-3 is not used directly, but rather is a subclass added to the appropriate method based on the file class definitions of the mapped output XML file 118 and the input Java object 116 to be mapped.

TABLE M114-3

Function(s)	Description of the invention
		execute()	A mapping is performed to create the output XML file 118.
setOutputStream()	The output stream is set to what the output XML file 118 will produce.

Table M114-4 summarizes the main functions (i.e., not all listed) of the output target class 114-4(X2 XMLOutputTarget).

The X2XMLOutputTarget class 114-4 allows XML files 118 to be written into a byte stream or a character stream. The class 114-4 provides optimizations, for example, to allow the byte stream to be targeted to the output stream of a servlet. Thus, the XML file 118 is not buffered until written out.

TABLE M114-4

Function(s)	Description of the invention
		close()	The output stream is closed and any system resources associated with the output stream are released.
flush()	The output stream is cleared and any buffered output bytes are forced out.
		write()	Bytes are written from the particular byte array to the output stream.

In short, the X2 XMLMappImpl class 114-3 implements the X2XMLMapping interface 114-2. The X2XMLMapping interface 114-2 extends the X2XMLHandler interface 114-1. Thus, the X2 XMLMappgImpl class 114-3 implements the method defined in the X2XMLHandler interface 114-1.

Referring to FIG. 4, a method 400 is illustrated in which the general steps performed to map a software object 116 (e.g., a Java Bean) to an XML file 118 are shown:

(a) in step 402, an instance of the mapping interface 114-2 (e.g., X2XMLMapping) is obtained to implement the mapping from the input object X116 to the output XML file 118;

(b) in step 404, the output streams of the software objects 116 and the XML files 118 in the mapping interface 114-3 are set;

(c) calling mapping interface 114-2 in step 406;

(d) creating a JSP container in step 408;

(e) in step 410, mapping interface 114-2 calls a JSP container using JSP XML template 112 that creates XML file 118;

(f) in step 412, the JSP container compiles and executes the JSP XML template 112;

(g) in step 414, the compiled JSP XML template 112 begins writing the XML file 118 to the specified output stream (from step 404);

(h) in step 416, the compiled JSP XML template 112, when applicable to the element/attribute data and to the start/end tag, calls back to the mapping interface 114-2 to maintain the processing state and adds the data to the output XML file 118 (data is retrieved from the software object 116);

(i) in step 418, the compiled JSP XML template 112 optionally calls the isporationElementPresent method or the isporationAttributePresent method to decide whether certain portions of the XML document should be generated;

(j) in step 420, the JSP XML template 112 calls back the getelementrepetition method to determine how many times a loop should be made in generating certain portions of the XML document; and

(k) in step 422, the processing state is maintained by the stack; this is useful when a complex type is generated in an XML file and an array occurs, either recursively or the complex type is contained in another complex type.

The mapping from Java to XML uses XML document templates 112 encoded with similar standards as required by the parser 104 to handle (at least for complex objects) events. For example, for complex types, the start and end tags must be encoded (the original type is not needed). Example II, "JAVA-XML CUSTOMER," detailed below, generates an output CUSTOMER XML file from an input CUSTOMER iava object.

Example II

JAVA-XML CUSTOMER

The following components (details below) are part of example II:

(A) customer 2xmlmapping.java: a processor class 114-1 called by the JSP 112 to obtain values from incoming customer Java objects 116 to populate an outgoing XML file 118;

(B) customer. jsp: a JSP template 112 to generate an output XML file 118;

(C) java: including constants and hash maps. The hash mapping is used to map the tag name to an integer constant. JSP template 112 uses these integer constants; and

(D) java: the program of the mapping classes/interfaces 114-2, 114-3, is used to perform the mapping from Java to XML and (as provided in item C of example I above) from XML to Java.

A. Program for creating XML file from input Java object

(custom 2xmlmapping. java) in which some pruning is done for brevity.

∥START Customer2XMLMapping.java    package com.xxx.xml2xmapp±ng.sample.customer；    import java()；util.*；    import com.ibm.xml2xmapping.util.*；    public class Customer2XMLMapping extends    com.xxx.xml2xmapping.X2XMLMappingImpl{      private Customer fieldCustomer；    /***    *Customer2XMLMapping constructor comment.    */    public Customer2XMLMapping(){      super()；      fieldPageName＝””customer.jsp”；    }    /**    *getElementRepetitions method comment.    */    public int getElementRepetitions(int name){      switch(name){<dp n="d24"/>      }      return 0；    }    /**    *getElementValue method comment.    */    public String getElementValue(int name){      switch(name){         case CustomerSymbols.CUSTOMER_FIRSTNAME：{            return this.fieldCustomer.getfirstName()；         }         case CustomerSymbols.CUSTOMER LASTNAME：{            retum this.fieldCustomer.getLastName()；         }         case CustomerSymbols.CUSTOMER_ID：{            return this.fieldCustomer.getId()；         }      }      return“”；    }    *getElementValue method comment.    public String getElementValue(int index，int name){       switch(name){       }       retutn““；    }    *@param aCustomer    com.xxx.xml2xmapping.sample.customer.Customer    public void setCustomer(Customer aCustomer){          this.fieldCustomer＝aCustomer；    }<dp n="d25"/>    }   ∥END Customer2XMLmapping.java

Document template (customer. jsp) of module 112 in b.jsp format, where it is truncated for brevity.

∥START Customer.jsp    ＜％@page import＝”com.ibm.xml2xmapping.*“％＞    ＜％@page    import＝”com.ibm.xml2xmapping.sample.customer.CustomerSymbols”％＞    ＜％X2XMLHandler handler＝    (X2XMLHandler)request.getAttribute      (“com.ibm.xml2xmapping.X2XMLHandler”)；    handler.setWriter(out)；％＞    ＜？xml version＝”1.0”？＞    ＜customer＞    ＜FirstName＞＜％＝handler.getElementValue      (CustomerSymbols.CUSTOMER_FIRSTNANE)％＞＜/FirstName＞    ＜LastName＞＜％＝handler.getElementValue      (CustomerSymbols.CUSTOMER_LASTNAME)％＞＜/LastName＞    ＜CustId＞＜％＝handle r.getElementValue(CustomerSymbols.CUSTOMER ID)％＞＜/CustId＞    ＜/customer＞    ∥END Customer.jsp

A hash mapping and constants program used by c.customer.jsp (customersymbols.java),

where it is pruned for brevity.

∥START Customersymbols.java    package com.xxx.xml2xmapping.sample.customer；　　import java.util.HashMap；    public class CustomerSymbols{      public static final int CUSTOMER＝1；      public static finalint CUSTOMER FIRSTName＝2；      public static finalint CUSTOMER LASTNAME＝3；      public static final int CUSTOMER ID＝4；      private static CustomerSymbols fieldInstance；      private HashMap fieldName2SymbolDictionary；      private static Object anObject＝new Object()；    *CustomerInfoElementSymbols constructor comment.    private CustomerSymbols(){      super()；      this.fieldName2SymbolDictionary＝new HashMap()；      this.fieldName2SymbolDictionary.put(“customer”，                new Integer(CustomerSymbols.CUSTOMER))；      this.fieldName2SymbolDictionary.put(“FirstName”，                new Integer(CustomerSymbols.CUSTOMER_FIRSTNAEVJE))；    this.fieldName2SymbolDictionary.put(“LastName”，                new Integer(CustomerSymbols.CUSTOMER_LASTNAME))；    this.fieldName2SymbolDictionary.put(“CustId”，             new Integer(CustomerSymbols.CUSTOMER_ID))；    }    *@return int    *@param elementName java.lang.String    public static int getSymbol(String elementName){       if(CustomerSymbols.fieldInstance＝＝null){          synchronized(anObject)<dp n="d27"/>                if(CustomerSymbols.fieldInstance＝null)                   CustomerSymbols.fieldInstance＝new    CustomerSymbols()；            }      }    }    return    ((Integer)CustomerSymbols.fieldInstance.fieldName2SymbolDictionary.get(elementName)).intValue()；    }    }    ∥END Customersymbols.java

To generate an XML file for an array of customer cases discussed in example I, a rewritten customer jsp example is provided below:

for(int i＝0；    i＜handler.getElementRepetitions(CustomerSymbols.CUSTOMERS)；i++)    {    ＜％handler.startElement(i，CustomerSymbols.cCJsTOMER)；％＞    ＜customer＞    ＜FirstName＞    ＜％＝handler.getElementValue        (CustomerSymbols.CUSTOMER_FIRSTNAME)％＞＜/FirstName＞    ＜LastName＞    ＜％＝handler.getElementValue        (CustomerSymbols.CEJSTOMERLASTNAME％＞＜/LastName＞    ＜CustId＞＜％＝handler.getElementValue        (CustomerSymbols.CUSTOMER_ID)％＞＜/CustId＞    ＜/customer＞    ＜％＝handler.endElement(i，Customersymbols.CUSTOMER)；％＞    ＜％}％＞

the processor 114-1 decides the array size (i.e., how many cycles should be performed) and returns in the getElementReptivities method. When the customer jsp calls startElement with a subscript and name, the processor 114-1 sets a reference to that particular customer object in the array.

To handle recursion, processor 114-1 uses a stack. When the object recurses, processor 114-1 pushes to the startElement on the stack and pops to the endElement. The object of the operation is the object at the top of the stack.

If the object is optional, the presence of the object is determined using the isptionelement () or isptionAttribute () method. Jsp is overwritten to add a conditional statement that uses the boolean value returned by one of the ispondialxxx methods.

In summary, advantages of exemplary embodiments of the present invention include:

(a) providing a common framework for mapping from XML files to Java objects and from Java objects to XML files, wherein the framework uses a processor that masks, e.g., obtains, attributes for mapping;

(b) initializing the mapping method (XML/Java) of the present invention using existing tools (e.g., SAX parser, JSP); and

(c) interfaces and classes (in a Java environment) are provided to simplify the structure of the mapping process of the present invention, making the mapping process similar for both mapping directions.

Claims (44)

1. A computer-implemented method of converting a data structure representing a software object into structured language elements of a file, the method comprising:

(a) generating a structured language element template file;

(b) reading attributes from the software object, the attributes being associated with structured language elements of the document;

(c) using the attributes, obtaining a building block defined by the structured language element based on the association between the attributes and the structured language element; and

(d) the structured language element template file is populated with these building blocks.

2. The computer implemented method of claim 1, wherein step (c) comprises directly calling back software objects to obtain attributes representing components defining the structure and content of the file.

3. The computer-implemented method of claim 1, wherein step (c) comprises creating an object model that represents the structure and content of the file.

4. The computer-implemented method of claim 1, wherein the structured language elements represent extensible markup language (XML) constructs.

5. The element implementing method of claim 1, wherein the step (c) comprises establishing a loop in the template file for processing the repeated structured language elements.

6. A computer-implemented method of converting structured language elements of a document into a data structure representing a software object, the method comprising:

(a) reading each structured language element of the document;

(b) selecting from a set of available attributes defined by a data structure of the software object, determining attributes associated with structured language elements of the document; and

(c) properties representing the data structure of the software object are populated with structured language element values from the file.

7. The computer-implemented method of claim 6, wherein step (a) comprises generating events representing the structure and content of the file.

8. The computer implemented method of claim 6, wherein step (a) comprises calling back the handler with events representative of the structure and content of the file.

9. The computer-implemented method of claim 6, wherein step (a) comprises creating an object model that represents the structure and content of the file.

10. The computer implemented method of claim 6, wherein the structured language elements represent extensible markup language (XML) constructs, and step (a) further comprises implementing Document Type Definitions (DTDs) and XML schema standards.

11. The computer-implemented method of claim 10, further comprising maintaining a stack for recursive XML constructs.

12. A system for converting a software object (116) containing properties into a document (118) defined by structured language elements, the system comprising:

(a) a document template (112);

(b) a processor interface (114-1) that provides a representation of a structured language element of a document (118) according to a callback of a document template (112);

(c) a mapping module (114-2, 114-3) in communication with the processor interface (114-1) for converting attributes of the software object (116) into structured language elements identified by the file (118); and

(d) and (c) outputting the target class (114-4), communicating with the mapping modules (114-2, 114-3), and writing the structured language elements generated in the step (c) into a file (118).

13. The system of claim 12, wherein the mapping module includes a mapping interface (114-2) for performing the conversion of attributes to structured language elements and setting an output target stream of the document (118), and a mapping class (114-3) for providing a method used by the mapping interface (114-2).

14. The system of claim 13, wherein the output target stream is defined as a buffer.

15. The system of claim 13, wherein the output target stream is defined as a response stream of a servlet.

16. The system of claim 12, wherein the structured language elements represent extensible markup language (XML) constructs.

17. The system of claim 16, wherein the file template is created using JavaServer Pages (JSP).

18. A system for converting a document (118) containing structured language elements into a software object (110), the system comprising:

(a) an analyzer (104) to obtain events representative of characteristics of the file (108);

(b) inputting a source class (106-1) for reading a file (108);

(c) a content handler class (106-2) in communication with the input source class (106-1) for implementing a buffer for use by events acquired by the analyzer (104); and

(d) a mapping module (106-3, 106-4) in communication with the content handler class (106-2) for converting the events obtained by the parser (104) into attributes of the software object (110).

19. The system as recited in claim 18, wherein the mapping module includes a mapping interface (106) to perform event to attribute conversion and to set an output target stream of the software object (110), and a mapping class (106-3) to provide a method used by the mapping interface (106-4).

20. The system of claim 19, wherein the structured language elements represent extensible markup language (XML) constructs.

21. A method of converting a software object having properties into a document represented by structured language elements, the method comprising:

(a) providing the software object to an instance of the invoked mapping interface;

(b) compiling and executing the template using the instance of the called container; and

(c) the file is written to a particular output stream using the compiled template.

22. The method of claim 21, further comprising calling back a mapping interface to maintain processing state.

23. The method of claim 21, further comprising calling an isOptionalElementPresent method with the compiled template to determine whether to generate the selected portion of the document.

24. The method of claim 21, further comprising invoking the isproptionalattributepresent method with the compiled template to determine whether to generate the selected portion of the document.

25. The method of claim 21, further comprising maintaining processing state using a stack when generating a complex type within a file, the complex type selected from the group consisting of: array, recursive, and complex types contained within another complex type.

26. The method of claim 25, wherein the stack state is maintained by callbacks from compiled templates to mapping interfaces to indicate when the complex types begin and end.

27. The method of claim 21, further comprising invoking a getelementrepetition method to determine how many cycles a template should perform on a selected portion of a file.

28. The method of claim 21, wherein the structured language elements represent extensible markup language (XML) constructs, and the templates are created using JavaServer Pages (JSP).

29. A method of converting a document containing structured language elements into a software object, the method comprising:

(a) providing the file to the instance of the called mapping interface;

(b) registering the mapping interface as a content handler;

(c) analyzing the file using the instance of the invoked analyzer; and

(d) the software object is populated with attributes associated with structured language elements parsed from the file by the callback mapping interface.

30. The method of claim 29, wherein step (d) comprises calling back and invoking a method selected from the group consisting of: startDocument, startElement, characters, endElement, and endDocument.

31. The method of claim 30, wherein the startDocument and startElement methods executed by the mapping interface create a software object.

32. The method of claim 29, wherein the endElement method performed through the mapping interface sets the attributes in the software object.

33. The method of claim 29, wherein the structured language elements represent extensible markup language (XML) constructs.

34. A computer program product for converting a data structure representing a software object into structured language elements of a document, the computer program product comprising computer readable program code means for:

(a) generating a structured language element template file;

(b) reading attributes from the software object, the attributes being associated with structured language elements of the document;

(c) using the attributes, obtaining a building block defined by the structured language element based on the association between the attributes and the structured language element; and

(d) the structured language element template file is populated with these building blocks.

35. The computer program product of claim 34, wherein step (c) comprises directly calling back to the software object to obtain events representing components defining the structure and content of the file.

36. The computer program product of claim 34, wherein step (c) comprises creating an object model that represents the structure and content of the file.

37. The computer program product of claim 34, wherein the structured language elements represent extensible markup language (XML) constructs.

38. The computer program product of claim 34, wherein step (c) comprises creating a loop in the template file for processing repeated structured language elements.

39. A computer program product for converting structured language elements of a document into a data structure representing a software object, the computer program product comprising computer readable program code means for:

(a) reading each structured language element of the document;

(b) selecting from a set of available attributes defined by the data structure of the software object, determining attributes associated with the structured language elements of the document; and

(c) properties of the data structure representing the software object are populated with structured language element values from the file.

40. The computer program product of claim 39, wherein step (a) comprises generating events representative of the structure and content of the file.

41. The computer program product of claim 39, wherein step (a) comprises calling back the processor with events representative of the structure and content of the file.

42. The computer program product of claim 39, wherein step (a) comprises creating an object model that represents the structure and content of the file.

43. The computer program product of claim 39, wherein the structured language elements represent extensible markup language (XML) constructs, and step (a) further comprises enforcing Document Type Definition (DTD) and XML schema standards.

44. The computer program product of claim 43, further comprising maintaining a stack for recursive XML constructs.