fastjson反序列化泛型类

为了代码通用，你的定义对象可能是一个泛型对象，其中可变的data属性的类型参数化。那么这个泛型类型的对象，反json化时应该注意些什么呢？

1. Response类型

    public static class Response<T> {
           private String msg;
           private String code;
           private T data;
   
           public String getMsg() {
               return msg;
           }
   
           public void setMsg(String msg) {
               this.msg = msg;
           }
   
           public String getCode() {
               return code;
           }
   
           public void setCode(String code) {
               this.code = code;
           }
   
           public T getData() {
               return data;
           }
   
           public void setData(T data) {
               this.data = data;
           }
   
           @Override
           public String toString() {
               return "Response{" +
                       "msg='" + msg + '\'' +
                       ", code='" + code + '\'' +
                       ", data=" + data +
                       '}';
           }
       }
   
   //额外的pojo类
   public static class User {
           private String name;
           private String id;
   
           public User() {
           }
   
           public User(String name, String id) {
               this.name = name;
               this.id = id;
           }
   
           public String getName() {
               return name;
           }
   
           public void setName(String name) {
               this.name = name;
           }
   
           public String getId() {
               return id;
           }
   
           public void setId(String id) {
               this.id = id;
           }
   
           @Override
           public String toString() {
               return "User{" +
                       "name='" + name + '\'' +
                       ", id='" + id + '\'' +
                       '}';
           }
       }
   
       public static class Student {
           private String nickname;
           private int age;
   
           @Override
           public String toString() {
               return "Student{" +
                       "nickname='" + nickname + '\'' +
                       ", age=" + age +
                       '}';
           }
   
           public Student() {
           }
   
           public Student(String nickname, int age) {
               this.nickname = nickname;
               this.age = age;
           }
   
           public String getNickname() {
               return nickname;
           }
   
           public void setNickname(String nickname) {
               this.nickname = nickname;
           }
   
           public int getAge() {
               return age;
           }
   
           public void setAge(int age) {
               this.age = age;
           }
       }
   

2. 假如你有如下两个jsonstring, 那么你该如何反json化成具体的Response对象呢？

   //1
   {
     "msg": "success",
     "code": "000000",
     "data": {
       "name": "java",
       "id": "123"
     }
   }
   //2
   {
     "msg": "success",
     "code": "000000",
     "data": {
       "nickname": "mars",
       "age": 15
     }
   }
   

3. 使用fastjson

       public static void main(String[] args) {
           
           String json2 = "{\"msg\":\"success\",\"code\":\"000000\",\"data\":{\"name\":\"java\",\"id\":\"123\"}}";
           //JSON.parseObject(json2,Response<User>.class);  //由于Java的泛型-类型擦除，这么些是不行的
           Response response1 = JSON.parseObject(json2, Response.class);  //这样虽然可以反json成功，但其中的data就被转成了Object类型
           System.out.println(response1);
           System.out.println(JSON.toJSONString(response1));
       }
   

   //运行结果
   Response{msg=‘success’, code=‘000000’, data={“name”:“java”,“id”:“123”}}
   {“code”:“000000”,“data”:{“name”:“java”,“id”:“123”},“msg”:“success”}

4. 能否强制转换为User对象呢

   public static void main(String[] args) {
           
           String json2 = "{\"msg\":\"success\",\"code\":\"000000\",\"data\":{\"name\":\"java\",\"id\":\"123\"}}";
           //JSON.parseObject(json2,Response<User>.class);  //由于Java的泛型-类型擦除，这么些是不行的
           Response response1 = JSON.parseObject(json2, Response.class);  //这样虽然可以反json成功，但其中的data就被转成了Object类型
           System.out.println(response1);
       	User data = (User) response1.getData();
           System.out.println(data.getName());
           System.out.println(JSON.toJSONString(response1));
       }
   

   //运行结果
   Response{msg=‘success’, code=‘000000’, data={“name”:“java”,“id”:“123”}}
   Exception in thread “main” java.lang.ClassCastException: com.alibaba.fastjson.JSONObject cannot be cast to com.common.json.JsonTest$User
   at com.common.json.JsonTest.main(JsonTest.java:30)

   显然不行

5. 那么如何反json这种泛型对象呢？——TypeReference

package com.common.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;

public class JsonTest {
    /*
    泛型类序列化
     */

    public static void main(String[] args) {
        
        String json2 = "{\"msg\":\"success\",\"code\":\"000000\",\"data\":{\"name\":\"java\",\"id\":\"123\"}}";
        Response<User> response = parseData(json2, new TypeReference<Response<User>>() {
        });
        System.out.println(response);
        System.out.println(JSON.toJSONString(response));

        String json3 = "{\"msg\":\"success\",\"code\":\"000000\",\"data\":{\"nickname\":\"mars\",\"age\":15}}";
        Response<Student> studentResponse = parseData(json3, new TypeReference<Response<Student>>() {
        });
        System.out.println(studentResponse);
        System.out.println(JSON.toJSONString(studentResponse));
    }

    //通用反序列化方法
    public static <Z> Z parseData(String jsonStr, TypeReference<Z> reference) {
        Z z = JSONObject.parseObject(jsonStr, reference);
        return z;
    }
}

1. 总结
   1. TypeReference可以完成泛型类的反json化；
   2. 如果泛型类中有多个类型参数呢？又改如何处理呢？哈哈，留着以后遇到再总结。