Jackson序列化&&FastJson序列化API使用

Java中的RPC（远程服务调用）可以通过序列化的方式进行。

JDK英文文档，墙裂不推荐看中文！！！

1. Jackson 进行JSON的解析和序列化

1.1 Jackson的API

ObjectMapper的API文档

1 需要注意的是：

  • ObjectMapper是JSON操作的核心，Jackson的JSON操作都是在ObjectMapper中实现的。
  • ObjectMapper有多个JSON序列化的方法，可以把JSON串保存在File、OutputStream等不同的介质中。

2 Jackson的API：`

  • writeValue(File resultFile, Object value)可以用于所有Java值的序列化，将JSON输出到File中。

  • writeValue(OutputStream out, Object value) 可以用于所有Java对象的序列化，并将JSON串保存到流中。注意，此方法不会显示的关闭流。

  • writeValueAsString(Object value)可以用于任何Java对象的序列化方式，并输出字符串。等效于writeValue（Writer，Object) 并构造String，但是效率更高。

  • writeValueAsBytes(Object value)可用于任何Java对象的序列化方式，并输出byte[]数组。等效于writeValue（Writer，Object) 并得到byte[]数组，注意数组的编码是UTF-8；

  • <T> T readValue(String content, Class<T> valueType)注意，我们在传入Class<T>对象，注意一般是传入Class<?>，因为Class类中并不使用泛型对象，但是此处使用泛型对象，因为我们的返回值就是T，避免了类型强转。温故知新——泛型实践篇

3. Jackson提供的注解
Jackson提供了一系列的注解，方便对JSON序列化和反序列化进行控制，下面介绍一些常用的注解：

  • JsonIgnore 此注解用于属性上，作用是Json操作时，忽略该属性。
  • JsonFormat 此注解用于属性上， 作用是把Date类型转化成为想要的格式。
  • JsonProperty 此注解用于属性上，作用是把改属性的名称序列化成另一个名称。
  • JsonSerialize 此注解用于属性上，作用是指定属性序列化的类型。
  • JsonDeserialize 此注解用于属性上，作用是指定属性反序列化的类型。

1.2 Jackson源码分析

1.2.1 源码

1. 引入MAVEN依赖：

     <!--Jackson的API-->
      <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.4</version>
        </dependency>
      <!--JDK1.8时间类序列化-->
      <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
      </dependency>

2. 实体类

public class User implements Serializable {

    private String name;
    private List<String> sports;
    //序列化格式
    //@JsonSerialize(using = LocalDateSerializer.class)
    //反序列化格式
    //@JsonDeserialize(using = LocalDateDeserializer.class)
    //Json格式
    //@JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate date;
   //节省篇幅，省略get/set方法
}

3. 测试类：

public static void main(String[] args) {
        //创建用户对象
        User user = new User();
        user.setName("小胖");
        List sports = new ArrayList<>();
        sports.add("足球");
        sports.add("游泳");
        user.setSports(sports);
        user.setDate(LocalDate.now());
        //创建对象
        //Json序列化和反序列化
        ObjectMapper mapper = new ObjectMapper();
//        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
//        mapper.registerModule(new JavaTimeModule());
        //User转化为Json
        try {
            //对象转化为Json数据
            String s = mapper.writeValueAsString(user);
            System.out.println("s：" + s);
            //Json转化为对象
            User user1 = mapper.readValue(s, User.class);
            System.out.println(user1.toString());
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

注意点：Jackson序列化对象时，对象必须实现getXxx方法。但是对象中若存在普通方法以get开头，那么在序列化时，也会将该方法进行序列化。此时需要在方法上添加@JsonIgnore注解。

public class School {

    @JsonIgnore
    public String getData(){
        User user = new User();
        return user.getFields().get(0);
    }
}

1.2.2 源码分析

首先注意的是JDK1.8中时间类，采用了一套新的API。

在这里我们采用是LocalDate类，若是User类中，没有使用注解，那么序列化结果为：

{
    "name": "小胖",
    "sports": ["足球", "游泳"],
    "date": {
        "year": 2019,
        "month": "MARCH",
        "chronology": {
            "id": "ISO",
            "calendarType": "iso8601"
        },
        "dayOfMonth": 27,
        "dayOfWeek": "WEDNESDAY",
        "dayOfYear": 86,
        "era": "CE",
        "monthValue": 3,
        "leapYear": false
    }
}

显然，这不是我们预期的Json串。并且，我们在反序列化过程中，会出现异常：

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of java.time.LocalDate (no Creators, like default construct, exist):
cannot deserialize from Object value (no delegate- or property-based Creator)
at [Source: (String)"{"name":"小胖","sports":["足球","游泳"],"date":{"year":2019,"month":"MARCH","chronology":{"id":"ISO","calendarType":"iso8601"},"dayOfMonth":27,"dayOfWeek":"WEDNESDAY","dayOfYear":86,"era":"CE","monthValue":3,"leapYear":false}}"; line: 1, column: 43] (through reference chain: com.JsonSerializer.User["date"])

大概意思：就是LocalDate的没有参数是Object的构造函数。不能实例化对象。

华丽的分割线SpringBoot的处理

SpringBoot的解决方案：

  1. 首先在MAVEN 中加入ckson-datatype-jsr310依赖。
<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
  1. 配置Configuration中的ObjectMapper。
@Bean
public ObjectMapper serializingObjectMapper() {
  ObjectMapper objectMapper = new ObjectMapper();
  objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  objectMapper.registerModule(new JavaTimeModule());
  return objectMapper;
}

Java bean的解决方案：
在Java Bean中使用注解，就可以进行反序列化和序列化。

    //序列化格式
    @JsonSerialize(using = LocalDateSerializer.class)
    //反序列化格式
    @JsonDeserialize(using = LocalDateDeserializer.class)
    //Json格式
    @JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate date;

执行结果：

Jackson序列化和反序列化的结果

1.3 Jackson序列化工具类

为了便于使用Jackson进行序列化操作，故实现该工具类：

@Slf4j
public class JacksonUtils {

    private static ObjectMapper objectMapper = new ObjectMapper();


    /**
     * 将对象序列化为JSON
     */
    public static <T> String toJSONString(T obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.error("序列化失败", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * @param str   反序列化的JSON串
     * @param clazz 反序列化的目标对象
     */
    public static <T> T parseObject(String str, Class<T> clazz) {
        try {
            return objectMapper.readValue(str, clazz);
        } catch (IOException e) {
            log.error("反序列化失败", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 带泛型的反序列化
     *
     * @param str  待序列化的字符串
     * @param type {@code new TypeReference<List<Student>>(){}}
     * @param <T>  泛型对象
     * @return 序列化为泛型对象
     */
    public static <T> T parseObject(String str, TypeReference<T> type) {
        try {
            return objectMapper.readValue(str, type);
        } catch (JsonProcessingException e) {
            log.error("反序列化失败", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 验证字符串是否为JSON格式。
     * <p>
     * 注意：该方法是比较简易的判断，只是判断字符串以什么开头。
     *
     * @param str 待验证的字符串
     * @return true:为JSON格式，false不为JSON格式
     */
    public static boolean validateJSON(String str) {
        return str.startsWith("{") || str.startsWith("[");
    }

}

2. FastJson 序列化

2.1 FastJson的API

FastJson是性能极好的JSON解析器和生成器。

1. FastJson的优点：

  • 速度快：超越其他任何java json parser
  • 功能强大：支持Java Bean、Collection、Map、日期、枚举、支持泛型和自省。
  • 零依赖：只依赖于JDK。

2. FastJson的主要类:

  1. JSON：FastJson解析器，用于JSON格式字符串与JSON对象以及javaBean之间转换。
  2. JSONObject：FastJson提供的json对象。
  3. JSONArray：FastJson提供的json数组对象。

2.2 FastJson的准备工作

1. FastJson的MAVEN依赖：

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

2. JSON准备：

    private static final String OBJ_JSON = "{\"studentName\":\"lily\",\"studentAge\":12}";
    private static final String ARR_JSON = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
    private static final String COMPLEX_JSON = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";

ARR_JSON格式：

[{
    "studentName": "lily",
    "studentAge": 12
}, {
    "studentName": "lucy",
    "studentAge": 15
}]

COMPLEX_JSON格式：

{
    "teacherName": "crystall",
    "teacherAge": 27,
    "course": {
        "courseName": "english",
        "code": 1270
    },
    "students": [{
        "studentName": "lily",
        "studentAge": 12
    }, {
        "studentName": "lucy",
        "studentAge": 15
    }]
}

2.3 JSON字符串和JSONObject或JSONArray之间的转换

我们日常操作是：JSON字符串和JavaBean对象之间的转换。但是为什么存在JSONObject或者JSONArray对象呢？因为我们不想为每一个JSON字符串都创建一个Bean对象，但是我们还是想像对象一样操作JSON串时。就可这样操作

2.3.1 JSON字符串和JSONObject之间的转换

1 JSON到JSONObject的转换；
JSONObject object = JSONObject.parseObject(OBJ_JSON);

  1. JSONObject到JSON的转换；
    String toJSONString = JSONObject.toJSONString(object);
JSONObject和JSON的转换

2.3.2 数组对象型——JSON和JSONArray转换

  1. JSON到JSONArray的转换；
    JSONArray jsonArray = JSONArray.parseArray(ARR_JSON);
    需要注意的是JSONArray实现了List<Object>接口。
  2. JSONArray到JSON的转换；
    String string = jsonArray.toJSONString();

2.3.3 如何操作JSONObject对象

  1. 获取JSONObject里面的JSONObject对象；
    jsonObject.getJSONObject("course");
  2. 获取JSONObject里面的JSONArray对象；
    jsonObject.getJSONArray("students");
  3. 获取JSONObject里面的String或基本数据类型；
    jsonObject.getXXX("students"); 
  public static void main(String[] args) {
        JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON);
        //获取JSON中的参数
        jsonObject.getString("teacherName");
        //获取JSON中的对象
        jsonObject.getJSONObject("course");
        //获取JSON中数组
        jsonObject.getJSONArray("students");
        //JSON转换为Object
        String jsonString = jsonObject.toJSONString();
        System.out.println("序列化后的对象"+jsonString);
    }

2.4 JSON字符串和JavaBean之间的转换

JSON和JavaBean之间的转化，其实是将转化Bean的class对象传入即可。

    public static <T> T parseJWT2Sub(String token, Class<T> clazz) {
        SecretKey key = obtainKey();
        Claims body = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
        return JSON.parseObject(body.getSubject(), clazz);
    }

2.4.1 JSON转化为Object（TypeReference方式）

在FastJson中提供了一个可用来处理泛型反序列化的类TypeRefernce。

2.4.1.1 TypeRefrence进行反序列化

通过设置new TypeReference<Teacher<String>>() {}；，JSON字符串反序列化成Teacher对象会保留泛型<String>；

使用方式：github的使用文档

1. 通过TypeReference处理泛型对象

     Teacher<String> teacher = JSONObject.parseObject(COMPLEX_JSON, new TypeReference<Teacher<String>>() {
        });

2. 使用getType()可以获取更好的性能。

        Type type = new TypeReference<Teacher<String>>() {
        }.getType();
        Teacher<String> teacher = JSONObject.parseObject(COMPLEX_JSON, type);

2.4.1.2 TypeRefrence源码分析

1. TypeRefrence部分源码分析：

public class TypeReference<T> {
    static ConcurrentMap<Type, Type> classTypeCache = new ConcurrentHashMap(16, 0.75F, 1);
    protected final Type type;
    public static final Type LIST_STRING = (new TypeReference<List<String>>() {
    }).getType();

    protected TypeReference() {
        Type superClass = this.getClass().getGenericSuperclass();
        Type type = ((ParameterizedType)superClass).getActualTypeArguments()[0];
        Type cachedType = (Type)classTypeCache.get(type);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(type, type);
            cachedType = (Type)classTypeCache.get(type);
        }

        this.type = cachedType;
    }

    public Type getType() {
        return this.type;
    }

为什么这里的构造方法要是protected的，即我们无法直接创建该对象，只能使用匿名类创建子类对象。

getGenericSuperclass()的API方法

public Type getGenericSuperclass();

  • Returns the Type representing the direct superclass of the entity (class, interface, primitive type or void) represented by this Class.
  • If the superclass is a parameterized type, the Type object returned must accurately reflect the actual type parameters used in the source code.

返回Class对象（类，接口，基本数据类型，void）的直接父类的Type类型。
如果父类是parameterized [pə'ræmɪtəraɪzd]类型（也可以理解为父类是泛型对象），那么返回的参数类型是父类的泛型类型。

基本原理：

  • 类型擦除是擦除的方法中Code字节码，但是会把泛型类型保存在Signature中，不能通过反射直接获取，但是可以通过子类获取父类的泛型类型。

  • 类型擦除不会将元数据（即类结构）上的泛型擦除，还是可以通过反射直接获取。复习盘点——泛型擦除。

  • 可以通过匿名内部类的方式获取子类，在这里，推荐使用protected构造方法，创建匿名类。复习盘点——内部类

2.4.2 JSON转化为Object（Class方式）

不保留泛型的反序列化。

使用public static <T> T parseObject(String text, Class<T> clazz)方法，边可完成JSON的反序列化。

1. 特殊JSON反序列化

需要注意的是，若是text为null的情况下，最后反序列化的结构也是为null

 public static void main(String[] args) {
        UserPO userPO = JSON.parseObject(null, UserPO.class);
        System.out.println(userPO);    //若是null，反序列化对象也是null
        UserPO userPO1 = JSON.parseObject("", UserPO.class);
        System.out.println(userPO1);  //若是空串，抛出异常
        UserPO userPO2 = JSON.parseObject("{}", UserPO.class);
        System.out.println(userPO2);  //若是空JSON，返回空对象
    }

2. 泛型丢失

Teacher teacher = JSONObject.parseObject(COMPLEX_JSON, Teacher.class);

我们可以看到，因为返回值需要泛型类型T所以我们采用的是Class<T>，防止返回Object对象，让用户强转。但需要注意：这种方式在反序列化的时候，会丢失泛型类型。

2.4.3 JSON转化为Object集合对象

方式一：TypeReference

//获取数组对象的List<Student>的Type
Type type = new TypeReference<ArrayList<Student>>() {
}.getType();

List<Student> list = JSONObject.parseObject(ARR_JSON, type);
System.out.println(list);

方式二：使用parseArray

    List<Student> students = JSONObject.parseArray(ARR_JSON, Student.class);

2.4.4 Object转化为（自定义格式）的JSON

我们通过：fastjson如何json数组串转换为Object[]时如何指定各个数据项的数据类型引出fastjson SerializerFeature对象

我们可以通过这个API，完成Bean对象转换成String类型。
String toJSONString(Object object, SerializerFeature... features)

SerializerFeature模式的使用
  Student stu = new Student();
        stu.setStudentAge(null);
        stu.setStudentName("黎明");
        String toJSONString = JSONObject.toJSONString(stu,
                SerializerFeature.PrettyFormat,
                SerializerFeature.WriteNullStringAsEmpty,  //如果字符串是空，那么返回""，而非不返回
                SerializerFeature.WriteNullNumberAsZero,  //如果字符串是空，那么返回0，而不是不返回、
                SerializerFeature.WriteClassName,     //序列化时写入类型信息，反序列化时用到
                SerializerFeature.DisableCircularReferenceDetect); //消除对同一对象循环引用问题。
        System.out.println(toJSONString);
SerializerFeature序列化方式

2.5 JSON转化为Object到底采用哪种方式

在项目中，一般都是使用JSON进行数据的传输。那么通常采用Class方式还是TypeRefrence方式进行反序列化呢？

1. JSON转化为简单对象

若是对象的属性只是简单数据类型（基本数据类型，或者String类型）那么可以使用Class方式转化为Object对象。

JSON.parseObject(dataInfo.getData(), Order.class);

2. JSON转化为复杂对象

若是一个对象里面的属性依旧是一个对象，那么我们就可以使用TypeRefrence进行转换。

public class ApiResponseVo<T> {
    private String subCode;
    private String subMsg;
    private String count;
    private List<T> list;
    //省略 getter、setter方法
}

我们在将JSON转换为对象的时候，就可以保留List<T>的泛型。即：

ApiResponseVo<Order> apiResponseVo=
JSON.parseObject(dataInfo.getData(), new TypeReference<ApiResponseVo<Order>>(){});

参考文章：
Java下利用Jackson进行JSON解析和序列化

使用FastJson处理JSON数据

fastjson如何json数组串转换为Object[]时如何指定各个数据项的数据类型

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,013评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,205评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,370评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,168评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,153评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,954评论 1赞 283
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,271评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,916评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,382评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,877评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,989评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,624评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,209评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,199评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,418评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,401评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,700评论 2赞 345