Use the Jackson Core framework in the Java class library for XML serialization and dependentization
Use the Jackson Core framework in the Java class library for XML serialization and dependentization
Jackson is a popular Java class library that can be used to serialize and derives between Java objects and XML.Jackson Core is a core module in the Jackson framework, which provides the ability to process XML format data.This article will introduce how to use the Jackson Core framework in Java to serialize and deactivate XML.
1. Introduction to Jackson Core framework
Jackson is a Java library for processing data for JSON, XML, YAML and other formats.It provides a set of APIs and tools for processing these data formats.Among them, Jackson Core is the core module of the Jackson framework, which provides universal data processing capabilities, including serialization and derivativeization.
2. Add dependence
Using the Jackson Core framework for XML serialization and derivativeization, we first need to add corresponding dependencies to the project.You can add dependencies through Maven or Gradle.The following is an example of using Maven to add dependencies:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.12.2</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.2</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.12.2</version>
</dependency>
3. XML serialization
Use the Jackson Core framework in Java for XML serialization. You need to create a XMLMAPPER object to perform serialization operations with it.The following is an example of serializing the Java object to XML:
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
public class XmlSerializer {
public static void main(String[] args) {
try {
// Create XMLMAPPER objects
XmlMapper xmlMapper = new XmlMapper();
// Create a Java object
Person Person = New Person ("Zhang San", 20);
// Execute serialization operation
String xml = xmlMapper.writeValueAsString(person);
// Output serialization results
System.out.println(xml);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
}
In the above example, first create a XMLMAPPER object, then create a Person object, and finally call the xmlmapper.writevalueasstring () method to sequence the person as a XML string.
Fourth, XML counter -serialization
In Java, the Jackson Core framework is used for XML back serialization. It also needs to create a XMLMAPPER object to use it to perform a debit series operation.The following is an example of turning the XML string back order into the Java object:
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
public class XmlDeserializer {
public static void main(String[] args) {
try {
// Create XMLMAPPER objects
XmlMapper xmlMapper = new XmlMapper();
// xml string
String xml = "<Person><name>张三</name><age>20</age></Person>";
// Execute the back -sequentialization operation
Person person = xmlMapper.readValue(xml, Person.class);
// Output Capitalization results
System.out.println(person.getName());
System.out.println(person.getAge());
} catch (Exception e) {
e.printStackTrace();
}
}
}
In the above example, a XMLMAPPER object is first created, and then a XML string is defined as a back -sequential input. Finally, the XMLMAPPER.Readvalue () method is called to organize the XML string to the Person object.
Through the above examples, we can see that it is very simple to use the Jackson Core framework to perform XML serialization and derivativeization in the Java library.You only need to introduce the corresponding dependencies, and then create an XMLMAPPER object. Call the method provided to achieve serialization and dependentization operation.
