RU2287181C2 - System and method for mutual transformation of program objects and documents based on elements of structured language - Google Patents

Abstract

FIELD: computer science, technology for mutual transformation of document (for example, XML document) and program object (for example, Java language object).

SUBSTANCE: in such structure, interpreter is used, masking method for producing transformation properties. Due to that, transformation code is generated, having general type for transformation in both directions. Transformer transforms XML document to program object by means of analyzer 104. To execute reverse transformation (from Java language to XML) it is required, that elements of XML document are positioned in certain order to provide for validity of produced XML document 118. For this purpose, in accordance to invention, template XML document is generated using, for example, JSP technology. Template, created using JSP, allows recording tags of documents in JSP with possible reverse call for values of elements and attributes. Content may be sent to buffer or directly to the output stream of servlet.

EFFECT: it is possible to efficiently realize creation of structure for such transformation by means of standard tools.

4 dwg, 8 tbl, 2 ex

Description

Technical field

The present invention relates to the mutual conversion or display of program objects and documents based on elements of a structured language, in particular to the mutual conversion of various program objects, such as Java ™ objects and XML documents (extensible markup language).

BACKGROUND OF THE INVENTION

XML is an abridged version of the standard generalized markup language (SGML), which is designed specifically for creating WWW pages. It allows developers to create their own custom tags that provide functionality not available in the HTML language.

For example, the XML language supports links that point to many documents, unlike the HTML language, in which each link can point to only one address.

Since the XML language is a form of self-description of data (which are also referred to in this application as elements of a structured language), it is used to encode data models that are powerful in content. Thus, the XML language can be used as a means of exchanging data between heterogeneous systems. In XML, the data of many different systems can be presented or published: existing programs in the COBOL programming language, databases, programs in the C ++ programming language and similar programs. This often leads to an economic problem, which is how to display the information contained in an XML document in other data formats and vice versa. For example, after exchanging information between organizations by transferring an XML document, it may be necessary to convert such information into a Java language object that can be used to create a database or implement a transaction request.

US Pat. No. 6,125,391, issued September 26, 2000 to Meltzer et al., Describes an example of a tool for converting data from XML to Java. For such a conversion, an XML document is analyzed in the said patent and events are detected. In particular, one analyzer parses an XML document and creates a tree view in memory that the query can be addressed to, and another analyzer parses an XML document and detects events containing information about the document (for example, the document start event, event element start with element name, element content, element end event, document end event, etc.).

To convert from Java to XML, Meltzer et al. Describe the generation of code that has accessors for each element. An element accessor has a cycle that repeats periodically for each character. The loop contains a switch statement that performs a specific action depending on what the character is. The goal of this action is to create a string buffer containing a fragment of an XML document element. The solution according to the patent of Meltzer and others does not provide the creation of an auxiliary infrastructure for working with code that converts from Java to XML. The code used in the patent solution of Meltzer'a et al. Is fully generated and inconvenient for user editing.

Therefore, there is a need to create a structure for the mutual transformation of program objects and documents based on elements of a structured language (for example, XML), which can be effectively implemented using standard tools.

Summary of the invention

The above disadvantages of the prior art are absent in the method and system of the present invention, which proposed a single integrated environment for the mutual conversion of documents (for example, an XML document) and program objects (for example, a Java language object). This integrated environment uses a handler that masks the way to obtain the property for conversion. As a result, a conversion code is generated having a general view for conversion in both directions. Mutual conversion of XML elements and properties of a Java object occurs in the converter. The converter converts an XML document into a program object using an analyzer (such as a DOM standard analyzer (document object model) or a simple application programming interface (API) for XML (SAX standard)).

To perform the conversion in the other direction (from Java to XML), it is necessary that the elements of an XML document are arranged in a certain order in order to ensure the authenticity of the received XML document. To ensure this validity, in an exemplary embodiment of the present invention, an XML template document is created using, for example, JavaServer Pages ™ (JSP). Templates created on the basis of JSP allow you to write document tags in JSP with the ability to call back to get the values of elements and attributes. JSP has editing support tools that allow you to efficiently create templates. In addition, the content (s) can be sent to the buffer or directly to the servlet response stream.

Accordingly, an object of the present invention is a computer-implemented method for converting a data structure representing a program object into elements of a structured language of a document. The method proposed in the invention consists in (a) generating a template for the specified document, (b) reading the properties of the program object that are interconnected with the elements of the structured language of the document, (c) using the read properties, they are formed by elements of the structured language of the design based on the relationship between by these properties and elements of a structured language and by means of a conversion code that provides both the conversion of a program object into a document based on string elements turirovannogo language and converting in reverse direction, and (g) filling the resulting construct a document template.

When implementing the above method in step (c), a direct callback of the program object can be carried out to obtain properties that display structures that determine the structure and content of the document. In addition, at step (c), an object model can be created that displays the structure and content of the document, and for processing repeating elements of a structured language at step (c), a loop can be created in the document template. The elements of a structured language are preferably XML (Extensible Markup Language) constructs.

The object of the present invention is also a system for converting a program object containing properties into a document defined by elements of a structured language, containing a computer having a processor connected via a system bus to a memory in which (a) a document template is stored, (b) a processor interface that provides the display of elements of a structured language of a document based on callbacks performed by a document template, (c) a conversion module associated with an interface-processor, etc. transforming the properties of program objects into elements of a structured language recognized by a document, and (d) the class of target output data associated with the conversion module and used to write elements of the structured language generated by the conversion module into a document.

