Java 中FastJson的使用【吃透FastJson】

如果不了解JSON格式，建议先看下：JSON数据格式【学习记录】

JSON序列化、反序列化JavaBean的框架有很多，最常见的Jackson、阿里巴巴开源的FastJson、谷歌的GSON、apache提供的json-lib等，下面我们主要来熟悉一下：Java语言中FastJson的使用。

FastJson

FastJson是由阿里巴巴工程师基于Java开发的一款Json解析器和生成器，可用于将Java对象转换为其JSON表示形式，它还可以用于将JSON字符串转换为等效的Java对象。FastJson可以处理任意Java对象，包括没有源代码的预先存在的对象。

FastJson使用十分简便，我们只需要在Maven工程的pom文件中引入以下依赖即可：

<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.73</version>
</dependency>

FastJson API的入口是com.alibaba.fastjson.JSON，常用的序列化操作都可以在JSON类上的静态方法直接完成。

API测试

我们已经在项目中引入了FastJson的依赖，我们再创建一个用户类用于测试：

package com.test.json;import lombok.Data;@Data
public class User {private Integer id;private String name;private String sex;private Integer age;public User(Builder builder) {this.id = builder.id;this.name = builder.name;this.sex = builder.sex;this.age = builder.age;}public static Builder builder() {return new Builder();}public static class Builder {private Integer id;private String name;private String sex;private Integer age;public Builder name(String name) {this.name = name;return this;}public Builder sex(String sex) {this.sex = sex;return this;}public Builder age(int age) {this.age = age;return this;}public Builder id(int id) {this.id = id;return this;}public User build() {return new User(this);}}
}

一、序列化

序列化就是将JavaBean序列化为JSON字符串，下面我们来看下FastJson常见的序列化方法。

下面序列化相关方法都有统一的返回值类型String。

1）toJsonString(Object o);

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();System.out.println(JSON.toJSONString(user));
}

{"age":23,"id":1,"name":"张三","sex":"男"}

我们通过传入一个对象，便可以将对象转成JSON字符串，这里我们传入的不仅仅是JavaBean还可以是一个Map对象，传入Map对象我们同样也可以取到一个JSON字符串。

public static void main(String[] args) {Map<String, Object> userMap = new HashMap<>();userMap.put("id", 1);userMap.put("name", "张三");userMap.put("sex", "男");userMap.put("age", 23);System.out.println(JSON.toJSONString(userMap));
}

{"age":23,"id":1,"name":"张三","sex":"男"}

List对象也很适用，结果是一个标准的JSONArray的字符串。

public static void main(String[] args) {User zhangsan = User.build().id(1).name("张三").sex("男").age(23).build();User lisi = User.build().id(2).name("李四").sex("女").age(18).build();List<User> userList = new ArrayList<>();userList.add(zhangsan);userList.add(lisi);System.out.println(JSON.toJSONString(userList));
}

[{"id":1,"name":"张三","sex":"男","age":23},{"id":2,"name":"李四","sex":"女","age":18}]

2）toJSONString(Object o, boolean prettyFormat);

如果说 toJSONString(Object o); 的输出结果只有单调的一行让你看起来有点吃力，那么我们可以使用 toJSONString(Object o, boolean prettyFormat); 来让输出结果看起来舒服点。

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();System.out.println(JSON.toJSONString(user, true));
}

{"age":23,"id":1,"name":"张三","sex":"男"
}

通过JSON自带的格式化，让输出结果看起来更加清晰，真是贴心~

3）JSON.toJSONString(Object object, SerializerFeature… features);

我们可以看到这个方法里面有个参数SerializerFeature...，可能感到有点陌生，我们先来看下什么是 SerializerFeature ，通过源码可以发现 SerializerFeature 原来是个枚举类：

源码中都被 @deprecated 注释的实例说明已经废弃了，那有哪些是我们平时经常用到的呢：

对象	描述
SerializerFeature.UseSingleQuotes	使用单引号而不是双引号，默认为false
SerializerFeature.PrettyFormat	结果是否格式化，默认为false
SerializerFeature.WriteDateUseDateFormat	如果时间是date、时间戳类型，按照这种格式"yyyy-MM-dd HH:mm"初始化时间
SerializerFeature.WriteMapNullValue	是否输出值为null的字段，默认为false
SerializerFeature.WriteClassName	序列化时写入类型信息，默认为false

使用案例：

• SerializerFeature.UseSingleQuotes

使用单引号而不是使用双引号，默认为false。

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();System.out.println(JSON.toJSONString(user, SerializerFeature.UseSingleQuotes));
}

{'age':23,'id':1,'name':'张三','sex':'男'}

• SerializerFeature.PrettyFormat

