Jackson注解入门示例

最新推荐文章于 2024-07-22 07:00:00 发布
原创 最新推荐文章于 2024-07-22 07:00:00 发布 · 357 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#jackson #annotation #注解 #示例 #入门

本文详细介绍了Jackson库中各种注解的功能与应用场景，包括解决JSON字段与Java Bean字段不匹配的问题，以及如何处理多态、循环引用等复杂情况。

jackson目的是什么呢？ 它是解决json和bean之间对应关系，json就是字符和java的bean如何进行关联，json字符和bean之间会有哪些问题呢？

文章目录

1、预先思考

  • 最理想情况下，就json和bean是一一对应，层次结构相同，成员变量和json的key对应字符串相同，这样json也是最好处理。

1.1、json和bean会有什么问题呢？

  1. 当一个系统与多个系统进行交互的时候采用json格式，不同系统生成json格式层次和json中的key可能不同
  2. 比如说A系统用户名字段是userName ， B系统中用户名字段user_name, 我们系统定义用户名字段userN，这个时候怎么做
    1. 方案一：对方系统转换成我们系统字段名传给我们
    2. 方案二：对方已经成熟系统不愿意改，我们系统写一个适配器接收两个系统原始进行转换成标准的（当差异很大时候，这个方式比较合理），如果只是字段名微调就重新定义一个适配器有那个啥？
    3. 方案三：jackson可以解决这种适配情况（json字段与bean字段一对多的关系）
  3. json对象的字段不一定，不同场景传递字段不一样且数量不定，比如说订单，比如对接多个快递公司，每个快递公司填信息不一样，传到我们系统时候，有时候这个字段存在，有时它不存在，此时我们怎么定义bean呢？
    1. 方案一：把所有可能字段全部定义
    2. 方案二：把可变对象定义成一个字段JsonObject对象之类,其实它本质也就一个map
    3. 方案三：jackson注解简单解决这个问题，本质上也是map
  4. json 和枚举关系怎么对应，到底是对应枚举那个属性和枚举本身的name？这个jackson也可以配置
  5. json 和bean多态怎么对应呢？场景是这样的，就拿订单来说，订单主信息是一样，而明细可以不一样，比如下预售订单和现货订单就不一样？那此时你在想我需要对预售订单和现货订单分别提供接口，如果只提供一个接口怎么实现呢？这个时候需要在解析json时候如何对应不同明细子类呢？jackson也是有这种特性
  6. 有时候我需要忽略null转成json字符串中，或者说觉得某个字段不需要转成json字符，如何灵活配置忽略字段呢？
  7. 格式转换，比如说数据库查询出来是10000，我们希望转给前端是$10,000, 或者前端传给我们是$10,000,我们转换成10000，jackson可以定义转换逻辑
  8. 如果bean出现循环依赖，转成json应该是什么样？怎么解决？
  • 带这个问题去了解jackson

2、具体jackson注解

2.1、@JsonAnySetter

  • 将Map的属性变成bean的属性，且动态变化的，变成bean属性时，key就是属性名称， value就是属性值。

  • public class ExtendableBean {
    public String name;
    private Map<String, String> properties;

    @JsonAnyGetter
    public Map<String, String> getProperties() {
        return properties;
    }
}


@Test
public void whenSerializingUsingJsonAnyGetter_thenCorrect()
  throws JsonProcessingException {
 
    ExtendableBean bean = new ExtendableBean("My bean");
    bean.add("attr1", "val1");
    bean.add("attr2", "val2");

    String result = new ObjectMapper().writeValueAsString(bean);
 
    assertThat(result, containsString("attr1"));
    assertThat(result, containsString("val1"));
}

  • 输出结果

    • {
    "name":"My bean",
    "attr2":"val2",
    "attr1":"val1"
}

2.2、@JsonGetter /@JsonSetter

  • 当方法和属性不同时候就可以利用@JsonGetter/@JsonSetter指定某一个属性

  • public class MyBean {
    public int id;
    private String name;

    @JsonGetter("name")
    public String getTheName() {
        return name;
    }
}