In the proposed system, the conversion module may contain a conversion interface that converts the properties of a program object into elements of a structured language and defines the target output stream of the document, as well as a conversion class that provides the methods used by the conversion interface. In this case, the output target stream can be defined as a buffer or servlet response stream.

Another object of the invention is a system for converting a document containing elements of a structured language into a program object containing a computer having a processor connected via a system bus to a memory that stores (a) an analyzer for detecting events that display features of the document, (b) the class of the input data source for reading the document, (c) the class of the content handler associated with the class of the input data source and implementing the buffer for events detected by the analyzer, and (d) the module reobrazovaniya associated with the data handler class content and transformative events detected by the analyzer to the properties of the program object.

In this system, the conversion module may have a conversion interface that converts document events into object properties and defines the output target stream of the program object, and a class that provides the methods used by the conversion interface.

Finally, an object of the present invention is a method for converting a program object having properties into a document represented by elements of a structured language interconnected with properties of a program object, the method being implemented in a computer in whose memory the conversion interface and the container are stored. The method proposed in the invention consists in (a) activating the conversion interface and transferring the program object to the instance of the activated conversion interface, (b) activating the container and using the instance of the activated container, compile and execute the document template, (c) write the document at the specified output stream using a compiled document template.

To maintain the processing state, the proposed method may include a callback to the conversion interface. Determining whether to generate selected parts of a document through a compiled template can be done by calling the isOptionalElementPresent or isOptionalAttributePresent methods.

When generating complex types of information objects inside a document that are selected from the group consisting of an array of data, recursion, and a complex type that is contained within another complex type, the processing state can be maintained using the stack. In this case, the state of the stack is maintained by performing callbacks to the transform interface from the compiled template to indicate the beginning and end of complex types.

Determining the number of cycles performed by the template on selected parts of the document can be done by calling the getElementRepetitions method.

In all embodiments of the invention, the elements of a structured language can be XML language constructs (extensible markup language). In this case, JavaServer Pages (JSP) technology can be used to create the master document.

The methods of the invention can be implemented in a computer program product for converting a data structure representing a program object into elements of a structured document language or for converting elements of a structured document language into a data structure representing a program object.

Other features and features of the present invention are contained in the following description of specific embodiments with reference to the attached drawings.

Brief Description of the Drawings

Additional features and advantages of the present invention are disclosed in the detailed description with reference to the attached drawings, in which:

figure 1 shows a block diagram of a computing system that can be used to implement the method and device for implementing the invention,

figure 2 is a block diagram illustrating the structure of an integrated environment for converting XML objects to Java and vice versa,

figure 3 is a flowchart illustrating a method of converting an XML document into a software object using the integrated environment shown in figure 2,

figure 4 is a flowchart illustrating a method of converting a program object into a document in XML using the integrated environment shown in figure 2.

Detailed Description of Embodiments of the Present Invention

Figure 1 and its corresponding description shows an example of an applicable computing environment in which the invention may be implemented. Despite the fact that the invention is described in the general context of computer-executable instructions of a computer program installed on a personal computer, it can also be implemented in combination with other software modules.

In general, program modules contain routines, programs, components, data structures, and similar programs that perform specific tasks or implement specific abstract data types. In addition, the present invention can also be implemented using computer systems having other configurations, including portable devices, multiprocessor systems, microprocessor or programmable consumer electronics, mini-computers, mainframes, and the like. The invention can also be implemented in distributed computing environments in which tasks are performed by remote processors connected by a data network.

Software modules in a distributed computing environment can reside in both local and remote memory storage devices.

As shown in FIG. 1, an exemplary system 10 includes a conventional personal computer 20 having a processor 22, a system memory 24, and a system bus 26 linking various components of the system, including the system memory 24 to the processor 22. The system bus 26 has several bus structures types, including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of common bus architectures (e.g. PCI (local bus for connecting peripheral devices), VESA (Video Electronics Standards Association tronics), ISA (industry standard architecture), EISA (advanced industry standard bus architecture), etc.).

System memory 24 has read only memory (ROM) 28 and random access memory (RAM) 30. The ROM 28 stores the basic input / output system (BIOS) 32, which contains the main routines that facilitate the exchange of information between elements inside the computer 20, for example during startup. The computer 20 also has a drive 34 on hard magnetic disks — a hard disk drive, a drive 36 on floppy magnetic disks — a hard disk drive (for reading and writing to a removable disk 38) and a storage device (memory) 40 on compact disks (for reading CDs 42 or reading or writing to other optical storage media). The storage devices 34, 36 and 40 are connected to the system bus 26 via interfaces 44, 46 and 48, respectively.

The drives 34, 36 and 40 and the corresponding computer-readable media (38, 42) provide non-volatile storage of data, data structures and instructions for the computer 20. The data carriers shown in figure 1 are only examples, and specialists in this field of technology know the use of other types of media readable by a computer (for example, magnetic cassettes, flash memory cards, digital video disks, etc.).

A number of program modules can be stored in drives 34, 36, and 40 and RAM 30, including the operating system 50, one or more application programs 52, other program modules 54, and program data 56. The user can enter commands and information into computer 20 using the keyboard 58 and input devices 60 (e.g., mouse, microphone, joystick, gaming touch pad, satellite dish, scanner, etc.). Such devices (58 and 60) are connected to the processor 22 via an interface 62 ports (for example, serial port, parallel port, game port, universal serial bus (USB), etc.), which is connected to bus 26. With bus 26 via interface 66 (for example, a video adapter), a monitor 64 or other type of display device is also connected.

