在Springboot + Mybaitis-plus 項目中利用Jackson實現json對java多態的（反）序列化

Jackson容許配置多態類型處理，當JSON面對的轉換對象是一個接口、抽象類或者一個基類的時候，能夠經過必定配置實現JSON的轉換。在實際項目中，Controller層接收入參以及在Dao層將對象以json的形式存入數據庫時均可能會遇到這個問題。而Springboot和mp都支持使用Jackson處理json，從而能夠利用Jackson的特色，解決這一問題。

注意

爲了代碼簡潔，這裏的代碼忽略了set和get方法和構造函數

在本例中，父類Zoo有兩個子類Dog和Cat類

public static class Zoo {
  
    private String name;
    private AnimalTypeEnum animalType;
  
}

父類Zoo中，包含一個表明動物種類的枚舉字段

public enum AnimalTypeEnum {
    DOG("dog"),
    CAT("cat");
    private final String name;
}

對於子類Dog包含一個速度屬性

public static class Dog extends Zoo {
    private Double speed;
}

對於子類Cat包含一個尺寸屬性

public static class Cat extends Zoo {
    private Integer size;
}

咱們想作的事情是根據Zoo中的動物類型枚舉字段animalType，將JSON反序列化爲兩種子類

方法一

使用Jackson提供的處理註解能夠實現上述功能

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        property = "animalType",
        visible = true
)
@JsonSubTypes(
        {
                @JsonSubTypes.Type(value = Dog.class, name = "DOG"),
                @JsonSubTypes.Type(value = Cat.class, name = "CAT")
        }
)
public static class Zoo {
  
    private String name;
    private AnimalTypeEnum animalType;
  
}

@JsonTypeInfo()

該註解表示對該類開啓多態類型處理，包含四個屬性

use 表明使用哪種類型識別碼

JsonTypeInfo.Id.NAME 是本例中選擇的類型識別碼，意指一個指定的名字

include表明識別碼是如何包含進JSON

JsonTypeInfo.As.EXISTING_PROPERTY 表明POJO中存在的類型
property 指定類型表示碼的屬性名稱

"animalType" 就是POJO中的類型字段名
visible 表明類型標識符是否會進入反序列化，默認false

因爲這裏咱們一樣須要該字段反序列化，因此設置爲true

@JsonSubTypes()

該註解用於給出給定類的子類

@JsonSubTypes.Type[]數組中給出了多態類和property中指定屬性某個值之間的綁定關係。在上例中，Dog類和animalType = DOG的值進行了綁定

在父類Zoo上加入如上註解以後，便可實現多態反序列化

對應測試

public void method1Test() throws JsonProcessingException {

    ObjectMapper objectMapper = new ObjectMapper();
    Cat cat = new Cat("小貓", AnimalTypeEnum.CAT, 20);
    Dog dog = new Dog("小狗", AnimalTypeEnum.DOG, 30.03);

    String catJson = objectMapper.writeValueAsString(cat);
    String dogJson = objectMapper.writeValueAsString(dog);

    log.debug(catJson);
    log.debug(dogJson);

    //反序列化
    Zoo catZoo = objectMapper.readValue(catJson, Zoo.class);
    Zoo dogZoo = objectMapper.readValue(dogJson, Zoo.class);

    //類型一致
    assertEquals(catZoo.getClass(),cat.getClass());
    assertEquals(dogZoo.getClass(),dog.getClass());

    //參數值一致
    assertEquals(20,((Cat)catZoo).getSize());
    assertEquals(30.03,((Dog)dogZoo).getSpeed());

}

能夠看到，通過添加註解能夠實現咱們的需求

這樣無論是springboot仍是mybaitis-plus進行反序列化的時候，都經過註解的信息按照咱們的要求進行反序列化

方法二

在項目中，一個基類會有不少的子類，而且隨着項目的深刻，子類可能會愈來愈多。使用上面的方法，須要不停的添加@JsonSubTypes中的內容，十分繁瑣。這種寫法是 違反開閉原則（OCP）的。

