Jackson-annotations常用注解

文章目录
  1. 1. 字段命名
  2. 2. 字段包含
  3. 3. 字段文档,元数据
  4. 4. 反序列化和序列化的细节
  • 反序列化细节
  • 序列化细节
  • 原文链接:https://www.dubby.cn/detail.html?id=9071

    字段命名

    • @JsonProperty

      可以指定字段的命名(还可以指定这个字段需要参与序列化和反序列化)。

      • @JsonProperty.value:指定的字段名字
      • @JsonProperty.index:指定顺序,默写数据格式是基于顺序(JSON不是这种数据格式)。
      • @JsonProperty.defaultValue:默认值。注意:这个属性目前为止并没有被core和data-bind使用;制备一些扩展模块使用。

    字段包含

    • @JsonAutoDetect:定义默认的字段包含规则
    • @JsonIgnore:忽略某个指定的字段:
      • 修饰字段,setter和getter中的任何一个,相当于所有都加了
        • 除非使用@JsonProperty修饰,可以实现只忽略序列化或者反序列化
    • @JsonIgnoreProperties:修饰类,指定忽略一个字段列表,或者忽略那些未知的字段
    • @JsonIgnoreType:修饰类,忽略指定的类型的字段
    • @JsonInclude:可以定义空值是否参与(反)序列化

    字段文档,元数据

    • @JsonPropertyDescription:2.3支持,给字段配置人类阅读的解释

    反序列化和序列化的细节

    • @JsonFormat:对于Date/Time字段,可以指定格式化格式
    • @JsonUnwrapped:指定某个字段(类型是POJO)序列化成扁平化,而不是嵌套对象,在反序列化时再包装成对象
    • @JsonView:可以定义视图

    @JsonUnwrapped(prefix = "pre")简单解释:

    1
    2
    3
    4
    5
    6
    7
    public class MyValue {
    public String name;
    JsonUnwrapped(prefix = "pre_", suffix = "_suf")
    public MyValue myValue;
    public int age;
    public Date date;
    }

    序列化结果:

    1
    {"name":"杨正","pre_name_suf":null,"pre_age_suf":0,"pre_date_suf":null,"age":24,"date":"2017-12-09"}

    @JsonView简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    public class JsonViewTest {
    public static void main(String[] args) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    String json = "{\"username\":\"dubby.cn\",\"password\":\"123456\"}";
    //反序列化,使用视图
    User user = objectMapper.readerWithView(User.UserWithoutPassword.class).forType(User.class).readValue(json);
    System.out.println(user);
    user.password = "xxxx";
    //序列化,使用视图
    String result1 = objectMapper.writerWithView(User.UserWithoutPassword.class).writeValueAsString(user);
    System.out.println(result1);
    String result2 = objectMapper.writerWithView(User.UserWithPassword.class).writeValueAsString(user);
    System.out.println(result2);
    }
    }
    class User {
    @JsonView({UserWithoutPassword.class})
    public String username;
    @JsonView({UserWithPassword.class})
    public String password;
    public interface UserWithPassword extends UserWithoutPassword {
    }
    public interface UserWithoutPassword {
    }
    @Override
    public String toString() {
    return "User{" +
    "username='" + username + '\'' +
    ", password='" + password + '\'' +
    '}';
    }
    }

    反序列化细节

    • @JacksonInject:指示某个字段的值是注入的,而不是从JSON中取出的
    • @JsonAnySetter:修饰一个2个参数的方法,任何JSON中有,而对象中没有的字段都会以(key,value)的形式传给这个方法
    • @JsonCreator:上篇文章自定义构造方法介绍过了
    • @JsonSetter:是@JsonProperty的替代注解
    • @JsonEnumDefaultValue:反序列化时,如果遇到未定义的枚举值时,赋值为默认枚举

    @JsonAnySetter简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    public class JsonAnySetterTest {
    public static void main(String[] args) throws IOException {
    String json = "{\"username\":\"dubby.cn\",\"password\":\"123456\",\"x-key\":\"xxx-value\",\"y-key\":\"yyy-value\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    Data data = objectMapper.readValue(json, Data.class);
    System.out.println(data);
    }
    }
    class Data {
    public String username;
    public String password;
    public String other;
    @JsonAnySetter
    public void anySetter(String a, String b) {
    if (other == null) {
    other = "";
    }
    other += a;
    other += ",";
    other += b;
    other += ";";
    }
    @Override
    public String toString() {
    return "Data{" +
    "username='" + username + '\'' +
    ", password='" + password + '\'' +
    ", other='" + other + '\'' +
    '}';
    }
    }

    输出:

    1
    Data{username='dubby.cn', password='123456', other='x-key,xxx-value;y-key,yyy-value;'}

    @JsonEnumDefaultValue简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class EnumTest {
    public static void main(String[] args) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE, true);
    String json = "{\"myEnum\":\"V4\"}";
    EnumData enumData = objectMapper.readValue(json, EnumData.class);
    System.out.println(enumData);
    }
    }
    class EnumData {
    public MyEnum myEnum;
    @Override
    public String toString() {
    return "EnumData{" +
    "myEnum=" + myEnum +
    '}';
    }
    }
    enum MyEnum {
    V1, V2, V3, @JsonEnumDefaultValue Default;
    }

    输出:

    1
    EnumData{myEnum=Default}

    序列化细节

    • @JsonAnyGetter:修饰一个方法,返回Map,这个方法的返回值会被序列化成(key,value)形式
    • @JsonGetter:@JsonPropert的替代注解
    • @JsonPropertyOrder:注定序列化的顺序
    • @JsonRawValue:被修饰的字段“准确”的显示出来,没有转义或装饰,双引号都不加
    • @JsonValue:指定序列化输出的值
    • @JsonRootName:使用这个指定的值作为JSON的根,前提是SerializationFeature.WRAP_ROOT_VALUE已经打开了

    @JsonAnyGetter简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class JsonAnyGetterTest {
    public static void main(String[] args) throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    AnyGetterData data = new AnyGetterData();
    data.data = "http://dubby.cn";
    System.out.println(objectMapper.writeValueAsString(data));
    }
    }
    class AnyGetterData {
    public String data;
    @JsonAnyGetter
    public Map other() {
    Map<String, String> map = new HashMap<>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");
    return map;
    }
    }

    输出:

    1
    {"data":"http://dubby.cn","key1":"value1","key2":"value2","key3":"value3"}

    @JsonPropertyOrder简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class JsonPropertyOrderTest {
    public static void main(String[] args) throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    JsonPropertyOrderData data = new JsonPropertyOrderData();
    data.name1 = "value1";
    data.name2 = "value3";
    data.name3 = "value4";
    System.out.println(objectMapper.writeValueAsString(data));
    }
    }
    @JsonPropertyOrder(value = {"name2", "name3", "name1"})
    class JsonPropertyOrderData {
    public String name1;
    public String name2;
    public String name3;
    }

    输出:

    1
    {"name2":"value3","name3":"value4","name1":"value1"}

    @JsonValue简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    public class JsonValueTest {
    public static void main(String[] args) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    String json ="{\"name2\":\"value3\",\"name3\":\"value4\",\"name1\":\"value1\"}";
    JsonValueData data = objectMapper.readValue(json, JsonValueData.class);
    System.out.println(data.toString());
    System.out.println(objectMapper.writeValueAsString(data));
    }
    }
    class JsonValueData {
    public String name1;
    public String name2;
    public String name3;
    @JsonValue
    public String other() {
    return name1+name2+name3;
    }
    @Override
    public String toString() {
    return "JsonValueData{" +
    "name1='" + name1 + '\'' +
    ", name2='" + name2 + '\'' +
    ", name3='" + name3 + '\'' +
    '}';
    }
    }

    输出:

    1
    JsonValueData{name1='value1', name2='value3', name3='value4'}"value1value3value4"

    @JsonRootName简单解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class JsonRootNameTest {
    public static void main(String[] args) throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
    RootData data = new RootData();
    data.name1 = "value1";
    data.name2 = "value2";
    data.name3 = "value3";
    System.out.println(objectMapper.writeValueAsString(data));
    }
    }
    @JsonRootName(value = "root")
    class RootData {
    public String name1;
    public String name2;
    public String name3;
    }

    输出:

    1
    {"root":{"name1":"value1","name2":"value2","name3":"value3"}}

    如果文章对你有帮助,欢迎点击上方按钮打赏作者