The computer 20 may operate in a network environment in which it is logically connected to one or more remote computers, such as a remote computer 68. The remote computer 68 may be a server, router, peer device or other conventional network node and, as a rule, has many or all the elements described in relation to the computer 20, however, for simplicity, only the storage device 70 is shown. The logical connections shown in Fig. 1 include a local area network 72 and a global network 74. Such a network environment is usually used in institutions, corporate All networks, intranets, and the Internet.

When used in a local network environment, the computer 20 is connected to the local network 72 via a network interface or adapter 76. When used in a global network environment, the computer 20 typically has a modem 78 or other means for maintaining communication over a global network 74, such as the Internet. The modem 54, which may be internal or external, is connected to the bus 26 via an interface 62 ports. In a networked environment, program modules shown with respect to the computer 20, or parts thereof, can be stored in a remote storage device 70.

The method of the present invention is described by the example of converting, or displaying, XML documents into Java objects, as well as Java objects into XML documents. Support for other data formats is also possible. For example, many existing business applications are written in the COBOL, C, and PL / 1 languages. Such applications consist of programs stored in enterprise information systems, such as CICS ™ (general-purpose software for online transaction processing) or IMS ™ (information management system). The COBOL language is used to input and output program structures in the COBOL language. You need to convert from XML to COBOL and from COBOL to XML. The present invention can be applied to such transformations, in this case, in the case of conversion from XML to object X, the conversion handler (described later) fills the COBOL language structure with data from an XML document, and in case of conversion of object X to XML, the conversion processor (described below ) extracts data from the COBOL language structure and uses a template to populate an XML document.

The following high-level process is used in the conversion methods of the present invention: (a) the lexical analyzer groups the characters into words or tokens recognized by a particular system (conditional markup); (b) the parser analyzes groups of tokens in order to recognize valid language constructs; and (c) the code generator uses a set of valid language constructs and generates executable codes. Steps (a) - (c) can be performed in combined form. For example, in the case of converting an XML document to a Java object, each character of the XML document is analyzed in order to recognize valid XML tokens, such as start tags (opening), properties, end tags (closing) and sections (sections) " CDATA. " Then the tokens must be verified to determine if they form valid XML constructs. Verification at the lowest level determines whether all tagging has matching start and end tags, and whether the properties in the start tag are structured properly. If there is a description of the document in the DTD format (definition of the type of document) or an XML schema, it is possible to ensure that the constructions in the XML language detected during the analysis are valid from the point of view of the DTD or XML schema formats, as well as being correctly formulated XML language. Finally, the data contained in the XML document is used to perform some useful action (that is, converting it into a Java language object).

Some of the above problems can be at least partially solved with the help of easily accessible XML document parsers. XML document parsers perform lexical and parsing. Examples of analysis standards are the SAX standard and the DOM standard implemented in the API (SAX is a simple application programming interface (API) for XML; DOM is an object model of documents).

SAX is an event-based standard. XML document parsers using the SAX standard generate events corresponding to the various elements that were found in the parsed XML document. The DOM standard is a simple application programming interface based on object modeling. XML document parsers based on the DOM standard create a group object model in memory that displays the contents of an XML document. Upon completion of the analysis by the XML document analyzer, the tree structure of the DOM objects containing information about the structure and content of the XML document is stored in memory.

2 schematically shows an integrated environment 100 according to one embodiment of the present invention. The integrated environment 100 is shown as an example of an integrated component 102, such as a servlet, that can be implemented in the system 10 shown in FIG. 1. Integral component 102 includes an analyzer 104 implemented using, for example, DOM or SAX interfaces, which interacts with module 106 for converting an XML document into a program object. For clarity, when describing embodiments of the present invention, an analyzer with a SAX interface is used as an example of analyzer 104.

Module 106 converting an XML document into a program object receives an input document 108 in XML and generates an output object 110 in Java. The integrated component 102 also has an XML template document module 112 (for example, based on JSP technology - JavaServer Pages ™), which is associated with a module 114 for converting a program object into an XML document. Module 114 converting the program object into an XML document receives an input object 116 in the Java language and generates an output document 118 in the XML language.

Convert an XML document to a program object

As shown in FIG. 2, the module 106 for converting an XML document into a program object has the following components:

(a) class 106-1 of the input data source (XML2xInputSource) for implementing the input document 108 in XML;

(b) Buffered Content Handler class 106-2 (XML2xBufferedContentHandler) for implementing the SAX standard event buffer generated by the analyzer 104;

(c) a conversion interface 106-4 (XML2xMapping) for transforming and defining input and output target streams; and

(d) a conversion class 106-3 (XML2xMappingImpl) that provides methods for converting an input document 108 in XML to an output object 110 in Java.

The various interfaces and classes are described in detail below. For the Java language, the terms “class” and “interface” have special meanings. A Java language class (abstract, internal, or final) is a collection of data components and methods that characterize a particular object, and the Java interface is used to give certain functionality to the class that implements them (i.e., the interfaces define the functions of the classes). Interfaces also serve to create constant values used by classes that implement the interface. Interfaces contain constant parameters and descriptions of methods, however, the implementation of methods depends on the classes that implement the interface. One class can implement any number of interfaces.

Table M106-1 lists the main functions (i.e., not an exhaustive list of functions) of class 106-1 of the input data source (XML2xInputSource).

The XML2xInputSource class is used to provide the ability to read an XML document from a byte stream, character stream, or XML2xBufferedContentHandler 106-2.

