Java-json序列化和反序列化
Java-json序列化和反序列化
java开发中经常会遇到json的序列化与反序列化，常用的json序列化工具有阿里的Fastjson、spring mvc内置的Jackson、还有就是我们接下来要说的谷歌的Gson。
Fastjson 的常见使用
Fastjson API入口类是com.alibaba.fastjson.JSON，常用的序列化操作都可以在JSON类上的静态方法直接完成。
反序列化
// 把JSON文本parse为JSONObject或者JSONArray
public static final Object parse(String text);
// 把JSON文本parse成JSONObject
public static final JSONObject parseObject(String text)；
// 把JSON文本parse为JavaBean
public static final <T> T parseObject(String text, Class<T> clazz);
// 把JSON文本parse成JSONArray
public static final JSONArray parseArray(String text);
//把JSON文本parse成JavaBean集合
public static final <T> List<T> parseArray(String text, Class<T> clazz);
序列化
// 将JavaBean序列化为JSON文本
public static final String toJSONString(Object object);
// 将JavaBean序列化为带格式的JSON文本
public static final String toJSONString(Object object, boolean prettyFormat);
//将JavaBean转换为JSONObject或者JSONArray。
public static final Object toJSON(Object javaObject);示例
fastjson反序列化json字符串为四种类型
1. JavaBean
Student student = JSON.parseObject(jsonString, Student.class);
2. List<JavaBean>
List<Student> listPerson =JSON.parseArray(jsonString, Student.class);
3. Map<String,Student>
Map<String, Object> listPerson = JSON.parseObject(jsonString,new TypeReference<Map<String,Object>>(){});
4. List<Map<String,Object>>
List<Map<String, Object>> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map<String,Object>>>(){});JackJson的常见使用
需要包： jackson-core-2.2.3.jar（核心jar包） jackson-annotations-2.2.3.jar（该包提供Json注解支持） jackson-databind-2.2.3.jar
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.1</version>
</dependency>1、指定对象Class转成 json字符串
/**
ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。
ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。
*/
ObjectMapper mapper = new ObjectMapper();//User类转JSON
{"name":"小民","age":20,"birthday":844099200000,"email":"xiaomin@sina.com"}
String json = mapper.writeValueAsString(user);
System.out.println(json);2、List集合转化成json字符串
List<User> users = new ArrayList<User>();
users.add(user);
String jsonlist = mapper.writeValueAsString(users);
System.out.println(jsonlist);3、Json字符串转化成指定Class类
String json = "{\"name\":\"小民\",\"age\":20,\"birthday\":844099200000,\"email\":\"xiaomin@sina.com\"}";
/**
* ObjectMapper支持从byte[]、File、InputStream、字符串等数据的JSON反序列化。
*/
ObjectMapper mapper = new ObjectMapper();
User user = mapper.readValue(json, User.class);
System.out.println(user);4、Json字符串转化成集合List
String jsonString="[{'id':'1'},{'id':'2'}]";
ObjectMapper mapper = new ObjectMapper();
List<Bean> beanList = mapper.readValue(jsonString, new TypeReference<List<Bean>>() {});5.创建一个JSON对象
try {
// create `ObjectMapper` instance
ObjectMapper mapper = new ObjectMapper();
// create a JSON object
ObjectNode user = mapper.createObjectNode();
user.put("id", 1);
user.put("name", "John Doe");
user.put("email", "john.doe@example.com");
user.put("salary", 3545.99);
user.put("role", "QA Engineer");
user.put("admin", false);
// convert `ObjectNode` to pretty-print JSON
// without pretty-print, use `user.toString()` method
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
// print json
System.out.println(json);
} catch (Exception ex) {
ex.printStackTrace();
}Gson 的常见使用
GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象，或者将一个Java转化为Json字符串。
Gson特点：1：面向对象；2：简洁高效；3：数据传递和解析方便
下面介绍一下Gson的常用方法
首先贴一下我用来做示例的实体类Test的代码，如下：
public class Test {
/* 姓名*/
private String name;
/* 性别*/
private String sex;
/* 年龄*/
private Integer 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 "StudentEntity{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
public Test(String name, String sex, Integer age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}1.gson.tojso();//形参为要序列化的json串
方法作用：把实体对象转换为json（序列化）
public static void main(String[] args) {
//创建实体类
Test test = new Test("序列化", "男", 25);
//实例化Gson
Gson gson = new Gson();
//把对象序列化为json
String s = gson.toJson(test);
//输出---序列化后的结果为：{"name":"序列化","sex":"男","age":25}
System.out.println("序列化后的结果为："+s);
//定义List集合
List<Test> tests = new ArrayList<>();
tests.add(test);
String s1 = gson.toJson(tests);
//输出---List集合序列化后的结果为：[{"name":"序列化","sex":"男","age":25}]
System.out.println("List集合序列化后的结果为："+s1);
Map<String, Test> testMap = new HashMap<>();
testMap.put("序列化测试",test);
//输出--Map集合序列化后的结果为：{序列化测试=StudentEntity{name='序列化', sex='男', age=25}}
System.out.println("Map集合序列化后的结果为："+testMap);
}2.gson.fromJson();
方法作用：
（1）把json转换为List对象（反序列化）
public static void main(String[] args) {
// 定义json
String json = "[{\"name\":\"转换对象\",\"sex\":\"女\",\"age\":20}]";
//实例化Gson
Gson gson = new Gson();
//把json序列化为List对象
List<Test> o = gson.fromJson(json, new TypeToken<List<Test>>() {
}.getType());
//输出---序列化后的结果为：[StudentEntity{name='转换对象', sex='女', age=20}]
System.out.println("反序列化成List后的结果为："+o.toString());
}（2）把json转换为Map对象（反序列化）
public static void main(String[] args) {
//实例化Gson
Gson gson = new Gson();
//定义json
String jsonMap = "{'序列化测试':{name='序列化', sex='男', age=25}}";
//把json序列化为Map对象
HashMap<String,Test> o1 = gson.fromJson(jsonMap, new TypeToken<HashMap<String,Test>>() {
}.getType());
//输出---{序列化测试=StudentEntity{name='序列化', sex='男', age=25}}
System.out.println("反序列化成Map后的结果为："+o1);
}（3）把json转换为实体对象（反序列化）
public static void main(String[] args) {
// 定义json
String json = "{\"name\":\"转换对象\",\"sex\":\"女\",\"age\":20}";
//实例化Gson
Gson gson = new Gson();
//把json序列化为实体类（Test）对象
Test test = gson.fromJson(json, Test.class);
//输出---反序列化后的结果为：StudentEntity{name='转换对象', sex='女', age=20}
System.out.println("反序列化成实体类后的结果为："+test.toString());
}注意：
一、把实体类序列化为json时，如果实体类某个属性的值为null，gson在序列化该对象是则默认过滤掉该属性，该属性不会参与序列化。
二、反序列化时需注意json串的格式，如果是数组则最外层是用‘[ ]’来包括的，如果是对象或者是Map则是用‘{ }’来包括的，
根据需要反序列化的json格式来选定需要反序列化用的方法gson.fromJson()应该传递哪种参数，反序列化成对象参数应该是这个对象的反射（entity.Class），如果是List或者是Map，参数则是泛型。
参考网址：
Fastjson
https://github.com/alibaba/fastjson
https://blog.csdn.net/chq88888/article/details/100591317?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduend~default-2-100591317.nonecase&utm_term=json%E5%BA%8F%E5%88%97%E5%8C%96%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D&spm=1000.2123.3001.4430
JackJson
https://attacomsian.com/blog/jackson-create-json-object
https://www.jianshu.com/p/3931b3b6e7b6
https://www.javaguides.net/p/java-jackson-json-tutorial-with-examples.html
Gson
https://blog.csdn.net/weixin_41763995/article/details/88063847
https://github.com/google/gson
https://howtodoinjava.com/gson/gson-serialize-deserialize-json/