精华内容
下载资源
问答
  • jackson注解

    2017-07-13 14:26:52
    Jackson注解 Jackson(http://jackson.codehaus.org)库是基于java语言的开源json格式解析工具。相对于javajson解析的其他库,诸如json-lib、gson包,Jackson具有以下优点: 功能全面,提供多种模式的json...
     
    

    Jackson(http://jackson.codehaus.org)库是基于java语言的开源json格式解析工具。相对于javajson解析的其他库,诸如json-lib、gson包,Jackson具有以下优点:

    功能全面,提供多种模式的json解析方式,“对象绑定”使用方便,利用注解包能为我们开发提供很多便利。

    性能较高,“流模式”的解析效率超过绝大多数类似的json包。

    jackson主要的包

    jackson-core——核心包(必须),提供基于“流模式”解析的API。核心包:JsonPaser(json流读取),JsonGenerator(json流输出)。

    jackson-databind——数据绑定包(可选),提供基于“对象绑定”和“树模型”相关API。数据绑定包:ObjectMapper(构建树模式和对象绑定模式),JsonNode(树节点)。

    jackson-annotations——注解包(可选),提供注解功能。

    jackson-datatype-joda-2.1.5.jar——日期转换

    Jackson注解

    1. 重命名属性,忽略属性,以及修改属性所使用的类型。

    ① 属性重命名时使用的注解

    最常见的使用方式之一就是改变某个成员属性所使用的JSON名称。例如: class Name { @JsonProperty("firstName") public String _first_name; }

    ②忽略属性使用的注解

    有时POJO包括了一些你不希望输出的属性,在这种情况下,你可以进行如下操作:

    public class Value {
      public int value;
      @JsonIgnore public int internalValue;
    }

    或者,你可能忽略掉某些从JSON数据中得到的属性,如果是这样,你可以使用:
    @JsonIgnoreProperties({ "extra", "uselessValue" })
    public class Value {
      public int value;
    }

    或者,更粗暴点的,忽略掉从JSON(由于在应用中没有完全匹配的POJO)中获得的所有“多余的”属性。

    @JsonIgnoreProperties(ignoreUnknown=true)
    public class PojoWithAny {
      public int value;
    }

    choose more/less specific types 时使用的注解 

    在有些情况下,Jackson在读入或输出一个成员属性时,所选用的类型(type)可能并不是你想要的

    @JsonSerialize(as=BasicType.class) 将类型序列化成指定类型

    @JsonSerialize(using=CustomDoubleSerialize.class) 作用于属性或者字段上,用于在序列化时嵌入我们自定义的代码,比如序列化一个double时在其后面限制两位小数点。 

    @JsonDeserialize 作用于属性或者字段上,指定反序列化方式

    @JsonDeserialize(as=ValueImpl.class) 将类型反序列化成指定类型

    @JsonDeserialize(using= CustomDateDeserialize.class) 用于在反序列化时嵌入我们自定义的代码

    2. 使用构造器或工厂方法

    在默认情况下,当由JSON数据创建相应类的实例时,Jackson尝试使用该类的“默认”构造器(即无参数构造器)。不过,你可以选择使用其他的构造器,或者一个静态工厂方法,来创建实例。完成这个操作,你需要使用@JsonCreator注解,有可能还需要使用@JsonProperty注解给参数(arguments)绑定名称。

    复制代码
    publicclass MyBean {
      private int value;
    @JsonCreator publicMyBean(@JsonProperty(
    "value") int v) { this.value = v; } public int getValue() { return value; } }
    复制代码

    使用相同的方式,可以将@JsonCreator用在静态工厂方法上。不过,还有一个可选的替代方案,被称作“授权式”构建器(“delegating” creator):

    复制代码
    publicclass DelegatingPOJO {
       private final int _x, _y;
    
       @JsonCreator
       publicDelegatingPOJO(Map<String,Object> delegate) {
          _x = (Integer)delegate.get("x");
          _y = (Integer)delegate.get("y");
       }
    }
    复制代码

     不同之处在于,构建器方法只能有一个参数,而且参数一定不要(must NOT)添加@JsonProperty注解。

    3. 处理多态类型

    如果你要进行读取、输出操作的对象拥有许多可能的子类型(即表现出多态性),你可能还需要添加一些类型信息。Jackson在反序列化时(读取JSON数据,生成相应的对象)需要这些信息,以便能正确地读取对象的类型。我们可以通过在“基本类型”上添加@JsonTypeInfo注解来完成操作:

    @JsonTypeInfo 类注解,当输出操作的对象拥有多个子类型且在反序列化时需要添加子类对象的类型信息,使用此注解可以正确地设置子类对象的类型

    @JsonTypeInfo(use=Id.CLASS,include=As.PROPERTY,property=”class”) 子类类型作为属性,属性名为class

    复制代码
    // 将Java类的名称(“com.myempl.ImplClass”)存储到JSON的一个名称为“class”的属性中

    @JsonTypeInfo(use=Id.CLASS, include=As.PROPERTY,property=”class”)
    public abstract class BaseClass {
    }

    public class Impl1 extends BaseClass {
      public int x;
    }

    public class Impl2 extends BaseClass {
      public String name;
    }

    public class PojoWithTypedObjects {
      public List<BaseClass> items;
    }
    复制代码

    items序列化之后的结果类似:

    {“items” : [
      {“class”:”Impl2”,  “name”: “Bob”},
      {“class”:”Impl1”, :”x” : 13}
    ]}

    4. 重新设置属性的自动发现(Changing property auto-detection)

    @JsonAutoDetect

    类注解,指定属性发现规则

    Jackson默认的属性发现规则将会查找到如下所述的属性:

    •所有被public修饰的字段(成员变量);

    •所有被public修饰的getter(即形如“getXxx()”的方法);

    •所有被public修饰的setter(即形如“setXxx(value)”的方法)

    @JsonAutoDetect(fieldVisibility=JsonAutoDetect.Visibility.ANY)

    @JsonAutoDetect(fieldVisibility=JsonAutoDetect.Visibility.NONE)

     

    更多注解查看http://wiki.fasterxml.com/JacksonAnnotations

    原文:http://blog.csdn.net/ljhabc1982/article/details/17553095

    展开全文
  • jackSon注解

    2019-09-22 08:08:46
    jackSon注解– @JsonInclude 注解不返回null值字段 Spring Boot项目中遇到的小知识 @Data @JsonInclude(JsonInclude.Include.NON_NULL) public class OrderDTO { private String orderId; @JsonProperty...

    jackSon注解– @JsonInclude 注解不返回null值字段

    Spring Boot项目中遇到的小知识

    @Data
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class OrderDTO {
    
        private String orderId;
        @JsonProperty("name")
        private String buyerName;
        @JsonProperty("phone")
        private String buyerPhone;
        @JsonProperty("address")
        private String buyerAddress;
        @JsonProperty("openid")
        private String buyerOpenid;
        private BigDecimal orderAmount;
    
        /**
         * 订单状态,默认是0
         */
        private Integer orderStatus;
    
        /**
         * 支付状态
         */
        private Integer payStatus;
    
        @JsonSerialize(using = Date2LongSerializer.class)
        private Timestamp createTime;
        @JsonSerialize(using = Date2LongSerializer.class)
        private Timestamp updateTime;
    
        @JsonProperty("items")
        List<OrderDetailEntity> orderDetailList;
    }

    @JsonInclude(JsonInclude.Include.NON_NULL)表示,如果值为null,则不返回

    全局jsckson配置

    spring:
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: 123456
        url: jdbc:mysql://192.168.41.60/sell?characterEncoding=utf-8&useSSL=false
      jpa:
        show-sql: true
      jackson:
        default-property-inclusion: non_null # 全局jackson配置

    JSON库 Jackson 常用注解介绍

    注:以下所涉及到的实体类都使用了 Lomback 插件

    Jackson JSON 框架中包含了大量的注解来让我们可以干预 Jackson 的 JSON 处理过程,
    例如我们可以通过注解指定 java pojo 的某些属性在生成 json 时被忽略。。本文主要介绍如何使用 Jackson 提供的注解。
    Jackson注解主要分成三类,一是只在序列化时生效的注解;二是只在反序列化时候生效的注解;三是两种情况下都生效的注解。

    一: 两种情况下都有效的注解
    1. @JsonIgnore 作用域属性或方法上
    @JsonIgnore 用来告诉 Jackson 在处理时忽略该注解标注的 java pojo 属性,
    不管是将 java 对象转换成 json 字符串,还是将 json 字符串转换成 java 对象。

    @Data
    public class SellerInfoEntity {
    
        private String id;
        private String username;
        private String password;
        private String openid;
    
        @JsonIgnore
        private Timestamp createTime;
        @JsonIgnore
        private Timestamp updateTime;
    
    
        public SellerInfoEntity() {
        }
    
        public SellerInfoEntity(String id, String username, String password, String openid) {
            this.id = id;
            this.username = username;
            this.password = password;
            this.openid = openid;
        }
    }

    2. @JsonIgnoreProperties 作用在类上
    @JsonIgnoreProperties 和 @JsonIgnore 的作用相同,都是告诉 Jackson 该忽略哪些属性,
    不同之处是 @JsonIgnoreProperties 是类级别的,并且可以同时指定多个属性。

    @Data
    @JsonIgnoreProperties(value = {"createTime","updateTime"})
    public class SellerInfoEntity {
    
        private String id;
        private String username;
        private String password;
        private String openid;
    
        private Timestamp createTime;
        private Timestamp updateTime;
    
    
        public SellerInfoEntity() {
        }
    
        public SellerInfoEntity(String id, String username, String password, String openid) {
            this.id = id;
            this.username = username;
            this.password = password;
            this.openid = openid;
        }
    }

    使用Spring Boot快速搭建Controller进行测试:

    @RestController
    @RequestMapping("/jackson")
    public class TestJackson {
        @RequestMapping("test1")
        public Result test1(){
            SellerInfoEntity entity = new SellerInfoEntity("1","user1","123456","openid");
            return new Result(MyResultEnum.SUCCESS,entity);
        }
    }

    访问: localhost/sell/jackson/test1

    使用注解前:返回值

    {
        "code": 0,
        "msg": "成功",
        "data": {
            "id": "1",
            "username": "user1",
            "password": "123456",
            "openid": "openid",
            "createTime": null,
            "updateTime": null
        }
    }

    使用注解后:返回值

    {
        "code": 0,
        "msg": "成功",
        "data": {
            "id": "1",
            "username": "user1",
            "password": "123456",
            "openid": "openid",
        }
    }

    3. @JsonIgnoreType

    @JsonIgnoreType 标注在类上,当其他类有该类作为属性时,该属性将被忽略。

    package org.lifw.jackosn.annotation;
    import com.fasterxml.jackson.annotation.JsonIgnoreType;
    @JsonIgnoreType
    public class SomeOtherEntity {
        private Long id;
        public Long getId() {
            return id;
        }
        public void setId(Long id) {
            this.id = id;
        }
    }
    public class SomeEntity {
        private String name;
        private String desc;
        private SomeOtherEntity entity;
    }

    SomeEntity 中的 entity 属性在json处理时会被忽略。

    4. @JsonProperty
    @JsonProperty 可以指定某个属性和json映射的名称。例如我们有个json字符串为{“user_name”:”aaa”},
    而java中命名要遵循驼峰规则,则为userName,这时通过@JsonProperty 注解来指定两者的映射规则即可。这个注解也比较常用。

    public class SomeEntity {
        @JsonProperty("user_name")
        private String userName;
          // ...
    }

    二、只在序列化情况下生效的注解
    1. @JsonPropertyOrder
    在将 java pojo 对象序列化成为 json 字符串时,使用 @JsonPropertyOrder 可以指定属性在 json 字符串中的顺序。

    2. @JsonInclude
    在将 java pojo 对象序列化成为 json 字符串时,使用 @JsonInclude 注解可以控制在哪些情况下才将被注解的属性转换成 json,例如只有属性不为 null 时。

    @Data
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class SellerInfoEntity {
    
        private String id;
        private String username;
    
        @JsonInclude(JsonInclude.Include.NON_EMPTY)
        private String password;
        private String openid;
    
        private Timestamp createTime;
        private Timestamp updateTime;
    
    
        public SellerInfoEntity() {
        }
    
        public SellerInfoEntity(String id, String username, String password, String openid) {
            this.id = id;
            this.username = username;
            this.password = password;
            this.openid = openid;
        }
    }

    Controller 测试

    @RestController
    @RequestMapping("/jackson")
    public class TestJackson {
        @RequestMapping("test1")
        public Result test1(){
            SellerInfoEntity entity = new SellerInfoEntity("1","user1","","openid");
            return new Result(MyResultEnum.SUCCESS,entity);
        }
    }

    结果:

    {
        "code": 0,
        "msg": "成功",
        "data": {
            "id": "1",
            "username": "user1",
            "openid": "openid"
        }
    }

    上述例子的意思是 SellerInfoEntity 的所有属性只有在不为 null 的时候才被转换成 json,
    如果为 null 就被忽略。并且如果password为空字符串也不会被转换.

    该注解也可以加在某个字段上。

    另外还有很多其它的范围,例如 NON_EMPTY、NON_DEFAULT等

    三、是在反序列化情况下生效的注解

    1. @JsonSetter

    @JsonSetter 标注于 setter 方法上,类似 @JsonProperty ,也可以解决 json 键名称和 java pojo 字段名称不匹配的问题。

    public class SomeEntity {
        private String desc;
        @JsonSetter("description")
        public void setDesc(String desc) {
            this.desc = desc;
        }
    }

    上述例子中在将 json 字符串转换成 SomeEntity 实例时,会将 json 字符串中的 description 字段赋值给 SomeEntity 的 desc 属性。

    Spring Boot中全局处理返回为空或null的字段,不需要其他注解,直接加入这个类就可以过滤字段值为空和null的情况:

    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    @Configuration
    public class JacksonConfig {
    
        @Bean
        @Primary
        @ConditionalOnMissingBean(ObjectMapper.class)
        public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
            ObjectMapper objectMapper = builder.createXmlMapper(false).build();
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            return objectMapper;
        }
    
    }

     

    转载于:https://www.cnblogs.com/lgjava/p/10248651.html

    展开全文
  • JackSon注解

    2018-08-24 15:08:49
    1、不返回null值字段 @JsonInclude(JsonInclude.Include.NON_NULL) 2、忽略,不返回该字段 @JsonIgnore private Integer age;  

    1、不返回null值字段

    @JsonInclude(JsonInclude.Include.NON_NULL)

    2、忽略,不返回该字段

    @JsonIgnore
        private Integer age;

     

    展开全文
  • Jackson注解详解

    千次阅读 2021-06-11 16:05:12
    本文来说下Jackson中的注解。 文章目录概述 概述 本文来说下序列化框架Jackson的详细使用。Spring MVC默认采用Jackson解析Json,尽管还有一些其它同样优秀的... 此Jackson注解教程介绍了如何使用Jackson的注解。 下.

    本文来说下Jackson中的注解。


    概述

    本文来说下序列化框架Jackson的详细使用。Spring MVC默认采用Jackson解析Json,尽管还有一些其它同样优秀的json解析工具,例如Fast Json、GSON,但是出于最小依赖的考虑,也许Json解析第一选择就应该是Jackson。Jackson JSON工具包包含一组Java注解,可以使用这些注解来设置将JSON读入对象的方式或从对象生成什么JSON的方式。 此Jackson注解教程介绍了如何使用Jackson的注解。

    下面是一些常用的注解

    注解用法
    @JsonProperty用于属性,把属性的名称序列化时转换为另外一个名称。示例:@JsonProperty(“birth_ d ate”)private Date birthDate;
    @JsonFormat用于属性或者方法,把属性的格式序列化时转换成指定的格式。示例: @JsonFormat(timezone = “GMT+8”, pattern = “yyyyMM-dd HH:mm”) public DategetBirthDate()
    @JsonPropertyOrder用于类, 指定属性在序列化时 json 中的顺序 , 示例:@JsonPropertyOrder({ “birth_Date”, “name” })public class Person
    @JsonCreator用于构造方法,和 @JsonProperty 配合使用,适用有参数的构造方法。 示例: @JsonCreator public Person(@JsonProperty(“name”)String name) {…}
    @JsonAnySetter用于属性或者方法,设置未反序列化的属性名和值作为键值存储到 map 中 @JsonAnySetter public void set(String key, Object value) { map.put(key, value); }
    @JsonAnyGetter用于方法 ,获取所有未序列化的属性public Map<String, Object> any() { return map; } ;

    Read + Write注解

    Jackson包含一组注解,这些注解会影响从JSON读取Java对象以及将Java对象写入JSON。 我将这些注解称为“读+写注解”。 以下各节将更详细地介绍Jackson的读写注解


    @JsonIgnore

    Jackson注解@JsonIgnore用于告诉Jackson忽略Java对象的某个属性(字段)。 在将JSON读取到Java对象中以及将Java对象写入JSON时,都将忽略该属性。

    这是使用@JsonIgnore注解的示例

    Person实体类

    package cn.wideth.entity.domain;
    
    import com.fasterxml.jackson.annotation.JsonIgnore;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 人的基
     * 本信息
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person {
    
        //使用了@JsonIgnore注解,id属性不会再返回给前端了
        @JsonIgnore
        private Integer id;
    
        private String  name;
    
        private String  sex;
    
        private String  address;
    
    }
    

    Controller调用

    package cn.wideth.controller;
    
    import cn.wideth.entity.domain.Person;
    import io.swagger.annotations.Api;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.ArrayList;
    import java.util.List;
    
    @RestController
    @RequestMapping("/json")
    @Api(tags = "JSON注解使用测试")
    public class PersonController {
    
        // 查询参数
        @GetMapping("getPersonInfo")
        public List<Person> getPersonInfo() {
    
            List<Person> data = new ArrayList<>();
            Person p1 = new Person(1,"张三","男","上海");
            Person p2 = new Person(2,"李四","男","北京");
            Person p3 = new Person(3,"王五","男","杭州");
            data.add(p1);
            data.add(p2);
            data.add(p3);
            return data;
        }
    }
    

    程序结果

    在这里插入图片描述
    Person类的id属性使用了@JsonIgnore注解,不会再返回给前端了


    @JsonIgnoreProperties

    @JsonIgnoreProperties Jackson注解用于指定要忽略的类的属性列表@JsonIgnoreProperties注解放置在类声明上方,而不是要忽略的各个属性(字段)上方。

    这是如何使用@JsonIgnoreProperties注解的示例

    Person实体类

    package cn.wideth.entity.domain;
    
    import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 人的基
     * 本信息
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @JsonIgnoreProperties({"id", "name"})
    public class Person {
    
        private Integer id;
    
        private String  name;
    
        private String  sex;
    
        private String  address;
    
    }
    

    测试结果

    在这里插入图片描述


    @JsonIgnoreType

    @JsonIgnoreType Jackson注解用于将整个类型(类)标记为在使用该类型的任何地方都将被忽略。

    这是一个示例,展示如何使用@JsonIgnoreType注解

    import com.fasterxml.jackson.annotation.JsonIgnoreType;
    
    public class PersonIgnoreType {
    
        @JsonIgnoreType
        public static class Address {
            public String streetName  = null;
            public String houseNumber = null;
            public String zipCode     = null;
            public String city        = null;
            public String country     = null;
        }
    
        public long    personId = 0;
    
        public String  name = null;
    
        public Address address = null;
    }
    
    

    在上面的示例中,所有Address实例将被忽略。


    @JsonAutoDetect

    Jackson注解@JsonAutoDetect用于告诉Jackson在读写对象时包括非public修饰的属性。

    这是一个示例类,展示如何使用@JsonAutoDetect注解

    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    
    @JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY )
    public class PersonAutoDetect {
    
        private long  personId = 123;
        public String name     = null;
    
    }
    
    

    JsonAutoDetect.Visibility类包含与Java中的可见性级别匹配的常量,表示ANY,DEFAULT,NON_PRIVATE,NONE,PROTECTED_AND_PRIVATE和PUBLIC_ONLY。


    Read注解

    Jackson包含一组注解,这些注解仅影响Jackson将JSON解析为对象的方式-意味着它们影响Jackson对JSON的读取。 我称这些为“读注解”。 以下各节介绍了Jackson的读注解。


    @JsonSetter

    Jackson注解@JsonSetter用于告诉Jackson,当将JSON读入对象时,应将此setter方法的名称与JSON数据中的属性名称匹配。 如果Java类内部使用的属性名称与JSON文件中使用的属性名称不同,这个注解就很有用了。

    以下Person类用personId名称对应JSON中名为id的字段

    Person实体类

    package cn.wideth.entity.domain;
    
    import com.fasterxml.jackson.annotation.JsonSetter;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 人的基
     * 本信息
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person {
    
        //在序列化的时候使用id来替换personId
        @JsonSetter("id")
        private Integer personId;
    
        private String  name;
    
        private String  sex;
    
        private String  address;
    
    }
    

    测试程序结果

    在这里插入图片描述


    @JsonAnySetter

    Jackson注解@JsonAnySetter表示Jackson为JSON对象中所有无法识别的字段调用相同的setter方法。 “无法识别”是指尚未映射到Java对象中的属性或设置方法的所有字段。

    Phone实体类

    package cn.wideth.entity.domain;
    
    import com.fasterxml.jackson.annotation.JsonAnySetter;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import java.util.HashMap;
    import java.util.Map;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Phone {
    
        private String id;
    
        private String model;
    
    
        /**
         * 没有匹配上的反序列化属性,放到这里
         * @param key
         * @param value
         */
        @JsonAnySetter
        private Map<String,Object> other = new HashMap<>();
    }
    

    测试程序

    package cn.wideth.entity.domain;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import lombok.SneakyThrows;
    import java.util.HashMap;
    import java.util.Map;
    
    public class Main {
    
        @SneakyThrows
        public static void main(String[] args) {
    
            Map<String,Object> map = new HashMap<>();
            map.put("id","abdae");
            map.put("name","我的");
            map.put("model","nokia");
            map.put("size","6.0");
    
            ObjectMapper mapper = new ObjectMapper();
            String s = mapper.writeValueAsString(map);
            Phone phone = mapper.readValue(s, Phone.class);
            System.out.println(phone);
        }
    }
    

    测试程序结果

    在这里插入图片描述


    @JsonCreator

    Jackson注解@JsonCreator用于告诉Jackson该Java对象具有一个构造函数(“创建者”),该构造函数可以将JSON对象的字段与Java对象的字段进行匹配。

    @JsonCreator注解在无法使用@JsonSetter注解的情况下很有用。 例如,不可变对象没有任何设置方法,因此它们需要将其初始值注入到构造函数中。

    以这个PersonImmutable类为例

    public class PersonImmutable {
    
        private long   id   = 0;
        private String name = null;
    
        public PersonImmutable(long id, String name) {
            this.id = id;
            this.name = name;
        }
    
        public long getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    
    }
    
    

    要告诉Jackson应该调用PersonImmutable的构造函数,我们必须在构造函数中添加@JsonCreator注解。 但是,仅凭这一点还不够。 我们还必须注解构造函数的参数,以告诉Jackson将JSON对象中的哪些字段传递给哪些构造函数参数。

    添加了@JsonCreator和@JsonProperty注解的PersonImmutable类的示例如下:

    public class PersonImmutable {
    
        private long   id   = 0;
        private String name = null;
    
        @JsonCreator
        public PersonImmutable(
                @JsonProperty("id")  long id,
                @JsonProperty("name") String name  ) {
    
            this.id = id;
            this.name = name;
        }
    
        public long getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    
    }
    
    
    

    请注意,构造函数上方的注解以及构造函数参数之前的注解。 现在,Jackson能够从此JSON对象创建PersonImmutable:

    {
      "id"   : 1234,
      "name" : "John"
    }
    

    @JacksonInject

    Jackson注解@JacksonInject用于将值注入到解析的对象中,而不是从JSON中读取这些值。 例如,假设正在从各种不同的源下载Person JSON对象,并且想知道给定Person对象来自哪个源。 源本身可能不包含该信息,但是可以让Jackson将其注入到根据JSON对象创建的Java对象中。

    要将Java类中的字段标记为需要由Jackson注入其值的字段,请在该字段上方添加@JacksonInject注解。

    这是一个示例PersonInject类,在属性上方添加了@JacksonInject注解

    public class PersonInject {
    
        public long   id   = 0;
        public String name = null;
    
        @JacksonInject
        public String source = null;
    
    }
    
    

    为了让Jackson将值注入属性,需要在创建Jackson ObjectMapper时做一些额外的工作。

    这是让Jackson将值注入Java对象的过程:

    InjectableValues inject = new InjectableValues.Std().addValue(String.class, "jenkov.com");
    PersonInject personInject = new ObjectMapper().reader(inject)
                            .forType(PersonInject.class)
                            .readValue(new File("data/person.json"));
    
    

    请注意,如何在InjectableValues addValue()方法中设置要注入到source属性中的值。 还要注意,该值仅绑定到字符串类型-而不绑定到任何特定的字段名称。 @JacksonInject注解指定将值注入到哪个字段。

    如果要从多个源下载人员JSON对象,并为每个源注入不同的源值,则必须为每个源重复以上代码。


    @JsonDeserialize

    Jackson注解@JsonDeserialize用于为Java对象中给定的属性指定自定义反序列化器类。

    例如,假设想优化布尔值false和true的在线格式,使其分别为0和1。

    首先,需要将@JsonDeserialize注解添加到要为其使用自定义反序列化器的字段。 这是将@JsonDeserialize注解添加到字段的示例:

    public class PersonDeserialize {
    
        public long    id      = 0;
        public String  name    = null;
    
        @JsonDeserialize(using = OptimizedBooleanDeserializer.class)
        public boolean enabled = false;
    }
    
    

    其次,这是@JsonDeserialize注解中引用的OptimizedBooleanDeserializer类的实例:

    public class OptimizedBooleanDeserializer
        extends JsonDeserializer<Boolean> {
    
        @Override
        public Boolean deserialize(JsonParser jsonParser,
                DeserializationContext deserializationContext) throws
            IOException, JsonProcessingException {
    
            String text = jsonParser.getText();
            if("0".equals(text)) return false;
            return true;
        }
    }
    
    

    请注意,OptimizedBooleanDeserializer类使用通用类型Boolean扩展了JsonDeserializer。 这样做会使deserialize()方法返回一个布尔对象。 如果要反序列化其他类型(例如java.util.Date),则必须在泛型括号内指定该类型。

    可以通过调用jsonParser参数的getText()方法来获取要反序列化的字段的值。 然后,可以将该文本反序列化为任何值,然后输入反序列化程序所针对的类型(在此示例中为布尔值)。

    最后,需要查看使用自定义反序列化器和@JsonDeserializer注解反序列化对象的格式:

    PersonDeserialize person = objectMapper
            .reader(PersonDeserialize.class)
            .readValue(new File("data/person-optimized-boolean.json"));
    
    

    注意,我们首先需要如何使用ObjectMapper的reader()方法为PersonDeserialize类创建一个阅读器,然后在该方法返回的对象上调用readValue()。


    Write注解

    Jackson还包含一组注解,这些注解可以影响Jackson将Java对象序列化(写入)到JSON的方式。 以下各节将介绍这些写(序列化)注解中的每一个。


    @JsonInclude

    Jackson注解@JsonInclude告诉Jackson仅在某些情况下包括属性。 例如,仅当属性为非null,非空或具有非默认值时,才应包括该属性。 这是显示如何使用@JsonInclude注解的示例:

    import com.fasterxml.jackson.annotation.JsonInclude;
    
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    public class PersonInclude {
    
        public long  personId = 0;
        public String name     = null;
    
    }
    
    

    如果为该示例设置的值是非空的,则此示例将仅包括name属性,这意味着不为null且不是空字符串。

    @JsonInclude注解的一个更通俗的名称应该是@JsonIncludeOnlyWhen,但是写起来会更长。


    @JsonGetter

    @JsonGetter Jackson注解用于告诉Jackson,应该通过调用getter方法而不是通过直接字段访问来获取某个字段值。 如果您的Java类使用jQuery样式的getter和setter名称,则@JsonGetter注解很有用。

    例如,您可能拥有方法personId()和personId(long id),而不是getPersonId()和setPersonId()。

    这是一个名为PersonGetter的示例类,它显示了@JsonGetter注解的用法:

    public class PersonGetter {
    
        private long  personId = 0;
    
        @JsonGetter("id")
        public long personId() { return this.personId; }
    
        @JsonSetter("id")
        public void personId(long personId) { this.personId = personId; }
    
    }
    
    

    如您所见,personId()方法带有@JsonGetter注解。 @JsonGetter注解上设置的值是JSON对象中应使用的名称。 因此,用于JSON对象中personId的名称是id。 生成的JSON对象如下所示:

    {"id":0}
    

    还要注意,personId(long personId)方法使用@JsonSetter注解进行注解,以使Jackson识别为与JSON对象中的id属性匹配的设置方法。 从JSON读取Java对象时使用@JsonSetter注解-将Java对象写入JSON时不使用。 为了完整起见,仅包含@JsonSetter注解。


    @JsonAnyGetter

    @JsonAnyGetter Jackson注解使您可以将Map用作要序列化为JSON的属性的容器。 这是在Java类中使用@JsonAnyGetter注解的示例:

    public class PersonAnyGetter {
    
        private Map<String, Object> properties = new HashMap<>();
    
        @JsonAnyGetter
        public Map<String, Object> properties() {
            return properties;
        }
    }
    
    

    当看到@JsonAnyGetter注解时,Jackson将从@JsonAnyGetter注解的方法中获取返回的Map,并将该Map中的每个键值对都视为一个属性。 换句话说,Map中的所有键值对都将作为PersonAnyGetter对象的一部分序列化为JSON。


    @JsonPropertyOrder

    @JsonPropertyOrder Jackson注解可用于指定将Java对象的字段序列化为JSON的顺序。 这是显示如何使用@JsonPropertyOrder注解的示例:

    @JsonPropertyOrder({"name", "personId"})
    public class PersonPropertyOrder {
    
        public long  personId  = 0;
        public String name     = null;
    
    }
    
    

    通常,Jackson会按照在类中找到的顺序序列化PersonPropertyOrder中的属性。 但是,@JsonPropertyOrder注解指定了不同的顺序,在序列化的JSON输出中,name属性将首先出现,personId属性将随后出现。


    @JsonRawValue

    @JsonRawValue Jackson注解告诉Jackson该属性值应直接写入JSON输出。 如果该属性是字符串,Jackson通常会将值括在引号中,但是如果使用@JsonRawValue属性进行注解,Jackson将不会这样做。

    为了更清楚@JsonRawValue的作用,看看没有使用@JsonRawValue的此类:

    public class PersonRawValue {
    
        public long   personId = 0;
    
        public String address  = "$#";
    }
    

    Jackson会将其序列化为以下JSON字符串:

    {"personId":0,"address":"$#"}
    

    现在,我们将@JsonRawValue添加到address属性,如下所示:

    public class PersonRawValue {
    
        public long   personId = 0;
    
        @JsonRawValue
        public String address  = "$#";
    }
    

    现在,当对地址属性进行序列化时,杰克逊将省略引号。 因此,序列化的JSON如下所示:

    {"personId":0,"address":$#}
    

    当然它是无效的JSON,那么为什么要这么做呢?

    如果address属性包含一个JSON字符串,那么该JSON字符串将被序列化为最终的JSON对象,作为JSON对象结构的一部分,而不仅是序列化为JSON对象的address字段中的字符串。

    要查看其工作原理,让我们像下面这样更改address属性的值:

    public class PersonRawValue {
    
        public long   personId = 0;
    
        @JsonRawValue
        public String address  =
                "{ \"street\" : \"Wall Street\", \"no\":1}";
    
    }
    
    

    Jackson会将其序列化为以下JSON:

    {"personId":0,"address":{ "street" : "Wall Street", "no":1}}
    

    请注意,JSON字符串现在如何成为序列化JSON结构的一部分。

    没有@JsonRawValue注解,Jackson会将对象序列化为以下JSON:

    {"personId":0,"address":"{ \"street\" : \"Wall Street\", \"no\":1}"}
    

    请注意,address属性的值现在如何用引号引起来,并且值内的所有引号均被转义。


    @JsonValue

    Jackson注解@JsonValue告诉Jackson,Jackson不应该尝试序列化对象本身,而应在对象上调用将对象序列化为JSON字符串的方法。 请注意,Jackson将在自定义序列化返回的String内转义任何引号,因此不能返回例如 完整的JSON对象。 为此,应该改用@JsonRawValue(请参阅上一节)。

    @JsonValue注解已添加到Jackson调用的方法中,以将对象序列化为JSON字符串。 这是显示如何使用@JsonValue注解的示例:

    public class PersonValue {
    
        public long   personId = 0;
        public String name = null;
    
        @JsonValue
        public String toJson(){
            return this.personId + "," + this.name;
        }
    
    }
    
    

    要求Jackson序列化PersonValue对象所得到的输出是:

    "0,null"
    

    引号由Jackson添加。 请记住,对象返回的值字符串中的所有引号均会转义。


    @JsonSerialize

    @JsonSerialize Jackson注解用于为Java对象中的字段指定自定义序列化程序。 这是一个使用@JsonSerialize注解的Java类示例:

    public class PersonSerializer {
    
        public long   personId = 0;
        public String name     = "John";
    
        @JsonSerialize(using = OptimizedBooleanSerializer.class)
        public boolean enabled = false;
    }
    
    

    注意启用字段上方的@JsonSerialize注解。

    OptimizedBooleanSerializer将序列的真值序列化为1,将假值序列化为0。这是代码:

    public class OptimizedBooleanSerializer extends JsonSerializer<Boolean> {
    
        @Override
        public void serialize(Boolean aBoolean, JsonGenerator jsonGenerator, 
            SerializerProvider serializerProvider) 
        throws IOException, JsonProcessingException {
    
            if(aBoolean){
                jsonGenerator.writeNumber(1);
            } else {
                jsonGenerator.writeNumber(0);
            }
        }
    }
    
    

    本文小结

    本文详细介绍了Jackson中的各个注解。

    展开全文
  • 详解jackson注解(一)jackson系列化注解 jackson中用于系列化的主要注解有: 注解 描述 1 @JsonAnyGetter @JsonAnyGetter注解可以灵活地把类型为Map的属性作为标准属性使用。 2 @...
  • 详解jackson注解(二)jackson反系列化注解 jackson中用于反系列化的主要注解有: 注解 描述 1 JsonCreator JsonCreator注解在构造函数或者工厂方法上,用于指示实例化类的对象。构造函数...
  • Jackson注解示例

    2020-08-24 10:09:58
    2. Jackson序列化注解 2.1. @JsonAnyGetter 2.2. @JsonGetter 2.3. @JsonPropertyOrder 2.4. @JsonRawValue 2.5. @JsonValue 2.6. @JsonRootName 2.7. @JsonSerialize Jackson反序列化注解 3.1. @...
  • 详解jackson注解(三)jackson包含属性、忽略属性的注解 jackson中,指定包含哪些属性、忽略哪些属性的注解: 注解类 描述 1 JsonIgnoreProperties 用于标记忽略一个或多个属性。可以注解在类上、构造函数...
  • 常用Jackson注解解释

    千次阅读 2017-08-19 17:59:24
    常用Jackson注解解释
  • JackSon注解-@JsonInclude

    2020-11-18 09:55:57
    @JsonInclude - jackSon注解
  • jackson注解包2.2.3.rar

    2020-02-14 13:07:28
    jackson注解包 2.2.3版本 jackson-annotaion-2.2.3.jar
  • SpringBoot之Jackson注解

    2020-09-10 21:43:45
    Jackson注解 Jackson有多个注解,用来在序列化和反序列化操作 @JsonProperty("XXXX") //为key指定一个别名 private String aa; @JsonIgnore("XXXX") //忽略此属性 private String aa; @JsonIgnoreProperties({...
  • Jackson注解技巧(实用)

    千次阅读 2019-01-04 11:53:24
    Jackson注解技巧(实用) 前言 将java Bean转化为json串时,一般情况下是会事先制定好契约,例如属性字段的命名方式,jackson默认使用的是aaBbCc的驼峰命名格式,无论的序列化还是反序列化。但是,并非...
  • 前面花了好几篇文章大篇幅介绍`Jackson`的`Feature`特征以及原理,如果说Feature是全局设置,那么注解就是个性化配置,因此相比较起来面向应用、面向开发者的注解, 理解它的含义以及使用方式显得更加重要,是**...
  • jackSon注解-- @JsonInclude 注解不返回null值字段

    万次阅读 多人点赞 2017-12-03 13:22:01
    jackSon注解– @JsonInclude 注解不返回null值字段 Spring Boot项目中遇到的小知识 @Data @JsonInclude(JsonInclude.Include.NON_NULL) public class OrderDTO { private String orderId; @JsonProperty("name") ...
  • 使用Jackson注解忽略Json中的字段

    千次阅读 2019-02-03 17:26:22
    使用Jackson注解忽略Json中的字段 Ignore fields in JSON using Jackson @JsonIgnoreProperties or @JsonIgnore Jackson 提供了一种将JSON绑定到POJO的高效方法。然而,有时候在将JSON转换为Java 对象以及将Java对象...
  • jackson注解使用

    2015-02-26 10:17:16
    jackson常用注解 1、类注解,忽略部分字段 @JsonIgnoreProperties(value = { "name" })    2、@JsonIgnore忽略单个字段,可标注在属性或者方法上 3、@JsonProperty(value="create") 为属性定义返回的json名称...
  • Jackson注解使用

    2020-03-24 16:52:36
    使用@JsonSerialize将Date类型序列化成时间戳 根据需求编写序列化方法 ...import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonProcessingException; import ...
  • Jackson注解 @JsonCreator

    万次阅读 2018-10-11 21:37:05
    当json在反序列化时,默认选择类的无参构造函数创建类对象,当没有无参构造函数时会报错,@JsonCreator作用就是指定反序列化时用的无参构造函数。构造方法的参数前面需要加上@JsonProperty,否则会报错。...
  • Jackson注解 @JsonProperty

    千次阅读 2018-10-10 22:48:25
    @JsonProperty 注解用于序列化或者反序列化时,映射的属性的名字,可以放在get方法,set方法,还有属性上,都可以。 @JsonProperty(value = "fullName") private String name; 序列化后会是这样 {&...
  • jackSon注解– @JsonInclude 注解不返回null值字段 @Data @JsonInclude(value= JsonInclude.Include.NON_NULL) public class DraftBoxTStoreUserDto extends TStoreUser{ private String entryChannelsStr; ...
  • Jackson注解学习参考

    2019-04-15 01:11:32
    NULL 博文链接:https://wong-john.iteye.com/blog/1753402
  • jackson注解使用详解

    2019-05-15 17:18:22
    转载自: https://www.baeldung.com/jackson-annotations
  • Jackson注解 @JsonValue

    万次阅读 2018-10-10 22:55:03
    @JsonValue 可以用在get方法或者属性字段上,一个类只能用一个,当加上@JsonValue注解是,序列化是只返回这一个字段的值。 例如,实体类中age属性加上注解 @JsonValue private Integer age; 序列化这个类是...
  • Jackson注解 @JsonRootName

    千次阅读 2018-10-11 21:49:12
    @JsonRootName的作用是定义一个根key,看例子: @JsonRootName(value = "root") public class User { private String id; ... ...使用时必须给ObjectMapper对象做如下设置 ...mapper.enable...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,578
精华内容 19,031
关键字:

jackson注解