@Test
public void whenSerializingUsingJsonGetter_thenCorrect()
  throws JsonProcessingException {
 
    MyBean bean = new MyBean(1, "My bean");

    String result = new ObjectMapper().writeValueAsString(bean);
 
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));
}

2.3、@JsonPropertyOrder

  • 指定序列化字段顺序，这个场景用的不是很多,@JsonPropertyOrder(alphabetic = true) 表示按照26字母顺序排序

  • @JsonPropertyOrder({ "name", "id" })
public class MyBean {
    public int id;
    public String name;
}

@Test
public void whenSerializingUsingJsonPropertyOrder_thenCorrect()
  throws JsonProcessingException {
 
    MyBean bean = new MyBean(1, "My bean");

    String result = new ObjectMapper().writeValueAsString(bean);
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));
}

  • 输出结果

    • {
    "name":"My bean",
    "id":1
}

2.4、@JsonRawValue

  • 过滤某个字段不要jackson进行处理，只适合将bean转换成json字符串，不能用json字符串转成bean

  • public class RawBean {
    public String name;

    @JsonRawValue
    public String json;
}

@Test
public void whenSerializingUsingJsonRawValue_thenCorrect()
  throws JsonProcessingException {
 
    RawBean bean = new RawBean("My bean", "{\"attr\":false}");

    String result = new ObjectMapper().writeValueAsString(bean);
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("{\"attr\":false}"));
}

  • 输出结果

    • {
    "name":"My bean",
    "json":{
        "attr":false
    }
}

2.5、@JsonValue

  • 一般用于枚举到达使用哪个值进行序列化,某个实体中只序列化某个方法和成员变量

  • public enum TypeEnumWithValue {
    TYPE1(1, "Type A"), TYPE2(2, "Type 2");

    private Integer id;
    private String name;

    // standard constructors

    @JsonValue
    public String getName() {
        return name;
    }
}

@Test
public void whenSerializingUsingJsonValue_thenCorrect()
  throws JsonParseException, IOException {
 
    String enumAsString = new ObjectMapper()
      .writeValueAsString(TypeEnumWithValue.TYPE1);

    assertThat(enumAsString, is(""Type A""));
}

2.6、@JsonRootName

  • 需要开启WRAP_ROOT_VALUE开关 ，实例化成json时候套个壳，多加一层

  • @JsonRootName(value = "user")public class UserWithRoot {    public int id;    public String name;}@Testpublic void whenSerializingUsingJsonRootName_thenCorrect()  throws JsonProcessingException {     UserWithRoot user = new User(1, "John");    ObjectMapper mapper = new ObjectMapper();    mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);    String result = mapper.writeValueAsString(user);    assertThat(result, containsString("John"));    assertThat(result, containsString("user"));}

  • 输出结果

    • {    "user":{        "id":1,        "name":"John"    }}

2.7、@JsonSerialize 和@JsonDeserialize

  • 自定义序列化和反序列类

  • public class EventWithSerializer {    public String name;    @JsonSerialize(using = CustomDateSerializer.class)    public Date eventDate;}public class CustomDateSerializer extends StdSerializer<Date> {    private static SimpleDateFormat formatter       = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");    public CustomDateSerializer() {         this(null);     }     public CustomDateSerializer(Class<Date> t) {        super(t);     }    @Override    public void serialize(      Date value, JsonGenerator gen, SerializerProvider arg2)       throws IOException, JsonProcessingException {        gen.writeString(formatter.format(value));    }}@Testpublic void whenSerializingUsingJsonSerialize_thenCorrect()  throws JsonProcessingException, ParseException {     SimpleDateFormat df      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");    String toParse = "20-12-2014 02:30:00";    Date date = df.parse(toParse);    EventWithSerializer event = new EventWithSerializer("party", date);    String result = new ObjectMapper().writeValueAsString(event);    assertThat(result, containsString(toParse));}