结果是否格式化，默认为false。

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();System.out.println(JSON.toJSONString(user));System.out.println("===============");System.out.println(JSON.toJSONString(user, SerializerFeature.PrettyFormat));
}

{"age":23,"id":1,"name":"张三","sex":"男"}
===============
{"age":23,"id":1,"name":"张三","sex":"男"
}

• SerializerFeature.WriteDateUseDateFormat

如果时间是Date、时间戳类型，按照这种格式初始化时间"yyyy-MM-dd HH:mm"。

public static void main(String[] args) {System.out.println(JSON.toJSONString(new Date()));System.out.println("===============");System.out.println(JSON.toJSONString(new Date(), SerializerFeature.WriteDateUseDateFormat));
}

1676427576691
===============
"2023-02-15 10:19:37"

通过这种方式我们将日期输出成了固定的格式：yyyy-MM-dd HH:mm，有时候我们不想得到这种格式那该怎么办？通过下面方法支持自定义时间格式：（注意方法不要用错）

4）toJSONStringWithDateFormat(Object object, String dateFormat, SerializerFeature… features);

public static void main(String[] args) {System.out.println(JSON.toJSONString(new Date()));System.out.println("===============");System.out.println(JSON.toJSONStringWithDateFormat(new Date(), "HH:mm:ss"));
}

1676428350771
===============
"10:32:30"

下面我们接着看SerializerFeature枚举类的其他用法。

• SerializerFeature.WriteMapNullValue

是否输出值为null的字段，默认为false。

这个有什么用处呢？我们应该很清楚开发规范中鼓励用JavaBean传递参数，尽量减少Map传递参数，因为Map相当于一个黑盒，对于使用者来说根本不知道里面存在哪些字段，而对于创建者来说估计也时常会忘记里面存在哪些字段，为了解决这个痛，JSON也推出了解决方法：

public static void main(String[] args) {Map<String, Object> dataMap = new HashMap<>();dataMap.put("name", null);dataMap.put("age", 23);System.out.println(JSON.toJSONString(dataMap));System.out.println("===============");System.out.println(JSON.toJSONString(dataMap, SerializerFeature.WriteMapNullValue));
}

{"age":23}
===============
{"name":null,"age":23}

通过普通方式的 toJSONString() 方法，空值仿佛被吃掉了，这很可能会成为一个开发灾难！

• SerializerFeature.WriteClassName

序列化时写入类信息，默认为false。这个方法可以在反序列化的时候用到，用法如下：

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();System.out.println(JSON.toJSONString(user, SerializerFeature.WriteClssName));
}

{"@type":"com.test.json.User","age":23,"id":1,"name":"张三","sex":"男"}

通过这样我们可以看到我们序列化的对象是什么类型的。

上面这些便是toJSONString的扩展用法，上面说到的是序列化，那么对应的便是反序列化。

二、反序列化

反序列化就是把JSON格式的字符串转换为JavaBean对象。

1）JSONObject parseObject(String text);

public static void main(String[] args){String jsonStr = "{'age':23,'id':1,'name':'张三','sex':'男'}";JSONObject jsonObject = JSON.parseObject(jsonStr);System.out.println(jsonObject.get("name"));
}

张三

用法十分简单，可以将一个标准的JSON字符串转为一个JSONObject对象，由于JSONObject类实现了Map接口，因此我们可以通过get()来获取到值。

我们上述已经说过Map的致命不足，所以我们更希望能得到一个JavaBean对象。

2）<T> T parseObject(String text, Class<T> clazz);

我们通过传入我们想要转换的对象类型，就可以得到我们想要的JavaBean。

public static void main(String[] args){String jsonStr = "{'age':23,'id':1,'name':'张三','sex':'男'}";User user = JSON.parseObject(jsonStr, User.class);System.out.println(user.getName());
}

张三

除了基本反序列化之外，还有一种泛型反序列化可提供使用。

3）<T> T parseObject(String text, TypeReference<T> type, Feature... features);

通过泛型，我们就可以不用传入一个Class对象，而直接获取到我们的JavaBean。

public static void main(String[] args){String jsonStr = "{'age':23,'id':1,'name':'张三','sex':'男'}";User user = JSON.parseObject(jsonStr, new TypeReference<User>(){});System.out.println(user.getName());
}

张三

FastJson序列化还有一个用处那便是进行深克隆。软件设计模式中：原型模式涉及到的深克隆和浅克隆。

浅克隆的实现方式十分简单，我们只需要实现Cloneable接口，然后重写clone()方法：

@Data
class Person {private String name;
}@Data
class NiceCard implements Cloneable {public Person person;public void award() {System.out.println(this.person.getName() + "获得好人卡一张");}public NiceCard clone() throws CloneNotSupportedException {return (NiceCard)super.clone();}
}public class TestClient {public static void main(String[] args) {NiceCard niceCard = new NiceCard();Person person = new Person();person.setName("小李");niceCard.setPerson(person);NiceCard cloneCard = niceCard.clone();Persson clonePerson = cloneCard.getPerson();clonePerson.setName("小王");niceCard.award();cloneCard.award();System.out.println(person == clonePerson);}
}