經過閱讀源碼，咱們能夠看到，其多態處理的基本原理就是將子類何其對應的名稱之間的綁定關係註冊到ObjectMapper中。

方法二的思路是給每一個子類增長一個註解@JsonTypeName(value = "")，而後經過掃描全部帶有註解的類，將全部帶有標記的類註冊到ObjectMapper中。

在Springboot中自定義ObjectMapper有不少辦法，能夠參考在SpringBoot中自定義 Jackson的ObjectMapper

首先生成一個ObjectMapper 的bean

@Configuration
public class ObjectMapperConfig {
    @Bean
    @Primary
    //使這個bean優先被注入
    public ObjectMapper objectMapper() {

        ObjectMapper objectMapper = new ObjectMapper();
      
        //使用reflection框架，獲取本包下的全部帶有@JsonTypeName的註解
        Reflections reflections = new Reflections("cn.");
        Set<Class<?>> classSet = reflections.getTypesAnnotatedWith(JsonTypeName.class);
        //將這個上面掃描獲得的類註冊進這個ObjectMapper中
        objectMapper.registerSubtypes(classSet);
      
        //這裏是將咱們定義好的objectMapper set 進 Mybaitis-plus的Jackson處理器中，從而使得MP也能夠				順利的進行反序列化
        JacksonTypeHandler.setObjectMapper(objectMapper);
        return objectMapper;
    }
}

父類只須要添加這樣一個註解

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        property = "animalType",
        visible = true
)
public static class Zoo {
  
    private String name;
    private AnimalTypeEnum animalType;
  
}

子類添加註解

@JsonTypeName("DOG")
public static class Dog extends Zoo {
    private Double speed;
}

方法三

在咱們的場景中，分類標識符是一個枚舉類型。所以，咱們但願將全部的子類和標識符名稱對應的信息所有放在該枚舉類中，使得僅經過枚舉類就能夠綁定好全部子類和名稱之間的關係。

定義一個接口和註解，並在接口上使用了這個註解

@JsonSubTypeEnum.JsonSubTypeAnnotation
public interface JsonSubTypeEnum {
 
    Class<?> getJsonType();

    @Documented
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface JsonSubTypeAnnotation {
    }
}

這個接口定義了一個獲取子類類信息的方法

public enum AnimalType implements JsonSubTypeEnum {
    DOG(Dog.class),
    CAT(Cat.class),
    ;
    private final Class<? extends Animal> animalClass;

    @Override
    public Class<?> getJsonType() {
        return this.animalClass;
    }
}

讓須要用於分類的枚舉實現這個接口，枚舉中的animalClass屬性，用來記錄該標識符對應的子類的類別。

再來看ObjectMapper bean

@Bean
@Primary
public static ObjectMapper getObjectMapper(){
    ObjectMapper objectMapper = new ObjectMapper();
    Reflections reflections = new Reflections("com.");
  //獲取全部帶有自定義註解的類
    Set<Class<?>> classSet = reflections.getTypesAnnotatedWith(JsonSubTypeEnum.JsonSubTypeAnnotation.class)；
    //將其中的枚舉類拿出來處理
      for (Class<?> enumTyp : classSet) {
        if (!enumTyp.isEnum()) {
            continue;
        }
        final Object[] enumConstants = enumTyp.getEnumConstants();
        for (Object e : enumConstants) {
            if (e instanceof JsonSubTypeEnum) {
                //將每一個子類和標識符綁定註冊進入objectMapper
                final Class<?> subType = ((JsonSubTypeEnum) e).getJsonType();
                final String name = ((Enum<?>) e).name();
                objectMapper.registerSubtypes(new NamedType(subType, name));
            }
        }
    }
         //這裏是將咱們定義好的objectMapper set 進 Mybaitis-plus的Jackson處理器中，從而使得MP也能夠				順利的進行反序列化
   JacksonTypeHandler.setObjectMapper(objectMapper);
   return objectMapper;
}