2.8、@JsonCreator

  • 构造器方法

  • public class BeanWithCreator {    public int id;    public String name;    @JsonCreator    public BeanWithCreator(      @JsonProperty("id") int id,       @JsonProperty("theName") String name) {        this.id = id;        this.name = name;    }}@Testpublic void whenDeserializingUsingJsonCreator_thenCorrect()  throws IOException {     String json = "{\"id\":1,\"theName\":\"My bean\"}";    BeanWithCreator bean = new ObjectMapper()      .readerFor(BeanWithCreator.class)      .readValue(json);    assertEquals("My bean", bean.name);}

  • 输出

    • {    "id":1,    "theName":"My bean"}

2.9、@JacksonInject

  • json字符串没有对应的字段，就需要预先通过注射一个值

  • public class BeanWithInject {    @JacksonInject    public int id;        public String name;}@Testpublic void whenDeserializingUsingJsonInject_thenCorrect()  throws IOException {     String json = "{\"name\":\"My bean\"}";        InjectableValues inject = new InjectableValues.Std()      .addValue(int.class, 1);    BeanWithInject bean = new ObjectMapper().reader(inject)      .forType(BeanWithInject.class)      .readValue(json);        assertEquals("My bean", bean.name);    assertEquals(1, bean.id);}

2.10、@JsonAlias

  • json多个名称对应一个bean上字段

  • public class AliasBean {    @JsonAlias({ "fName", "f_name" })    private String firstName;       private String lastName;}@Testpublic void whenDeserializingUsingJsonAlias_thenCorrect() throws IOException {    String json = "{\"fName\": \"John\", \"lastName\": \"Green\"}";    AliasBean aliasBean = new ObjectMapper().readerFor(AliasBean.class).readValue(json);    assertEquals("John", aliasBean.getFirstName());}

2.11、@JsonIgnoreProperties

  • 类级别注解， 忽略某一些字段

  • @JsonIgnoreProperties({ "id" })public class BeanWithIgnore {    public int id;    public String name;}@Testpublic void whenSerializingUsingJsonIgnoreProperties_thenCorrect()  throws JsonProcessingException {     BeanWithIgnore bean = new BeanWithIgnore(1, "My bean");    String result = new ObjectMapper()      .writeValueAsString(bean);        assertThat(result, containsString("My bean"));    assertThat(result, not(containsString("id")));}

2.12、@JsonIgnore

  • 成员变量的，忽略单个字段

  • public class BeanWithIgnore {    @JsonIgnore    public int id;    public String name;}

  • @Testpublic void whenSerializingUsingJsonIgnore_thenCorrect()  throws JsonProcessingException {     BeanWithIgnore bean = new BeanWithIgnore(1, "My bean");    String result = new ObjectMapper()      .writeValueAsString(bean);        assertThat(result, containsString("My bean"));    assertThat(result, not(containsString("id")));}

2.13、@JsonIgoreType

  • 忽略某类型的字段

  • public class User {    public int id;    public Name name;    @JsonIgnoreType    public static class Name {        public String firstName;        public String lastName;    }}@Testpublic void whenSerializingUsingJsonIgnoreType_thenCorrect()  throws JsonProcessingException, ParseException {     User.Name name = new User.Name("John", "Doe");    User user = new User(1, name);    String result = new ObjectMapper()      .writeValueAsString(user);    assertThat(result, containsString("1"));    assertThat(result, not(containsString("name")));    assertThat(result, not(containsString("John")));}

2.14、@JsonInclude

  • 哪些字段包括在内进行序列化

  • @JsonInclude(Include.NON_NULL)public class MyBean {    public int id;    public String name;}public void whenSerializingUsingJsonInclude_thenCorrect()  throws JsonProcessingException {     MyBean bean = new MyBean(1, null);    String result = new ObjectMapper()      .writeValueAsString(bean);        assertThat(result, containsString("1"));    assertThat(result, not(containsString("name")));}