Table M106-1 Function Description available () Returns the number of bytes that can be read from the input stream without blocking getBufferedHandler () Getting a buffered SAX event handler getByteStream () Byte stream return getCharacterStream () Returning a character stream reader read () Read the next byte of data from this input stream skip () Bytes skipped from this input stream

Table M106-2 lists the main functions (i.e., not an exhaustive list of functions) of class 106-2 of the buffered content handler (XML2xBufferedContentHandler). The handler class M106-2 also includes a content handler for buffering SAX events coming from analyzer 104. This allows events to be played back. An example of a situation in which this function is useful is when different transformation handlers are used for different parts of an XML document. An example implementation is a simplified object access protocol (SOAP).

Table M106-2 Function Description Characters (char [] ch, int start, int length); Commentary on the method in which ch are the characters of an XML document 108; start - the initial position in the array; length - the number of characters to read from the array parse () Buffer SAX Events Execution

SOAP is a simplified protocol for exchanging information in a decentralized, distributed environment. It is an XML-based protocol and consists of three parts: (1) an envelope that forms an environment for describing the contents of the message and how it is processed; (2) a set of coding rules for representing instances associated with a particular application of data types; and (3) conventions for displaying remote calls and answering procedure calls. A SOAP message is an XML document that consists of a mandatory SOAP envelope, an optional SOAP header, and a mandatory SOAP body. In this case, different conversion handlers can be used to process the envelope and body.

Table M106-3 lists the main functions (i.e., non-exhaustive) of the 106-4 transformation interface (XML2xMapping). The XML2xMapping interface performs the conversion and defines the configuration of the input stream.

Table M106-3 Function Description Execute () Performing a conversion to create an XML input document format 108. A complete example of the execute () function is given below. SetInputStream () Definition of input stream, i.e. the source of the input document 108 in XML, which is subject to conversion.

Table M106-4 lists the main functions (i.e., a non-exhaustive list of functions) of the transformation class 106-3 (XML2xMappingImpl). As indicated above in the description of the definitions of the concepts of “class” and “interface”, the XML2xMappingImpl class is not used directly, but subclasses are allocated in it with the addition of content to the corresponding methods depending on the definitions of the document type for the input document 108 in XML, converted from the output object 110 in the Java language to which the conversion is performed.

Table M106-4 Function Description EndElement () Receive notification of the end of an item. The analyzer 104 activates this method at the end of each element of the input document 108 in XML. For each endElement () event, there is a corresponding startElement () event, even if the element is empty. Execute () Performing a conversion to create an XML input document format 108. SetDocumentLocator () Getting an object to detect the event source of a SAX standard document. SetInputStream () Definition of input stream. The definition of the source of the input document 108 in XML, which is subject to conversion. StartElement () Receive notification of the start of an item. The analyzer 104 calls this method at the beginning of each element of the input document 108 in XML. For each startElement () event, there is a corresponding endElement () event, even if the element is empty. All information about the content of the element is transmitted until the end event of the corresponding element (endElement ()).

FIG. 3 shows a method 300 for converting an XML document 108 into a software object 110 (eg, a Java Bean), in which:

(a) receive an instance of the conversion interface 106-4 (XML2xMapping) for implementing, in step 302, the conversion of the XML document to an object X;

(b) in step 304, the conversion interface 106-4 is activated, and in step 306, an XML input document 108 is input;

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

(d) at step 312, the parser 104 is activated with respect to the XML document 108 (i.e., the parser starts parsing the document);

(e) in step 314, in step (d), the callback interface arrives at the conversion interface 106-4, calling various methods (e.g., startDocument (start of the document), startElement (start of the element), characters, endElement (end of the element), endDocument ( end of document) etc.);

(e) in step 316, when the startDocument and / or startElement methods are executed, the transform interface 106-4 creates a program object 110; and

(g) in step 318, when the endElement method is executed, the transform interface 106-4 places the element in the program object 110.

The SAX API described above has many well-known specifications. An object of the present invention is to provide a class that implements a content handler interface, which is an interface built on a callback mechanism and used by XML document parsers to notify a program of SAX events as they are detected in an XML document. This interface is used with the buffered content handler class 106-2 (XML2xBufferedContentHandler) and the input source class 106-1 (XML2xInputSource). In relation to the content handler interface, the SAX API can also be implemented as an interface of the standard handler class (DefaultHandler). Example I “Converting an XML Document to a JAVA User Object” below describes in detail the use of a standard handler to generate a custom Java Bean from a user XML document.

Example 1

Convert an XML document to a custom JAVA object

In example 1, the following components were used (described below):

(A) customer.xml: sample input document 108 in XML;

(B) XML2CustomerMapping.java: handler class 106-2 to which parser 104 routes callbacks. Contains commands for constructing a custom object and determining its parameters;

(B) executive.java: class 106-3 / conversion interface program 106-4 used to convert from XML to Java and from Java to XML (Example II below);

(D) customer.java: output of a user object 110 in the Java Bean language; and

(E) CustomerSymbols.java: contains integer constants and a hash scheme. The hash scheme is used to convert tag names to integer constants used in XML2CustomerMapping.java.

A. The following is an XML input document (customer.xml).

// START customer.xml

<? xml version = "1.O"?>

<customer>

<FirstName> Jane </FirstName>

<LastName> Doe </LastName>

<CustId> xyz.123 </CustId>

</customer>

// END customer.xml

B. The program (XML2CustomerMapping.java), which is used to construct a user-defined object and set its parameters (i.e., a handler to which the event analyzer sends callbacks), is given below for brevity.

// START XML2CustomerMapping.java

