The object serialization is achieved in the Java library through the Circe YAML framework
Use the Circe YAML framework to achieve the object serialization in the Java class library
# 前
In Java development, the object serialization is a process of converting an object into a byte sequence, which can be used to store object data or transmit it on the network.Circe Yaml is a popular Java class library for mutual conversion between objects and Yaml (Yaml Ain'T Markup Language).Yaml is a human friendly data serialization format, which is very useful for configuration files and structured data.
This article will introduce how to use the Circe YAML framework to implement the serialization and derivativeization of the object.
# Introduction to Circe YAML dependencies
First, add Circe Yaml dependencies to your Java project.You can add the following dependencies to Maven or Gradle Construction Tools:
Maven:
<dependency>
<groupId>io.circe</groupId>
<artifactId>circe-yaml_2.13</artifactId>
<version>0.14.1</version>
</dependency>
Gradle:
groovy
implementation 'io.circe:circe-yaml_2.13:0.14.1'
# Create a serialized Java class
Next, we will create a simple Java class to demonstrate how to use the Circe YAML framework for the serialization and derivativeization of the object.
import io.circe.*;
import io.circe.parser.*;
import io.circe.syntax.*;
import java.util.*;
public class Person {
private String name;
private int age;
private List<String> hobbies;
// Ported constructor
public Person() {
}
// There are participating functions
public Person(String name, int age, List<String> hobbies) {
this.name = name;
this.age = age;
this.hobbies = hobbies;
}
// getter and setter method
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
// Sequences to yaml
public String toYaml() {
Encoder<Person> encoder = Encoder.instance();
String yaml = encoder.apply(this).toString();
return yaml;
}
// From YAML's back serialization
public static Person fromYaml(String yaml) {
Parser parser = new Parser();
Result<Json> result = parser.parse(yaml);
if (result.isSuccess()) {
Decoder<Person> decoder = Decoder.decodeOption(Decoder.instance());
return decoder.decodeJson(result.get()).getOrElse(null);
} else {
return null;
}
}
// The main method
public static void main(String[] args) {
// Create Person objects
Person Person = New Person ("Zhang San", 25, Arrays.aslist ("Basketball", "Music", "Travel");
// Sequences to yaml
String yaml = person.toYaml();
System.out.println ("serialized yaml:");
System.out.println(yaml);
// From YAML's back serialization
Person deserializedPerson = Person.fromYaml(yaml);
System.out.println ("Objects obtained by deeper order:");
System.out.println(deserializedPerson);
}
}
In the above code, we define a `Person` class, which contains the three attributes of` name`, `Age` and` Hobbies`.The class provides a non -ginseng constructor and a participating function, as well as the corresponding Getter and Setter method.In addition, we also implemented the method of `TOYAML ()` and `Fromyaml ()` method to convert the `Person` object into a YAML strings and the back order of the skewers from the YAML string to the` Person` object.`main` method is used to test the process of serialization and device.
# 运 运
In the above code, we use a simple `Person` object as an example, which can be changed and expanded according to actual needs.Run this code, you will get the following output:
The serialized yaml:
{
"name": "Zhang San",
"age" : 25,
"Hobbies": ["Basketball", "Music", "Travel"]
}
Objects obtained by deepertine:
Person {name = 'Zhang San', Age = 25, Hobbies = [Basketball, Music, Travel]}
The output contains the `Person` object obtained by serialized YAML string and derivatives.
# in conclusion
Through the Circe YAML framework, the serialization and deepening of the object in the Java class have become very simple.You can convert the object to the YAML string according to specific needs for storage or transmission, and the YAML string derivatives into objects for further processing.
Hope this article will help you help you in the process of using the Circe YAML framework to achieve the object serialization.Thank you for reading!