2.15、@JsonAutoDetect

  • 自动检测，哪些限制修饰符属性可以json序列化

  • @JsonAutoDetect(fieldVisibility = Visibility.ANY)public class PrivateBean {    private int id;    private String name;}@Testpublic void whenSerializingUsingJsonAutoDetect_thenCorrect()  throws JsonProcessingException {     PrivateBean bean = new PrivateBean(1, "My bean");    String result = new ObjectMapper()      .writeValueAsString(bean);        assertThat(result, containsString("1"));    assertThat(result, containsString("My bean"));}

2.16、@JsonTypeInfo

  • 序列化的详细信息

  • public class Zoo {    public Animal animal;    @JsonTypeInfo(      use = JsonTypeInfo.Id.NAME,       include = As.PROPERTY,       property = "type")    @JsonSubTypes({        @JsonSubTypes.Type(value = Dog.class, name = "dog"),        @JsonSubTypes.Type(value = Cat.class, name = "cat")    })    public static class Animal {        public String name;    }    @JsonTypeName("dog")    public static class Dog extends Animal {        public double barkVolume;    }    @JsonTypeName("cat")    public static class Cat extends Animal {        boolean likesCream;        public int lives;    }}@Testpublic void whenSerializingPolymorphic_thenCorrect()  throws JsonProcessingException {    Zoo.Dog dog = new Zoo.Dog("lacy");    Zoo zoo = new Zoo(dog);    String result = new ObjectMapper()      .writeValueAsString(zoo);    assertThat(result, containsString("type"));    assertThat(result, containsString("dog"));}

  • 输出

    • {    "animal": {        "type": "dog",        "name": "lacy",        "barkVolume": 0    }}

  • 反序列化

    • @Testpublic void whenDeserializingPolymorphic_thenCorrect()throws IOException {    String json = "{\"animal\":{\"name\":\"lacy\",\"type\":\"cat\"}}";    Zoo zoo = new ObjectMapper()      .readerFor(Zoo.class)      .readValue(json);    assertEquals("lacy", zoo.animal.name);    assertEquals(Zoo.Cat.class, zoo.animal.getClass());}

2.17、@JsonSubTypes

  • 表示子类注解（对应关系）

2.18、@JsonTypeName

  • 表示对应值

