Essa pergunta é uma operação que nós, como programadores, fazemos quase todos os dias. De quantas maneiras isso tem? Vamos falar sobre isso aqui.
Quatro formas de análise
- Análise oficial
- Análise Google Gson
- Análise Alibaba FastJson
- Análise de Jackson
Prática de caso
Aqui, discutimos apenas como converter objetos e json.
Aqui, primeiro criamos um projeto Maven para facilitar a introdução de dependências e, na verdade, testamos nossos diferentes métodos de resolução por meio de testes de unidade.
Abaixo todos nós usamos o objeto User, primeiro crie as classes que precisamos.
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álise oficial
O método oficial de análise json é mais complicado, portanto, menos pessoas o usam.
A primeira etapa é introduzir dependências:
<!--json官方-->
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20160810</version>
</dependency>A segunda etapa é escrever o código de teste:
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;
}
}A terceira etapa, teste de unidade:
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);
}
}A quarta etapa é visualizar os resultados:
Análise Google Gson
A primeira etapa é introduzir dependências:
<!--gson-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>A segunda etapa é escrever o código de teste:
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;
}
}A terceira etapa, teste de unidade: o mesmo que acima (a terceira e a quarta etapas abaixo são iguais às anteriores, portanto, o seguinte é omitido)
Na quarta etapa, verifique o resultado: O mesmo que acima
Análise Alibaba FastJson
Este método analítico foi desenvolvido pela Alibaba. É o mais eficiente, querido e poderoso. Quem quiser saber mais pode consultar a API do site oficial FastJson .
A primeira etapa é introduzir dependências:
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>A segunda etapa é escrever o código de teste:
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álise de Jackson
Este método de análise é usado atualmente por alguns dos frameworks mais populares, como SSM e SpringBoot. Jackson é usado para análise json interna, mas geralmente introduzimos FastJson para usá-lo porque é mais rápido.
A primeira etapa é introduzir dependências:
<!--jackson-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>A segunda etapa é escrever o código de teste:
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;
}
}Extensão ~ o nascimento de JSON
<img src = " https://imgkr.cn-bj.ufileos.com/38309b14-d0fb-4b01-a107-fa7a00786886.png " alt = "img" style = "zoom: 80%;" />
JSON nasceu porque os detalhes de implementação da integração de XML em HTML em cada navegador não são os mesmos, então Douglas Crockford (Douglas Crockford) e Chip Morningstar (Chip Morningstar) juntos a partir de tipos de dados JS Um subconjunto foi extraído como um novo formato de troca de dados. Como os navegadores convencionais usam componentes de mecanismo JavaScript comuns, não há problema de compatibilidade ao analisar esse novo formato de dados, então eles nomearam esse formato de dados "JavaScript Object Notation", abreviado como JSON, e assim nasceu o JSON!