Implementation steps of using oxm to map xml-JS Tutorial-php.cn

This time I will bring you the implementation steps of using oxm to map xml. What are the precautions for using oxm to map xml. The following is a practical case, let's take a look.

Understanding XML parsing technology

XML related concepts

(1) DTD: XML syntax rules are the verification mechanism of XML files. You can compare XML documents and DTD files to see whether the document conforms to the specifications and whether the elements and tags are used correctly.

(2) XML is the basis of SOA.

XML processing technology

(1) In order to use XML, we need to access data through an XML processor or XML API. Currently, JAXP provides two methods for processing XML: DOM and SAX.

①DOM: DOM accesses the data and structure in the XML document through programming, based on the tree structure of the XML document in memory. The disadvantage is that loading the entire XML document into memory requires a lot of overhead.

②SAX: It is event-driven and uses one segment of parsing to solve the problem of DOM occupying large memory. However, its disadvantage is that it cannot access documents randomly.

(2) In order to solve the problems of DOM and SAX, a stream-based StreamAPI for XML (StAX for short) appeared. It has been added to JAXP1.4 of JDK6. StAX is also event-driven.

(3) DOM, SAX and StAX all process XML based on the document structure, but many applications only focus on the document data itself, so XMLdata binding technology came into being.

Data binding: refers to the process of extracting data from storage media (XML documents and databases) and representing the data through programs, that is, binding the data to some kind of memory structure that the virtual machine can understand and operate.

XML binding frameworks: Castor, JAXB, JiBX, Quick, Zeus, etc.

XStream Overview

(1) XStream is a simple and easy-to-use open source framework for serializing Java objects into XML or deserializing XML into Java objects.

(2) XStream architecture composition:

Converters: When XStream encounters an object that needs to be converted, it delegates to the appropriate converter implementation.

IO (input/output): XStream is abstracted from the underlying XML data through HierarchicalStreamWriter and HierarchicalStreamReader, which are used for serialization and deserialization operations respectively.

Context: When XStream serializes and deserializes objects, it will create two classes, MarshallingContext and UnmarshallingContext, and the tower will process the data and delegate it to the appropriate converter.

Facade (unified entrance): Integrate the above three points together and open them to users with a unified interface.

Quick Start

(1) Create an XStream and specify the XML parser

XStreamxstream=newXStream(newDomDriver());

If you do not specify a parser, XStream will use the XPP (XMLPullParser) parser by default. XPP is a high-speed parser.

(2) Examples are as follows:

Use XStream alias

(1) In the above example, the full class name of the Java object corresponds to the root element of the XML file, and the attribute name corresponds to the node element of the XML file. However, in actual situations, both the Java object and the XML object may have already defined names. At this time, you need to use alias mapping.

XStream has three alias configurations:

Category name: Use alias(Stringname,Classtype).

Class member alias: use aliasField(Stringalias,ClassdefinedIn,StringfieldName).

Class members are used as attribute aliases: use aliasAttribute(ClassdefinedIn,StringattributeName,Stringalias). It is meaningless to name them alone. They must also be applied to a certain class through useAttributeFor(ClassdefinedIn,StringfieldName).

XStream Converter

During the development process, sometimes you need to convert some custom types. Just implement the Converter interface and call the registerConverter() method of XStream to register the converter.

XStream Annotations

XStreamxstream=newXStream(newDomDriver());

There are 2 ways to load objects:

①Method 1:

xstream.processAnnotations(AAA.class);

xstream.processAnnotations(BBB.class);

②Method 2:

xstream.autodetectAnnotations(true);//Automatically load annotation beans, and also cache the annotated objects

Streaming objects

(1) XStream provides alternative implementations for ObjectInputStream and ObjectOutputStream, allowing XML serialization or deserialization operations in the form of object streams. The previous one is the XML read by the DOM-based XML parser. Here we should obviously use the stream method for parsing.

The difference between using PrettyWriter and CompactWriter is that PrettyWriter will format the generated XML, while CompactWriter will compress the generated XML.

Persistence API

(1) XStream provides a simple way to persist objects in a collection into files, such as: XmlArrayList, XmlSet, XmlMap, etc.

(2) Before creating a collection, you also need to specify a persistence strategy PersistenceStrategy.

Processing JSON

(1) XML has an unshakable position in WebService, but in most web applications, lightweight JSON is still used as the data exchange format.

(2) XStream provides JettisonMappedXmlDriver and JsonHierarchicalStreamDriver to complete the conversion of java objects and json.

(3) The difference between JettisonMappedXmlDriver and JsonHierarchicalStreamDriver:

①JettisonMappedXmlDriver generates compressed JSON, while JsonHierarchicalStreamDriver generates formatted JSON.

②To convert JSON to an object, you can only use JettisonMappedXmlDriver.

Integration with SpringOXM

Overview of SpringOXM

SpringOXM has done a great job on the mainstream O/XMapping framework A unified abstraction and encapsulation, Marshaller and Unmarshaller are the two core interfaces of SpringOXM. Marshaller is used to convert objects into XML, and Unmarshaller is used to convert XML into objects.

summary

(1) XML data binding of java applications can be summarized into 2 methods:

Generate Java language code (such as JAXB, XMLBeans, Castor) based on XML documents.

Use some form of mapping binding method, which is to set how Java classes are associated with XML (such as XStream, Castor, JiBX).

(2) 2 ways to compare:

With a stable document structure defined by a Schema or DTD that is suitable for the application's needs, a code generation approach may be the best choice.

If you are using an existing Java class, or if you want to use a structure of the class that reflects the application's usage of the data, rather than an XML structure, the mapping method is the best choice.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!