小王获得一张好人卡
小王获得一张好人卡
true

结果中我们可以看到，好人卡都是属于小王的，这就是浅克隆的弊端了。

我们要想实现深克隆有许多种方式：

• 手动为引用属性赋值
• 借助FastJson
• 使用Java流的序列化对象

方法有很多，我们重点看下FastJson的实现方式：

public static void main(String[] args) {NiceCard niceCard = new NiceCard();Person person = new Person();person.setName("小李");niceCard.setPerson(person);//借助FastJsonNiceCard cloneCard = JSON.parseObject(JSON.toJSONString(niceCard), NiceCard.class);Person clonePerson = cloneCard.getPerson();clonePerson.setName("小王");niceCard.award();cloneCard.award();System.out.println(person == clonePerson);
}

小李获得好人卡一张
小王获得好人卡一张
false

通过FastJson反序列化，我们得到的两个对象实际上是不同的，这也很方便的实现了深克隆。

4）<T> List<T> parseArray(String text, Class<T> clazz);

这是将一个JSON字符串转为JSONArray的方法。

public static void main(String[] args) {String jsonStr = "[{\"id\":1,\"name\":\"张三\",\"sex\":\"男\",\"age\":23},{\"id\":2,\"name\":\"李四\",\"sex\":\"女\",\"age\":18}]";List<User> userList = JSON.parseArray(jsonStr, User.class);userList.forEach(System.out::println);
}

User(id=1, name=张三, sex=男, age=23)
User(id=2, name=李四, sex=女, age=18)

同样我们也可以通过使用泛型序列化来实现同样的功能：

5）List<Object> parseArray(String text, Type[] types);

public static void main(String[] args) {String jsonStr = "[{\"id\":1,\"name\":\"张三\",\"sex\":\"男\",\"age\":23},{\"id\":2,\"name\":\"李四\",\"sex\":\"女\",\"age\":18}]";Type type = new TypeReference<User>() {}.getType();JSON.parseArray(jsonStr, new Type[]{type, type}).forEach(System.out::println);
}

这种方式有个坑就是：我们使用parseArray()这个方法的时候第二个参数需要传入我们要反序列化的对象类型，但是我们这里需要传入的是数组，不知道你有没有为数组里面放了两个一样的type感到奇怪？没错，这就是方法的坑，我们List里面有多少个对象，Type[]这个数组里面的个数要与之匹配，不然会抛出以下错误：

上述JSON串中对象的类型都为User，如果JSON串中存在不同的类型时：

public static void main(String[] args) {String jsonStr = "[{\"id\":1,\"name\":\"张三\",\"sex\":\"男\",\"age\":23},{\"stuName\":\"李四\"}]";Type userType = new TypeReference<User>() {}.getType();Type studentType = new TypeReference<Student>() {}.getType();JSON.parseArray(jsonStr, new Type[]{userType,studentType}).forEach(System.out::println);
}

User(id=1, name=张三, sex=男, age=23)
Student(stuName=李四)

如果将userType和studentType调换顺序，则结果：

Student(stuName=null)
User(id=null, name=null, sex=null, age=null)

三、JavaBean转换为Byte[]

1）toJSONBytes(Object o)

我们平时在进行网络通讯的时候，需要将对象转为字节然后进行传输。我们使用字符串的时候，字符串中有个很便捷的API可以将字符串转为字节数组。

String str = "张三";
byte[] bytes = str.getBytes();

但是我们要将一个JavaBean对象转为字节数组的时候，我们得借助ByteArrayOutputStream流的帮助。

public static void main(String[] args) {byte[] bytes = null;ByteArrayOutputStream bos = new ByteArrayOutputStream();try{ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(obj);oos.flush();bytes = bos.toByteArray();oos.close();bos.close();} catch(IOException ex) {ex.printStackTrace();}
}

这种方式也可以很好的将JavaBean对象转为字节数组，但是代码不免有点多了！而FastJson中野提供了很方便的API以供使用。

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();//JavaBean对象转为字节数组byte[] bytes = JSON.toJSONBytes(user);
}

我们要将字节数组转为对象，FastJson也同样支持：

public static void main(String[] args) {User user = User.builder().id(1).name("张三").sex("男").age(23).build();//JavaBean对象转为字节数组byte[] bytes = JSON.toJSONBytes(user);//将字节数组转为JavaBean对象Object obj = JSON.parseObject(bytes, User.class, Feature.IgnoreNotMatch);System.out.println(obj);
}

//待更新…