2.19、@JsonFormat

  • json格式化，一般是日期和字符串之间转换

  • public class EventWithFormat {    public String name;    @JsonFormat(      shape = JsonFormat.Shape.STRING,      pattern = "dd-MM-yyyy hh:mm:ss")    public Date eventDate;}@Testpublic void whenSerializingUsingJsonFormat_thenCorrect()  throws JsonProcessingException, ParseException {    SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");    df.setTimeZone(TimeZone.getTimeZone("UTC"));    String toParse = "20-12-2014 02:30:00";    Date date = df.parse(toParse);    EventWithFormat event = new EventWithFormat("party", date);        String result = new ObjectMapper().writeValueAsString(event);        assertThat(result, containsString(toParse));}

2.20、@JsonUnwrapped

  • 去掉属性外壳，有点类似java8 map flat 操作

  • public class UnwrappedUser {    public int id;    @JsonUnwrapped    public Name name;    public static class Name {        public String firstName;        public String lastName;    }}@Testpublic void whenSerializingUsingJsonUnwrapped_thenCorrect()  throws JsonProcessingException, ParseException {    UnwrappedUser.Name name = new UnwrappedUser.Name("John", "Doe");    UnwrappedUser user = new UnwrappedUser(1, name);    String result = new ObjectMapper().writeValueAsString(user);        assertThat(result, containsString("John"));    assertThat(result, not(containsString("name")));}

  • 输出

    • {    "id":1,    "firstName":"John",    "lastName":"Doe"}

2.21、@JsonView

  • json视图，定义一些标签，每次只序列化特定视图

  • public class Views {    public static class Public {}    public static class Internal extends Public {}}public class Item {    @JsonView(Views.Public.class)    public int id;    @JsonView(Views.Public.class)    public String itemName;    @JsonView(Views.Internal.class)    public String ownerName;}@Testpublic void whenSerializingUsingJsonView_thenCorrect()  throws JsonProcessingException {    Item item = new Item(2, "book", "John");    String result = new ObjectMapper()      .writerWithView(Views.Public.class)      .writeValueAsString(item);    assertThat(result, containsString("book"));    assertThat(result, containsString("2"));    assertThat(result, not(containsString("John")));}

2.22、@JsonManagedReference

  • @JsonBackReference

  • 解决循环引用问题

  • public class ItemWithRef {
    public int id;
    public String itemName;

    @JsonManagedReference
    public UserWithRef owner;
}

public class UserWithRef {
    public int id;
    public String name;

    @JsonBackReference
    public List<ItemWithRef> userItems;
}

@Test
public void whenSerializingUsingJacksonReferenceAnnotation_thenCorrect()
  throws JsonProcessingException {
    UserWithRef user = new UserWithRef(1, "John");
    ItemWithRef item = new ItemWithRef(2, "book", user);
    user.addItem(item);

    String result = new ObjectMapper().writeValueAsString(item);

    assertThat(result, containsString("book"));
    assertThat(result, containsString("John"));
    assertThat(result, not(containsString("userItems")));
}

2.23、@JsonIdentityInfo

  • 也是解决循环依赖问题，它会标记循环起点

  • @JsonIdentityInfo(
  generator = ObjectIdGenerators.PropertyGenerator.class,
  property = "id")
public class ItemWithIdentity {
    public int id;
    public String itemName;
    public UserWithIdentity owner;
}


@JsonIdentityInfo(
  generator = ObjectIdGenerators.PropertyGenerator.class,
  property = "id")
public class UserWithIdentity {
    public int id;
    public String name;
    public List<ItemWithIdentity> userItems;
}

@Test
public void whenSerializingUsingJsonIdentityInfo_thenCorrect()
  throws JsonProcessingException {
    UserWithIdentity user = new UserWithIdentity(1, "John");
    ItemWithIdentity item = new ItemWithIdentity(2, "book", user);
    user.addItem(item);

    String result = new ObjectMapper().writeValueAsString(item);

    assertThat(result, containsString("book"));
    assertThat(result, containsString("John"));
    assertThat(result, containsString("userItems"));
}

  • 输出

    • {
    "id": 2,
    "itemName": "book",
    "owner": {
        "id": 1,
        "name": "John",
        "userItems": [
            2
        ]
    }
}

2.24、@JsonFilter

  • json过滤器，过滤某个字段

  • @JsonFilter("myFilter")
public class BeanWithFilter {
    public int id;
    public String name;
}

@Test
public void whenSerializingUsingJsonFilter_thenCorrect()
  throws JsonProcessingException {
    BeanWithFilter bean = new BeanWithFilter(1, "My bean");

    FilterProvider filters 
      = new SimpleFilterProvider().addFilter(
        "myFilter", 
        SimpleBeanPropertyFilter.filterOutAllExcept("name"));

    String result = new ObjectMapper()
      .writer(filters)
      .writeValueAsString(bean);

    assertThat(result, containsString("My bean"));
    assertThat(result, not(containsString("id")));
}

引用

例子来自于： [Jackson Annotation Examples](

Jackson 入门Jackson 入门
06-11
Jackson 入门 Jackson 入门 Jackson 入门
Jackson实例入门
04-26
NULL 博文链接：https://rensanning.iteye.com/blog/2372409
jackson快速入门
自由的天空
08-02 396
1. 背景 目前维护的产品使用jackson处理json，现整理一下jackson相关资料，希望对初次接触jackson的新手有所帮助。    jackson主页: http://jackson.codehaus.org/    jackson document: http://wiki.fasterxml.com/JacksonJavaDocs    JacksonInFiveMinute...
Jackson入门
千霜的博客
02-24 440
目录一 介绍二 Maven配置三 使用3.1 POJO与JSON3.2 Map,List与JSON四 注解4.1 更改属性名4.2 忽略属性参考 一 介绍 jackson用于在java对象与JSON之间映射。jackson有三种处理JSON的处理模型： Data Binding：在JSON与简单对象（POJO，Maps, Lists, Strings, Numbers, Booleans 和nu...
jackson 入门教程
feisenianshao的博客
07-13 604
json 的基础知识。 array and list –> wrap in [ ] object –> wrap in { } jackson 需要注意 需要序列化的pojo 的属性必须具有setter和getter方法，或者是public的。 java pojo –> json一个简单的例子： 下面的例子是采用databind 的方式生成 json 串的。 ObjectMapper objec
Spring MVC环境搭建与常用注解使用示例
结合其描述“springmvc搭建环境demo，内有部分注解的使用说明”以及标签信息（如Spring MVC、注解、环境搭建、控制器、请求映射等），可以判断该项目是一个典型的 Spring MVC 入门级示例工程，主要用于演示如何从零...
基于Maven搭建的Spring MVC入门示例项目
“入门示例”强调其教学属性，意味着项目结构简单、注释清晰、无多余复杂配置，非常适合刚接触Spring生态的新手理解基本概念和流程。“Webapp”进一步确认了其Web应用的本质，而压缩包内子文件名为“Maven Webapp”...
Jackson 快速入门
SolidCocoi的博客
04-06 2798
Jackson 快速入门
Jackson快速入门
Less Is More
08-26 725
Java生态圈中有很多处理JSON和XML格式化的类库，Jackson是其中比较著名的一个。虽然JDK自带了XML处理类库，但是相对来说比较低级，使用本文介绍的Jackson等高级类库处理起来会方便很多。 引入类库 由于Jackson相关类库按照功能分为几个相对独立的，所以需要同时引入多个类库，为了方便我将版本号单独提取出来设置，相关Gradle配置如下。 ext { jacksonVersion = '2.9.5' } dependencies { compile group: '...
一篇Jackson入门教程奉上
果冻想
11-07 813
前言现在开发，基本上都离不开JSON格式，也都会涉及到对象与JSON的序列化与反序列化。在Java的世界中，就不得不说fastjson和jackson了，这两个库基本上统治了Java世界...
java中的jackson_Java中Jackson快速入门
weixin_39546092的博客
02-16 720
Java生态圈中有很多处理JSON和XML格式化的类库，Jackson是其中比较著名的一个。虽然JDK自带了XML处理类库，但是相对来说比较低级，使用本文介绍的Jackson等高级类库处理起来会方便很多。引入类库由于Jackson相关类库按照功能分为几个相对独立的，所以需要同时引入多个类库，为了方便我将版本号单独提取出来设置，相关Gradle配置如下。ext {jacksonVersion = '...
Jackson详解
最新发布
从基础到源码解析的学习记录
07-22 4769
Jackson库的核心功能是将Java对象转换为json字符串（序列化）以及将json字符串转换为Java对象（反序列化）SpringMVC默认json解析器便是Jackson与其他Java的json的框架相比Jackson 解析大的json文件速度比较快Jackson 运行时占用内存比较低，性能比较好Jackson 有灵活的API，可以很容易进行扩展和定制核心模块由三部分组成jackson-core，核心包。
一文详细看懂 Jackson 框架 + 上手
qq_41826542的博客
03-13 3895
配置大全spring:jackson:# 设置属性命名策略,对应jackson下PropertyNamingStrategy中的常量值，SNAKE_CASE-返回的json驼峰式转下划线，json body下划线传到后端自动转驼峰式# 全局设置@JsonFormat的格式pattern# 当地时区# 设置全局时区# 常用，全局设置pojo或被@JsonInclude注解的属性的序列化方式。
Jackson使用详细介绍
AG.『Feng』的博客
01-29 6267
Jackson使用详细介绍
Jackson详细介绍
eff666的博客
02-28 9168
Jackson是基于Java平台的一套数据处理工具，被称为”最好的Java Json解析器”。它可以使我们高效、简便的处理json字符串。1、Jackson的版本以及maven依赖重点内容<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值