What is the JSON framework in the java class library
The most commonly used JSON framework in the Java class library is Jackson.Jackson is a high -performance, functional Java JSON processing library developed by FasterXML.It provides a series of APIs used to read, write, and operate JSON data, so that Java developers can easily process JSON data.
Before using Jackson, we first need to add it to the dependence of the Java project.You can build tools through Maven or Gradle to add the following dependencies in the project's pom.xml (or Build.gradle) file:
// Maven
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.5</version>
</dependency>
</dependencies>
// Gradle
dependencies {
implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.5'
}
After adding dependencies, we can start using Jackson.Here are some common examples:
1. Convert java objects to JSON string:
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonExample {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
// java objects converted to json string
User user = new User("John", 30);
String json = objectMapper.writeValueAsString(user);
System.out.println (json); // Output: {"name": "John", "Age": 30}
}
static class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
// It must provide the default constructor so that Jackson can be able to discerize objects
public User() {
}
// omit the getter and setter method
}
}
2. Convert JSON string to Java object:
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonExample {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
// json string convert to Java object
String json = "{\"name\":\"John\",\"age\":30}";
User user = objectMapper.readValue(json, User.class);
System.out.println (user.getName ()); // Output: John
System.out.println (user.getage ()); // Output: 30
}
static class User {
private String name;
private int age;
// omit the constructive method and getter, setter method
}
}
3. Processing complex JSON structure:
Jackson provides a powerful API for processing complex JSON structures, such as nested objects, array, etc.For example, you can use the `jsonnode` class to traverse and operate the JSON tree:
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonExample {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
String json = "{\"name\":\"John\",\"age\":30,\"skills\":[\"Java\",\"Python\"]}";
JsonNode jsonNode = objectMapper.readTree(json);
String name = jsonNode.get("name").asText();
int age = jsonNode.get("age").asInt();
JsonNode skillsNode = jsonNode.get("skills");
System.out.println (name); // Output: John
System.out.println (Age); // Output: 30
System.out.println (SkillsNode.isarray ()); // Output: true
}
}
Through the above examples, we can see that using Jackson to process JSON data is very simple.Jackson provides rich functions and flexible APIs to meet the needs of most JSON operations.Whether converting the Java object to a JSON string or converting the JSON string into a Java object, Jackson can help us handle it quickly and efficiently.Therefore, Jackson is one of the indispensable JSON processing frameworks in Java development.
