Java中的RPC（遠程服務調用）可以通過序列化的方式進行。

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的解決方案：

首先在MAVEN 中加入ckson-datatype-jsr310依賴。

<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

配置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的主要類:

JSON：FastJson解析器，用于JSON格式字符串與JSON對象以及javaBean之間轉換。
JSONObject：FastJson提供的json對象。
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);

JSONObject到JSON的轉換；
String toJSONString = JSONObject.toJSONString(object);

JSONObject和JSON的轉換

2.3.2 數組對象型——JSON和JSONArray轉換

JSON到JSONArray的轉換；
JSONArray jsonArray = JSONArray.parseArray(ARR_JSON);
需要注意的是JSONArray實現了List<Object>接口。

JSONArray到JSON的轉換；
String string = jsonArray.toJSONString();

2.3.3 如何操作JSONObject對象

獲取JSONObject里面的JSONObject對象；
jsonObject.getJSONObject("course");

獲取JSONObject里面的JSONArray對象；
jsonObject.getJSONArray("students");

獲取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[]時如何指定各個數據項的數據類型

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

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

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

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

1.1 Jackson的API

1.2 Jackson源碼分析

1.2.1 源碼

1.2.2 源碼分析

1.3 Jackson序列化工具類

2. FastJson 序列化

2.1 FastJson的API

2.2 FastJson的準備工作

2.3 JSON字符串和JSONObject或JSONArray之間的轉換

2.3.1 JSON字符串和JSONObject之間的轉換

2.3.2 數組對象型——JSON和JSONArray轉換

2.3.3 如何操作JSONObject對象

2.4 JSON字符串和JavaBean之間的轉換

2.4.1 JSON轉化為Object（TypeReference方式）

2.4.1.1 TypeRefrence進行反序列化

2.4.1.2 TypeRefrence源碼分析

2.4.2 JSON轉化為Object（Class方式）

2.4.3 JSON轉化為Object集合對象

2.4.4 Object轉化為（自定義格式）的JSON

2.5 JSON轉化為Object到底采用哪種方式

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

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

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

1.1 Jackson的API

1.2 Jackson源碼分析

1.2.1 源碼

1.2.2 源碼分析

1.3 Jackson序列化工具類

2. FastJson 序列化

2.1 FastJson的API

2.2 FastJson的準備工作

2.3 JSON字符串和JSONObject或JSONArray之間的轉換

2.3.1 JSON字符串和JSONObject之間的轉換

2.3.2 數組對象型——JSON和JSONArray轉換

2.3.3 如何操作JSONObject對象

2.4 JSON字符串和JavaBean之間的轉換

2.4.1 JSON轉化為Object（TypeReference方式）

2.4.1.1 TypeRefrence進行反序列化

2.4.1.2 TypeRefrence源碼分析

2.4.2 JSON轉化為Object（Class方式）

2.4.3 JSON轉化為Object集合對象

2.4.4 Object轉化為（自定義格式）的JSON

2.5 JSON轉化為Object到底采用哪種方式

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频