public class XML2CustomerMapping extends

corn.xxx.xml2xmapping.XML2xMappingImpl {

private StringBuffer fieldCurrentQualifiedElementName =

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.xrnl.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.xrnl.sax.SAXException {

String symbolName;

if (namespaceURI.equals ("")) symbolName = rawName;

else symbolName = namespaceURI + "_" + localName;

this.fieldCurrentElementSymbol = 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 () {

return this.fieldCustomer;

}

* startElement method comment.

public void startElement (String namespaceURI, String localName, String rawName, org.xml.sax.Attributes atts) throws org.xrnl.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 CustomerSymbols.CUSTOMER: {

this.fieldCustomer = new Customer ();

break;

}

}

}

}

// END XML2CustomerMapping.java

C. For brevity, the following is a program (execute.java) for converting from XML to Java (and from Java to XML, as described in more detail below in Example II) for brevity.

// START execute.java

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 numlterations = 1;

XML2CustomerMapping inMapping = new XML2CustomerMapping ();

Customer2XMLMapping outEventBasedMapping = new

Customer2XMLMapping ();

// Create the XML2 Customer handler and the Customer2XML handler XML2CustomerMapping in Mapping = new XML2CustomerMapping ();

Customer2XMLMapping outEventBasedMapping = new

Customer2XMLMapping ();

// read in the customer.xml file

ByteArrayInputStream inStream = null;

try {

FileInputStream 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 ();

}

ByteArrayOutputStream outStream = new ByteArrayOutputStream ();

try {

long ts = System.currentTimeMillis ();

for (int i = 0; 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 ("Last name from XML document is

"+ aCustomer.getLastName ());

System, out. println ("Customer id from XML document is" + aCustomer.getId ());

// Change the values on the customer object

aCustomer.setFirstName ("James");

aCustomer.setLastName ("Bond");

aCustomer.setId ("007");

// outbound mapping

// map from Java to XML

outEventBasedMapping.setCustomer (aCustomer);

// outEventBasedMapping.setOutputStream (outStream);

outEventBasedMapping.setOutputStream (System.out);

outEventBasedMapping.execute ();

}

long te = System.currentTimeMillis ();

System.out.println ("Average time" + (te-ts) / numlterations + "ms.");

} catch (Exception e) {

e.printStackTrace ();

}

}

}

// END execute.java

D. The Java Bean user program (customer.java) is described below. The Java Bean is a reusable component attached to the standard structure of the prior art. A bean is a class object, visible or invisible at run time.

// 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 firstName property (java.lang.String) value.

* @return The firstName property 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 () {

return fieldLastName;

}

* Sets the firstName property (Java.lang.String) value.

* @param firstName The new value for the property.

* @see #getFirstName

public void setFirstName (java.lang.String firstName) {

fieldFirstName = firstName;

}

* Sets the id property (Java.lang.String) value.

* @param id 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 follows from Example I, converting an XML document to a Java object is effective because the parser 104 handles events for all start tags, element tags, and end tags, thereby improving event tracking.

In another example, the case of distributing a single-user XML document to an array of users is considered. To generate an array of custom Java beans programs, follow these steps:

(i) use startElement for users to create a vector;

(ii) create a user object in startElement for each user; and

(iii) use the startElement, getElement, endElement events for FirstName, LastName and CustID to populate the user object, endElement for the user to enter the user object into the vector, and endElement for users to create the user array based on the vector and enter it into the corresponding Java object.

Analyzer 104 maintains a stack for recursive structures of the XML language (i.e., XML language elements displaying a list of lists). An object is created for each startElement. The stack can be used to maintain the required state. After creating a child element, it can be inserted into the corresponding parent object.

Convert a program object to an XML document;

As shown in figure 2, the module 114 converting a program object into an XML document has the following components:

(a) handler interface 114-1 (X2XMLHandler) for managing event analysis;

(b) the conversion interface 114-2 (X2XMLMapping) for performing the conversion and setting the output parameters of the target stream;

(c) a conversion class 114-3 (X2XMLMappingImpl) providing methods for converting an input object 116 in Java to an output document 118 in XML; and

(d) the output target class 114-4 (X2XMLOutputTarget) to implement the output document 118 in XML.

Table M114-1 lists the main functions (i.e., not an exhaustive list of functions) of the handler interface 114-1 (X2XMLHandler). Conversion module 114 implements the functions of interface 114-1 and registers the instance using the JSP container. The template document 112 refers to the conversion module to call back the main document-related events, such as the start and end of the elements, and obtain the values of the elements.

Table M114-1 Function Description GetElementValue () Returns the value of an item. It is used when working with simple types that are not limited to the start and end tags of an element. EndElement () Receive notification of the end of an item. It is used to maintain state when working with a complex type. GetElementAttribute () Returns the set attribute value. It is used when working with a complex type, limited by the start and end tags of the element. GetElementRepetitions () Used for repeating element, returns the number of repetitions. IsOptionalAtributePresent () Confirmation of truth in the presence of an optional attribute, otherwise confirms falsehood. Used in an XML document template (JSP) 112 to control the generation of the name and value of an optional attribute in an XML document 118. It is used when working with a complex type, limited by the start and end tags of the element. StartElement () Receive notification of the start of an item. Used to maintain state when working with complex types.

In general, a container is an entity that provides lifecycle management, security, deployment, and operational maintenance of components. There are many types of containers (Web, JSP, servlet, applet, etc.) that provide component-dependent services. A servlet container is a container that provides network services for sending requests and responses, decoding requests, and format requests. A JSP container is a container that provides services similar to those of a servlet and a machine that interprets and processes JSP pages in a servlet.

