关于java:JSON数据如何进行解析呢方式有哪些

32次阅读

共计 12789 个字符，预计需要花费 32 分钟才能阅读完成。

这个问题是咱们作为程序员简直每天都要进行的操作，那它有多少种形式呢，咱们这里就这点来说一说。

解析的四种形式

  • 官网解析
  • 谷歌 Gson 解析
  • 阿里巴巴 FastJson 解析
  • Jackson 解析

案例实操

这里咱们就只探讨对象与 json 如何相互转换。

这里咱们先创立好 Maven 我的项目，不便引入依赖，通过单元测试来理论测验咱们不同的解析形式。

上面咱们都应用 User 对象，先创立好咱们须要的类。

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 +
‘}’;
}

}
​

官网解析

官网提供的 json 解析形式，比拟繁琐，所以用的人比拟少。

第一步，引入依赖：

<!–json 官网 –>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20160810</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：

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.SpringJUnit4ClassRunner;
​
@RunWith(SpringJUnit4ClassRunner.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);
}
}

谷歌 Gson 解析

第一步，引入依赖：

<!–gson–>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：同上（上面第三步和第四步和下面都一样，所以上面省略）

第四步，查看后果：同上

阿里巴巴 FastJson 解析

这个解析形式是由阿里巴巴开发进去的，效率最高，深受大家青睐，功能强大，想要更深刻学习的能够查看 FastJson 官网 API。

第一步，引入依赖：

<!–fastjson–>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

Jackson 解析

这个解析形式是在目前咱们应用最风行的一些框架比方 SSM、SpringBoot，其外部的 json 解析应用的就是 Jackson，但往往咱们会另外引入 FastJson 来应用，因为速度更快。

第一步，引入依赖：

<!–jackson–>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>

第二步，编写测试代码：

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;
}
​
} 这个问题是咱们作为程序员简直每天都要进行的操作，那它有多少种形式呢，咱们这里就这点来说一说。

解析的四种形式

  • 官网解析
  • 谷歌 Gson 解析
  • 阿里巴巴 FastJson 解析
  • Jackson 解析

案例实操

这里咱们就只探讨对象与 json 如何相互转换。

这里咱们先创立好 Maven 我的项目，不便引入依赖，通过单元测试来理论测验咱们不同的解析形式。

上面咱们都应用 User 对象，先创立好咱们须要的类。

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 +
‘}’;
}

}
​

官网解析

官网提供的 json 解析形式，比拟繁琐，所以用的人比拟少。

第一步，引入依赖：

<!–json 官网 –>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20160810</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：

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.SpringJUnit4ClassRunner;
​
@RunWith(SpringJUnit4ClassRunner.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);
}
}

谷歌 Gson 解析

第一步，引入依赖：

<!–gson–>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：同上（上面第三步和第四步和下面都一样，所以上面省略）

第四步，查看后果：同上

阿里巴巴 FastJson 解析

这个解析形式是由阿里巴巴开发进去的，效率最高，深受大家青睐，功能强大，想要更深刻学习的能够查看 FastJson 官网 API。

第一步，引入依赖：

<!–fastjson–>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

Jackson 解析

这个解析形式是在目前咱们应用最风行的一些框架比方 SSM、SpringBoot，其外部的 json 解析应用的就是 Jackson，但往往咱们会另外引入 FastJson 来应用，因为速度更快。

第一步，引入依赖：

<!–jackson–>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>

第二步，编写测试代码：

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;
}
​
} 这个问题是咱们作为程序员简直每天都要进行的操作，那它有多少种形式呢，咱们这里就这点来说一说。

解析的四种形式

  • 官网解析
  • 谷歌 Gson 解析
  • 阿里巴巴 FastJson 解析
  • Jackson 解析

案例实操

这里咱们就只探讨对象与 json 如何相互转换。

这里咱们先创立好 Maven 我的项目，不便引入依赖，通过单元测试来理论测验咱们不同的解析形式。

上面咱们都应用 User 对象，先创立好咱们须要的类。

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 +
‘}’;
}

}
​

官网解析

官网提供的 json 解析形式，比拟繁琐，所以用的人比拟少。

第一步，引入依赖：

<!–json 官网 –>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20160810</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：

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.SpringJUnit4ClassRunner;
​
@RunWith(SpringJUnit4ClassRunner.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);
}
}

谷歌 Gson 解析

第一步，引入依赖：

<!–gson–>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

第三步，单元测试：同上（上面第三步和第四步和下面都一样，所以上面省略）

第四步，查看后果：同上

阿里巴巴 FastJson 解析

这个解析形式是由阿里巴巴开发进去的，效率最高，深受大家青睐，功能强大，想要更深刻学习的能够查看 FastJson 官网 API。

第一步，引入依赖：

<!–fastjson–>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

Jackson 解析

这个解析形式是在目前咱们应用最风行的一些框架比方 SSM、SpringBoot，其外部的 json 解析应用的就是 Jackson，但往往咱们会另外引入 FastJson 来应用，因为速度更快。

第一步，引入依赖：

<!–jackson–>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>

第二步，编写测试代码：

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;
}
​
}

正文完
java
发表至： java
2020-10-20
 0
关于java:如何优化正则表达式性能
Spring Boot（十）Logback和Log4j2集成与日志发展史
关于java:maven工程jar包瘦身
关于java:Java-线程