我们在日常开发中少不了和JSON数据打交道，那么我们来看看JAVA中常用的JSON解析方式。
1、JSON官方 （就不说了）
2、GSON （谷歌）
3、FastJSON （阿里巴巴）
4、jackson （springMvc 内置）
我们开始来参加 json 数据模拟对象
一、创建对象类模拟
1、对象类1 Grade
import java.util.ArrayList;
public class Grade {
private int id;
private String name;
//对象类 2 集合
private ArrayList<Student> stus;
//自定义构造器
public Grade(int id, String name, ArrayList<Student> stus) {
super();
this.id = id;
this.name = name;
this.stus = stus;
}
//默认构造器
public Grade() {
super();
}
}
2、对象类2 Student
public class Student {
private int id;
private String name;
private int age;
}
3、自行生成 get 、set 、toString方法
4、模拟的数据结构
/* 数据结构
{ id:
name:
stus:[{
id:
name:
age:
}]
}
* */
二、Json 之 GSON （谷歌）
GSON : 谷歌的，也比较好用
其中2.8.2为版本号，最新版本以及源码可以在官方的github上查看：https://github.com/google/gson
1、添加依赖
GSON : 谷歌的，也比较好用
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.2</version>
</dependency>
2、简析json 数据
//解析json数据
public static void test1() {
//Gson对象
Gson gson=new Gson();
// 解析字符串（到Grade类对象中）
String json1 = "{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘一','age':16}]}";
//解析对象：第一个参数：待解析的字符串 第二个参数结果数据类型的Class对象（类对象）
Grade grade=gson.fromJson(json1, Grade.class);
System.out.println("解析json 字符串到类对象中："+grade);
// 解析数组（到list集合中）
String json2 = "['北京','天津','杭州']";
//解析数组要求使用Type
ArrayList<String> list = gson.fromJson(json2,new TypeToken<ArrayList<String>>(){}.getType());
System.out.println("解析json 数组到list集合中："+list);
}
3、生成 json 数据
//生成json数据
public static void test2(){
//生成3个 Student 对象保存到 list中
ArrayList<Student> list=new ArrayList<Student>();
for(int i=0;i<3;i++){
list.add(new Student(101+i, "码子", 20+i));
}
//把 Student 保存到 Grade 中
Grade grade = new Grade(100001,"张三", list);
Gson gson = new Gson();
//将对象转换为诶JSON格式字符串
String json = gson.toJson(grade);
System.out.println("生成json 对象数据："json);
//{"id":100001,"name":"张三","stus":[{"id":101,"name":"码子","age":20},{"id":102,"name":"码子","age":21},{"id":103,"name":"码子","age":22}]}
}
三、Json 之 fastjson ( 阿里巴巴）
fastjson ： FastJSON是阿里巴巴的产品，效率最高
1、添加依赖
FastJSON是阿里巴巴的产品，效率最高
<!-- 二、fastjson ： FastJSON是阿里巴巴的产品，效率最高 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.4</version>
</dependency>
2、简析 json 数据
//解析
public static void test1() {
// 对象嵌套数组嵌套对象
String json1 = "{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘铭','age':16}]}";
// 数组
String json2 = "['北京','天津','杭州']";
//1、
//静态方法
Grade grade = JSON.parseObject(json1, Grade.class);
System.out.println("解析对象："+grade);
//2、
List<String> list = JSON.parseArray(json2, String.class);
System.out.println("解析数组："+list);
}
3、生成 json 数据
//生成
public static void test2() {
ArrayList<Student> list = new ArrayList<Student>();
for (int i = 1; i < 3; i++) {
list.add(new Student(101 + i, "码子", 20 + i));
}
Grade grade = new Grade(100001, "张三", list);
String json = JSON.toJSONString(grade);
System.out.println("生成json："+json);
}
}
四、Json 之 Jackson（MVC）
Jackson ：SpringMVC内置的解析器就是这个
1、添加依赖
<!-- 三 、Jackson ：SpringMVC内置的解析器就是这个 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.8.1</version>
</dependency>
<!-- JSONArray 等支持-->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
2、简析 json 数据
//解析
public static void test1() throws Exception {
// 对象嵌套数组嵌套对象
String json1 = "{\"id\":1,\"name\":\"JAVAEE-1703\",\"stus\":[{\"id\":101,\"name\":\"刘一\",\"age\":16}]}";
// 数组
String json2 = "[\"北京\",\"天津\",\"杭州\"]";
//1、
ObjectMapper mapper = new ObjectMapper();
Grade grade = mapper.readValue(json1, Grade.class);
System.out.println("解析 json 字符串到类对象："+grade);
//2、
ArrayList<String> list = mapper.readValue(json2,
new TypeReference<ArrayList<String>>() {
});
System.out.println("解析 json 数组到集合："+list);
}
3、生成 json 数据
//生成
public static void test2() throws JsonProcessingException {
ArrayList<Student> list = new ArrayList<Student>();
for (int i = 1; i < 3; i++) {
list.add(new Student(101 + i, "码子", 20 + i));
}
Grade grade = new Grade(100001, "张三", list);
ObjectMapper mapper = new ObjectMapper();
//将对象转换为JSON格式字符串
String json = mapper.writeValueAsString(grade);
System.out.println("生成json："+json);
}
4、json 数据转换
json -->> JavaScript Object Notation
//map集合/类转换成json -->>
数据格式如：var json = {“name”:”Jack”,”age”:90,”Marray”:true};
//把list/数组转为json -->>
数据格式如：var json = {“name”,”age”,”Marray”};
1、Map 转 json
JSONObject obj = JSONObject.fromObject(map); //把map`集合/类` 转成json
2、list 转 json
JSONArray obj = JSONArray.fromObject(list); //把list/数组 转为json
3、json 转 字符串
JSONObject obj = JSONObject.fromObject(str); // 获取json 字符串 str
String result = obj.toString(); // 把json对象转换成字符串
4、json转 类对象
JSONObject obj = JSONObject.fromObject(str); // 获取json 字符串 str
Person p = (Person) JSONObject.toBean(obj, Person.class); //把 json字符串转为 Person类（对应属性）
5、json转 Map
JSONObject obj = JSONObject.fromObject(str); // 获取json 字符串 str
Map m = (Map) JSONObject.toBean(obj, Map.class); //把 json字符串转为 Map
5、解析 json 数据2
// json 解析生成对象
public static void test3(){
// 对象嵌套数组嵌套对象
//String json1 = "[{\"id\":1,\"name\":\"JAVAEE-1703\",\"stus\":[{\"id\":101,\"name\":\"刘一\",\"age\":16}]}]";
String json1 = "[{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘一','age':16}]}]";
//获取json字符串
JSONArray ja = JSONArray.fromObject(json1);
//创建json配置对象
JsonConfig jc = new JsonConfig();
//设置json的要转换的类
jc.setRootClass(Grade.class);
//把json的多个对象属性放入集合
List<Grade> pList = (List<Grade>) JSONSerializer.toJava(ja, jc);
for (Grade p : pList) {
System.out.println(p);
}
}
获得结果
6、属性排除
//属性排除
public static void test4(Grade p){
JsonConfig jc = new JsonConfig(); //创建json配置对象
String[] attrs = {"id","stus"}; //添加要排除的属性
jc.setExcludes(attrs); //排除 /转换json时
//JSONObject obj = JSONObject.fromObject(p, jc); //把map转换成json对象
JSONArray p1 = JSONArray.fromObject(p, jc); //把list转换成json对象
System.out.println(p1);
}
结果：第二次输出被排除掉了