The X2XMLHandler 114-1 handler interface creates a mirror (but not identical) representation of the events analyzed by the analyzer 104. In essence, the structure created by the analyzer 104 is mirrored on the way from X2XML.

If the analyzer 104 is implemented using the SAX interface, events are sent to a handler 106-2 (i.e., essentially a callback mechanism) that processes them. In this example, handler 106-2 is used to populate the Java class.

After invoking template 112, it makes a callback addressed to the X2XMLHandler 114-1 handler interface. The X2XMLHandler 114-1 handler interface handles callback processing, receiving the requested data and maintaining the analysis state.

Despite the fact that the handler interface 114-1 is similar to the module 106 for converting an XML document into a program object in terms of its functions, there are certain differences between them. The element name is generated or encoded manually, and is not taken from a schema that supports a namespace. An item name may be unique for each item. Thus, to execute the startElement and endElement methods, only the name parameter is needed.

When module 106 converts an XML document into a program object, class 106-1 of an input data source (i.e., XMLReader) returns the element name as a string. In class 106-3 / conversion interface 106-4, the element name is combined with a unique number. This number is used by the selection operator to control the processing of elements. In the module 114 for converting a program object into an XML document, processing is optimized and coding support is improved, for which the element name is described as an integer constant. Thus, when calling these methods back, integer constants are used instead of strings.

The sequence of events in the processor interface 114-1 mirrors the sequence of information in the object 116 itself.

An XML document template (written using JavaServer Pages technology) uses the coding style described below. JSP technology makes it possible to separate the user interface from the generation of content, which allows you to completely change the layout of the page without changing the underlying dynamic information content. JavaServer Pages technology is an advanced version of Java Servlet technology, well known to those skilled in the art.

An example of the coding style of an XML document document 112 recorded using JSP technology.

Callbacks are encoded with respect to the start and end tags of document 118 and complex types. This allows handler 114-1 to maintain state. The start and end tags of the XML document template 112 recorded using JSP technology are also encoded directly to direct them to the target output stream. When working with simple types, callback encoding is not required, but the start and end tags must be encoded to direct them to the target output stream.

If an element of a complex or simple type is optional, the conditional expression inside template 112 uses the isOptionalElementPresent () function that controls the generation of the optional element.

If the attribute is optional, the isOptionalAttributePresent (int attributeName) method is used for a complex type, and the isOptionalAttributePresent (int elementName, int attributeName) method is used for a simple type. If the element is of a repeating simple type, it is determined whether it contains an optional attribute using the isOptionalAttributePresent (int index, int elementName, int attributeName) method for this.

For repeating elements, use the getElementRepetitions method, which returns the number of repeating elements. This is done to create a loop in template 112 to process each element. For simple types, template 112 must contain start and end tags and call the getElementValue (int index, int elementName) method to get the value of the element. Since complex types must be stateful, pattern 112 must call the startElement (int index, int elementName) and endElement (int index, int elementName) methods.

Table 114-2 lists the main functions (i.e., not an exhaustive list of functions) of the conversion interface 114-2 (X2XMLMapping). The conversion interface 114-2 performs the conversion function (of a Java object into an XML document) and sets the target output stream. The conversion interface 114-2 extends the functions of the handler interface 114-1, which provides the callback methods for the template 112 necessary to generate XML output 118.

Table M114-2 Function Description Execute () The implementation of the conversion, which creates the output document 118 in XML. setOutputStream () The definition of the output stream into which the output XML document 118 will be generated.

Table 114-3 lists the main functions (i.e., not an exhaustive list of functions) of conversion class 114-3 (X2XMLMappingImpl). Conversion class 114-3 provides methods for converting an input object 116 in Java to an output document 118 in XML. As described above, when describing class and interface definitions, X2XMLMappingImpl class 114-3 is not used directly, but subclasses are allocated in it using content added to the appropriate methods depending on the definitions of the type of XML output document 118, the conversion to which is performed, and an input object 116 in the Java language, the conversion from which is carried out.

Table M114-3 Function Description Execute () Implementation of the conversion to create an output document 118 in the language XML SetOutputStream () The definition of the output stream into which the output XML document 118 will be generated.

Table M114-4 lists the main functions (i.e., a non-exhaustive list of functions) of the output target class 114-4 (X2XMLOutput Target).

The X2XMLOutput Target class 114-4 allows you to write an XML document 118 into a stream of bytes or characters. Class 114-4 provides optimizations, in particular that allow the byte stream to be positioned in the servlet output stream. Thus, the XML document 118 is not buffered before the check read.

Table M114-4 Function Description Close () Closing the output stream and freeing up all system resources associated with the stream. Flush () Flushing the output stream and reading out all buffered output bytes. Write () Writing bytes from a given byte array to the output stream.

Thus, the X2XMLMappingImpl class 114-3 implements the X2XMLMapping functions of the 114-2 interface. X2XMLMapping interface 114-2 extends the functions of X2XMLHandler interface 114-1. Thus, the X2XMLMappingImpl class 114-3 implements the functions embedded in the X2XMLHandler interface 114-1.

FIG. 4 illustrates a method 400 for converting a program object 116 (eg, Java Bean) into an XML document 118, the implementation of which:

(a) in step 402, an instance of a conversion interface 114-2 is obtained (e.g., X2XMLMapping) for converting from an input object X 116 to an output document 118 in XML;

