Esta pregunta es una operación que los programadores hacemos casi todos los días, ¿de cuántas formas tiene ?, hablemos de esto aquí.
Cuatro formas de análisis
- Análisis oficial
- Análisis de Google Gson
- Análisis de Alibaba FastJson
- Análisis de Jackson
Práctica de caso
Aquí solo discutimos cómo convertir objetos y json.
Aquí primero creamos un proyecto Maven para facilitar la introducción de dependencias y, de hecho, probamos nuestros diferentes métodos de resolución a través de pruebas unitarias.
A continuación, todos usamos el objeto Usuario, primero creamos las clases que necesitamos.
User.java
package org.example;
public class User {
private String name;
private String sex;
private Integer age;
public User() {
}
public User(String name, String sex, Integer age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
Análisis oficial
El método oficial de análisis de json es más engorroso, por lo que menos personas lo usan.
El primer paso es introducir dependencias:
<!--json官方-->
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20160810</version>
</dependency>El segundo paso es escribir código de prueba:
package org.example;
import org.json.JSONObject;
import org.springframework.stereotype.Component;
/**
* 官方解析
*/
@Component
public class JsonTest1 {
/**
* 对象转json
* @param user
* @return
*/
public String userToJson(User user){
JSONObject jsonObject = new JSONObject(user);
String jsonStr = jsonObject.toString();
return jsonStr;
}
/**
* json转对象
* @param json
* @return
*/
public User userFromJson(String json){
JSONObject jsonObject = new JSONObject(json);
String name = jsonObject.getString("name");
String sex = jsonObject.getString("sex");
int age = jsonObject.getInt("age");
User user = new User(name,sex,age);
return user;
}
}El tercer paso, prueba unitaria:
package org.example;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;
@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class JsonTest1Test {
@Autowired
private JsonTest1 jsonTest1;
@Test
public void userToJson() {
User user = new User("秦明", "man", 18);
String json = jsonTest1.userToJson(user);
System.out.println(json);
}
@Test
public void userFromJson() {
String json = "{\"sex\":\"man\",\"name\":\"秦明\",\"age\":18}";
User user = jsonTest1.userFromJson(json);
System.out.println(user);
}
}El cuarto paso es ver los resultados:
Análisis de Google Gson
El primer paso es introducir dependencias:
<!--gson-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>El segundo paso es escribir código de prueba:
package org.example;
import com.google.gson.Gson;
import org.springframework.stereotype.Component;
/**
* gson解析
*/
@Component
public class JsonTest2 {
/**
* 对象转json
* @param user
* @return
*/
public String userToJson(User user){
Gson gson = new Gson();
String json = gson.toJson(user);
return json;
}
/**
* json转对象
* @param json
* @return
*/
public User userFromJson(String json){
Gson gson = new Gson();
User user = gson.fromJson(json, User.class);
return user;
}
}El tercer paso, prueba unitaria: igual que el anterior (el tercer y cuarto pasos a continuación son los mismos que los anteriores, por lo que se omite lo siguiente)
El cuarto paso, verifique el resultado: Igual que el anterior
Análisis de Alibaba FastJson
Este método analítico fue desarrollado por Alibaba. Tiene la mayor eficiencia, es amado por todos y tiene funciones poderosas . Aquellos que quieran aprender más pueden consultar la API del sitio web oficial de FastJson .
El primer paso es introducir dependencias:
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>El segundo paso es escribir código de prueba:
package org.example;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;
/**
* fastjson解析
*/
@Component
public class JsonTest3 {
/**
* 对象转json
* @param user
* @return
*/
public String userToJson(User user){
String json = JSONObject.toJSONString(user);
return json;
}
/**
* json转对象
* @param json
* @return
*/
public User userFromJson(String json){
User user = JSONObject.parseObject(json,User.class);
return user;
}
}Análisis de Jackson
Este método de análisis actualmente utiliza algunos de los marcos más populares, como SSM y SpringBoot. Jackson se utiliza para el análisis interno de json, pero a menudo presentamos FastJson para usarlo porque es más rápido.
El primer paso es introducir dependencias:
<!--jackson-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>El segundo paso es escribir código de prueba:
package org.example;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;
import java.io.IOException;
/**
* jackson解析
*/
@Component
public class JsonTest4 {
/**
* 对象转json
* @param user
* @return
*/
public String userToJson(User user) throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(user);
return json;
}
/**
* json转对象
* @param json
* @return
*/
public User userFromJson(String json) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
User user = objectMapper.readValue(json, User.class);
return user;
}
}Extensión ~ el nacimiento de JSON
<img src = " https://imgkr.cn-bj.ufileos.com/38309b14-d0fb-4b01-a107-fa7a00786886.png " alt = "img" style = "zoom: 80%;" />
JSON nació porque los detalles de la integración de XML en HTML en cada navegador son diferentes, por lo que Douglas Crockford (Douglas Crockford) y Chip Morningstar (Chip Morningstar) juntos a partir de tipos de datos JS Se extrajo un subconjunto como un nuevo formato de intercambio de datos. Debido a que los navegadores convencionales usan componentes comunes del motor de JavaScript, no hay problemas de compatibilidad al analizar este nuevo formato de datos, por lo que nombraron este formato de datos "JavaScript Object Notation", abreviado como JSON, ¡y así nació JSON!