(b) in step 404, a program object 116 and an output stream for an XML document 118 are defined in the conversion interface 114-3;

(c) in step 406, the conversion interface 114-2 is activated;

(d) in step 408, a JSP container is created;

(e) in step 410, the conversion interface 114-2 activates the JSP container using an XML document template 112 recorded using JSP technology (JSP-XML template) to create an XML document 118;

(e) in step 412, the JSP container compiles and implements the XML document template 112 recorded using the JSP technology (JSP-XML template);

(g) in step 414, the compiled XML document template 112 recorded using the JSP technology (JSP-XML template) starts writing the XML document 118 to the output stream (in step 404);

(h) in step 416, if applicable to attribute element / data tags and start / end tags, the compiled XML document template 112, written using JSP technology (JSP-XML template), calls the conversion interface 114- 2 in order to maintain a state of processing and inputting data into an XML output document 118 (data is extracted from program object 116);

(i) in step 418, a compiled XML document template 112 written using JSP technology (JSP-XML template) can optionally call the isOptionalElementPresent method or isOptionalAtributePresent method to determine if some parts of the XML document need to be generated;

(k) in step 420, an XML document document 112 recorded using JSP technology (JSP-XML template) calls the getElementRepetitions method to determine the number of cycles when generating certain parts of an XML document; and

(k) in step 422, the processing state is maintained using the stack; this is effective when generating complex types inside an XML document in which an array is formed, recursion occurs, or one complex type contains another complex type.

When transforming a Java object into an XML document, an XML template document 112 is used, which is encoded using similar standards defined by the analyzer 104 that processes events (at least for complex objects). For example, for complex types, it is necessary to encode start and end tags (which is not required for elements of simple types). Example II below, “Converting a JAVA User Object to an XML Document”, describes in detail the generation of an XML output document from an input Java user object.

Example II

Convert a custom JAVA object to an XML document

In example II, the following components were used (described below):

(A) Customer2XMLMapping.java: handler class 114-1 that the JSP template 112 calls to retrieve values from the input user object 116 of the Java language and populate the output document 118 in XML;

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

(B) customerSymbols.java: contains constants and a hash scheme. The hash scheme is used to convert tag names to integer constants. JSP pattern 112 uses integer constants; and

(D) execute.java: a class 114-2 / conversion interface program 114-3 program used to convert from Java to XML and from XML to Java (similar to step B of Example I above).

A. Below, with some abbreviations, for brevity, the program (Customer2XMLMapping.java) is used to create an XML document from an input object of the Java language.

// START Customer2XMLMapping.java

package corn.xxx.xml2xmapping.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) {

} return 0;

}

/ **

* getElementValue method comment.

* /

public String getElementValue (int name) {

switch (name) {

case CustomerSymbols.CUSTOMER_FIRSTNAME: {

return this.fieldCustomer.getFirstName ();

}

case CustomerSymbols.CUSTOMER_LASTNAME: {

return this.fieldCustomer.getLastName ();

} case CustomerSymbols.CUSTOMER_ID: {

return this.fieldCustomer.getId ();

}

}

return "";

}

* getElementValue method comment.

public String getElementValue (int index, int name) {

switch (name) {

}

return "";

}

* @param aCustomer

corn.xxx.xml2xmapping.sample.customer.Customer

public void setCustomer (Customer aCustomer) {

this.fieldCustomer = aCustomer;

}

}

// END Customer2XMLmapping.java

B. Below, for brevity, a template document (Customer.jsp) used in JSP technology for module 112 is described below.

// 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_FI RSTNAME)%> </FirstName>

<LastName> <% = handler.getElementValue (CustomerSymbols.CUSTOMER_LA STNAME)%> </LastName>

<CustId><%=handler.getElementValue(CustomerSymbols.CUSTOMER_ID)%> </CustId>

</customer>

// END Customer.jsp

C. Below, for brevity, the program (Customersymbols.java) of the hash schemes and constants used in the customer.jsp template document is given below.

// START Customersymbols.java

package corn.xxx.xml2xmapping.sample.customer;

import java.util.HashMap;

public class CustomerSymbols {

public static final int CUSTOMER = 1;

public static final int CUSTOMER_FIRSTNAME = 2;

public static final int CUSTOMER_LASTNAME = 3;

public static final int CUSTOMER_ID = 4;

private static CustomerSymbols fieldlnstance;

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_FIRSTNAME));

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. fieldlnstance == null) {

synchronized (anObject) {

if (CustomerSymbols. fieldlnstance = null) {

CustomerSymbols.fieldlnstance = new

CustomerSymbols ();

}

}

}

return

((Integer) CustomerSymbols.fieldInstance.fieldName2SymbolDictionar y.get (elementName)). IntValue ();

}

}

// END Customersymbols.Java

The following is a sample of a modified template document customer.jsp for generating an XML document with an array of users, as described in Example I:

for (int i = 0;

i <handler.getElementRepetitions (CustomerSymbols.CUSTOMERS); i ++)

{

<%handler.startElement(i,CustomerSymboIs.CUSTOMER);%> <customer>

<FirstName>

<% = handler.getElementValue (CustomerSymbols.CUSTOMER_FIRSTNAME)%> </FirstName>

<LastName>

<% = handler.getElement Value (CustomerSymbols.CUSTOMER_LASTNAME)%> </LastName>

<CustId> <% = handler.getElementValue (CustomerSymbols.CUSTOMER_ ID)%> </CustId>

</customer>

<% = handler.endElement (i, CustomerSymbols.CUSTOMER);%> <%}%>

Handler 114-1 determines the size of the array (i.e., the number of loops executed) and returns to the getElementRepetitions method. When the startElement method is called from the template document customer.jsp using the index and name, handler 114-1 creates a link to this particular user-defined array object.

Handler 114-1 uses the stack to handle recursion. As the object recurses, handler 114-1 pushes the write onto the stack using the startElement function, and pushes the data from the stack using the endElement function. A work item is an item located at the top of the stack.

If the object is optional (optional), the isOptionalElement () or isOptionalAtribute () methods are used to determine if the object exists. Adjustments are made to the process of processing the template document customer.jsp in order to introduce a conditional statement that uses the return Boolean expression for one of the isOptionalxxx methods. In general, the advantages of an exemplary embodiment of the present invention are as follows:

(a) creating a single integrated environment for converting an XML document into a Java object and a Java object into an XML document, which uses a handler that masks the way to obtain a property for conversion or display;

(b) the use of easily accessible tools (e.g., SAX parser, JSP) to implement the conversion methods (XML / Java) of the present invention; and

(c) providing interfaces and classes (in the Java language environment) that simplify the structure of the transformation process of the present invention and make the transformation process similar in both directions.

Claims (22)

1. A method of converting a data structure representing a program object into elements of a structured language of a document implemented in a computer and consisting in the fact that: (a) generate a template of the specified document; (b) read the properties of the program object, which are interconnected with the elements of the structured language of the document; (c) using the read properties, the constructs formed by the elements of the structured language are obtained on the basis of the relationship between these properties and the elements of the structured language and through a conversion code that provides both the conversion of a program object into a document based on elements of a structured language and conversion in the opposite direction; and (d) the resulting designs fill in the document template. 2. The method according to claim 1, wherein in step (c), a direct callback of the program object is performed to obtain properties that display structures that form the structure and content of the document. 3. The method according to claim 1, in which at step (c) create an object model that displays the structure and content of the document. 4. The method according to claim 1, in which the elements of a structured language are constructions of the XML language (extensible markup language). 5. The method according to claim 1, in which, in step (c), a cycle is created in the document template for processing repeating elements of a structured language. 6. System (10) for converting a program object (116) containing properties into a document (118) formed by elements of a structured language containing a computer (20) having a processor (22) connected via a system bus (26) to memory (24) ) in which are stored: (a) a template (112) of a document; (b) a processor interface (114-1) that displays the elements of a structured document language (118) based on callbacks performed by the document template (112); (c) a conversion module (114-2, 114-3) associated with a handler interface (114-1) and converting the properties of program objects (116) into elements of a structured language recognized by a document (118); and (d) the target output class (114-4) associated with the conversion module (114-2, 114-3) and used to write the structured language elements generated by the conversion module (114-2, 114-3) into a document ( 118). 7. The system according to claim 6, in which the conversion module has a conversion interface (114-2) that converts the properties of a program object into elements of a structured language and defines an output target document stream (118), and a conversion class (114-3) that provides methods used by the conversion interface (114-2). 8. The system of claim 7, wherein the output target stream is a buffer. 9. The system of claim 7, wherein the output target stream is a servlet response stream. 10. The system according to claim 6, in which the elements of a structured language are constructions of the XML language (extensible markup language). 11. The system of claim 10, in which the document template is created using JavaServer Pages (JSP) technology. 12. System (10) for converting a document (108) containing elements of a structured language into a program object (110) containing a computer (20) having a processor (22) connected via a system bus (26) to memory (24) into which are stored: (a) an analyzer (104) for detecting events displaying features of a document (108); (b) a class (106-1) of an input data source for reading a document (108); (c) the class (106-2) of the content handler associated with the class (106-1) of the input data source and implementing a buffer for events detected by the analyzer (104); and (d) a conversion module (106-3, 106-4) associated with the content processor data class (106-2) and converting events detected by the analyzer (104) into properties of a program object (110). 13. The system according to item 12, in which the conversion module has a conversion interface (106-4) that converts document events into object properties and defines an output target stream of a program object (110), and a class (106-3) that provides methods, conversions used by the interface (106-4). 14. The system of claim 13, wherein the elements of the structured language are XML language constructs (extensible language specification). 15. A method of converting a program object having properties into a document represented by elements of a structured language interconnected with properties of the program object, the method being implemented in a computer in whose memory the conversion interface and the container are stored, and that: (a) activating the transform interface and passing the program object to the instance of the activated transform interface; (b) activating the container and using a copy of the activated container, compile and execute the document template; and (c) writing a document to a predetermined output stream using a compiled document template. 16. The method according to clause 15, in which to maintain the processing state carry out a callback addressed to the conversion interface. 17. The method according to clause 15, in which the isOptionalElementPresent method is called to determine whether it is necessary to generate selected parts of the document through a compiled template. 18. The method according to clause 15, in which the isOptionalAttributePresent method is called to determine whether it is necessary to generate selected parts of the document through a compiled template. 19. The method according to clause 15, in which when generating complex types inside a document selected from the group consisting of an array of data, recursion and a complex type contained within another complex type, the processing state is maintained using the stack. 20. The method according to claim 19, in which the state of the stack is maintained by executing callbacks addressed to the conversion interface from the compiled template to indicate the beginning and end of elements of complex types. 21. The method according to clause 15, in which the getElementRepetitions method is called to determine the number of cycles performed by the template on selected sections of the document. 22. The method according to clause 15, in which the elements of a structured language are constructions of the XML language (extensible language specification), and to create a template using JavaServer Pages (JSP) technology.

Images