Jackson使用指南

最新推荐文章于 2024-07-05 09:53:36 发布
最新推荐文章于 2024-07-05 09:53:36 发布
阅读量220 收藏
点赞数
文章标签： json java runtime
原文链接：https://juejin.im/post/5c4970c6e51d4551b7482487
版权

原文链接? Jackson使用指南

从事JAVA开发工作以来,一直都离不开Jackson的序列化反序列化,对于Jackson的使用也一直处于够用但不深入的状态，下面是日常使用过程中对Jackson的总结。

Jackson常用注解

序列化注解

@JsonAnyGetter

像普通属性一样序列化Map

public class ExtendableBean {
    public String name;
    private Map<String, String> properties;
 
    @JsonAnyGetter
    public Map<String, String> getProperties() {
        return properties;
    }
}
复制代码

序列化示例：

{
    "name":"My bean",
    "attr2":"val2",
    "attr1":"val1"
}
复制代码

@JsonGetter

将指定的方法标记为getter方法。可以用来代替@JsonProperty

public class MyBean {
    public int id;
    private String name;
 
    @JsonGetter("name")
    public String getTheName() {
        return name;
    }
}
复制代码

序列化示例：

{
    "id": 1,
    "name":"My bean"
}
复制代码

@JsonPropertyOrder

用在类上，在序列化的时候自定义属性输出顺序

@JsonPropertyOrder({ "name", "id" })
public class MyBean {
    public int id;
    public String name;
}
复制代码

序列化示例：

{
    "name":"My bean",
    "id": 1
}
复制代码

@JsonRawValue

完全按照原样序列化属性的值

public class RawBean {
    public String name;
 
    @JsonRawValue
    public String json;
}
复制代码

例如：

RawBean bean = new RawBean("My bean", "{\"attr\":false}");
复制代码

将序列化为：

{
    "name":"My bean",
    "json":{
        "attr":false
    }
}
复制代码

而不是：

{
    "name":"My bean",
    "json":"{\"attr\":false}"
}
复制代码

@JsonValue

定义整个实体的序列化方法，Jackson将会使用该方法的输出作为序列化输出。

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;
    }
}
复制代码

序列化示例：

{
  "name": "Type 2"
}
复制代码

@JsonRootName

如果需要将实体包装一层，可以使用@JsonRootName来指定根包装器的名称

@JsonRootName(value = "user")
public class UserWithRoot {
    public int id;
    public String name;
}
复制代码

序列化示例：

{
    "user": {
        "id": 1,
        "name": "John"
    }
}
复制代码

如果不用该注解，将会序列化为：

{
    "id": 1,
    "name": "John"
}
复制代码

@JsonSerialize

用于指定自定义序列化器来序列化实体

public class Event {
    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));
    }
}
复制代码

输出示例：

{
  "name": "test",
  "eventDate": "20-12-2014 02:30:00"
}
复制代码

反序列化注解

@JsonCreator

指定反序列化使用的构造函数或方法

待反序列化Json示例：

{
    "id":1,
    "theName":"My bean"
}
复制代码
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;
    }
}
复制代码

@JacksonInject

指定某个字段从注入赋值，而不是从Json

public class BeanWithInject {
    @JacksonInject
    public int id;
     
    public String name;
}
复制代码

示例用法：

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);
复制代码

@JsonAnySetter

在反序列化时，将Map当成普通属性

待反序列化Json：

{
    "name":"My bean",
    "attr2":"val2",
    "attr1":"val1"
}
复制代码
public class ExtendableBean {
    public String name;
    private Map<String, String> properties;
 
    @JsonAnySetter
    public void add(String key, String value) {
        properties.put(key, value);
    }
}
复制代码

properties字段的值将会是由 attr2 -> val2,attr1 -> val1组成的键值对。

@JsonSetter

将方法标记为setter方法，可以指定属性名称

public class MyBean {
    public int id;
    private String name;
 
    @JsonSetter("name")
    public void setTheName(String name) {
        this.name = name;
    }
}
复制代码

@JsonDeserialize

用于指定自定义反序列化器来反序列化实体

public class Event {
    public String name;
 
    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date eventDate;
}
复制代码

对应的反序列化器：

public class CustomDateDeserializer
  extends StdDeserializer<Date> {
 
    private static SimpleDateFormat formatter
      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
 
    public CustomDateDeserializer() { 
        this(null); 
    } 
 
    public CustomDateDeserializer(Class<?> vc) { 
        super(vc); 
    }
 
    @Override
    public Date deserialize(
      JsonParser jsonparser, DeserializationContext context) 
      throws IOException {
         
        String date = jsonparser.getText();
        try {
            return formatter.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}
复制代码

Jackson设置属性是否参与序列化

@JsonIgnoreProperties

在类上指定要忽略的属性

@JsonIgnoreProperties({ "id" })
public class BeanWithIgnore {
    public int id;
    public String name;
}
复制代码

@JsonIgnore

在具体属性上忽略，使其不参与序列化过程

public class BeanWithIgnore {
    @JsonIgnore
    public int id;
 
    public String name;
}
复制代码

与@JsonIgnoreProperties是等效的。

@JsonIgnoreType

用在类上，将忽略该类所有属性

public class User {
    public int id;
    public Name name;
 
    @JsonIgnoreType
    public static class Name {
        public String firstName;
        public String lastName;
    }
}
复制代码

@JsonInclude

用于排除值为empty/null/default的属性

@JsonInclude(Include.NON_NULL)
public class MyBean {
    public int id;
    public String name;
}
复制代码

@JsonAutoDetect

强制序列化私有属性，不管它有没有getter方法

@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class PrivateBean {
    private int id;
    private String name;
}
复制代码

Jackson处理多态

一般都是组合起来使用，有下面三个注解：

  • @JsonTypeInfo

指定序列化中包含的类型信息的详细信息

  • @JsonSubTypes

指定带注释类型的子类型

  • @JsonTypeName

指定用于带注释的类的逻辑类型名称

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;
    }
}
复制代码

上述例子中，指定属性type为判断具体子类的依据，例如：type=dog，将被序列化为Dog类型。

Jackson通用注解（序列化反序列化都生效）

@JsonProperty

指定JSON中的属性名称

public class MyBean {
    public int id;
    private String name;
 
    @JsonProperty("name")
    public void setTheName(String name) {
        this.name = name;
    }
 
    @JsonProperty("name")
    public String getTheName() {
        return name;
    }
}
复制代码

@JsonFormat

用于在序列化日期/时间值时指定格式。

public class Event {
    public String name;
 
    @JsonFormat(
      shape = JsonFormat.Shape.STRING,
      pattern = "dd-MM-yyyy hh:mm:ss")
    public Date eventDate;
}
复制代码

@JsonUnwrapped

将对象中所有的属性与当前平级，不太好描述，简单说就是拆开包装。

public class UnwrappedUser {
    public int id;
 
    @JsonUnwrapped
    public Name name;
 
    public static class Name {
        public String firstName;
        public String lastName;
    }
}
复制代码

序列化示例：

{
    "id":1,
    "firstName":"John",
    "lastName":"Doe"
}
复制代码

如果不加@JsonUnwrapped注解，将被序列化为：

{
    "id":1,
    "name": {
        "firstName":"John",
        "lastName":"Doe"
    }
}
复制代码

@JsonView

指定视图，类似分组进行序列化/反序列化

定义视图：

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;
}
复制代码

序列化示例：

String result = new ObjectMapper()
  .writerWithView(Views.Public.class)
  .writeValueAsString(item);
复制代码

这时，将只会序列化id和itemName字段

@JsonManagedReference, @JsonBackReference

@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;
}
复制代码

不加注解，会循环调用，导致内存溢出，这时候可以使用@JsonManagedReference和@JsonBackReference来避免内存溢出。

@JsonIdentityInfo

用于指定在序列化/反序列化值时使用对象标识，例如，处理无限递归类型的问题。

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

@JsonFilter

指定序列化期间要使用的过滤器。

@JsonFilter("myFilter")
public class BeanWithFilter {
    public int id;
    public String name;
}
复制代码

示例代码：

BeanWithFilter bean = new BeanWithFilter(1, "My bean");

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

String result = new ObjectMapper()
  .writer(filters)
  .writeValueAsString(bean);
复制代码

自定义Jackson注解

可以使用@JacksonAnnotationsInside来开发自定义注解

@Retention(RetentionPolicy.RUNTIME)
    @JacksonAnnotationsInside
    @JsonInclude(Include.NON_NULL)
    @JsonPropertyOrder({ "name", "id", "dateCreated" })
    public @interface CustomAnnotation {}
复制代码

如何使用自定义注解：

@CustomAnnotation
public class BeanWithCustomAnnotation {
    public int id;
    public String name;
    public Date dateCreated;
}
复制代码

自定义注解可以增强代码复用，把一些通用的Jackson注解组合起来，形成一个新注解，新注解可以代替组合的注解。

Jackson MixIn 注解

动态地为某些类型增加统一的Jackson注解

实体：

public class Item {
    public int id;
    public String itemName;
    public User owner;
}
复制代码

MixIn类：

@JsonIgnoreType
public class MyMixInForIgnoreType {}
复制代码

我们可以动态地让User类型不参与序列化：

Item item = new Item(1, "book", null);
ObjectMapper mapper = new ObjectMapper();
mapper.addMixIn(User.class, MyMixInForIgnoreType.class);
result = mapper.writeValueAsString(item);
复制代码

禁用Jackson注解

假设我们有一个带Jackson注解的实体：

@JsonInclude(Include.NON_NULL)
@JsonPropertyOrder({ "name", "id" })
public class MyBean {
    public int id;
    public String name;
}
复制代码

我们可以这样来禁用该实体上的所有Jackson注解：

MyBean bean = new MyBean(1, null);
ObjectMapper mapper = new ObjectMapper();
mapper.disable(MapperFeature.USE_ANNOTATIONS);
复制代码

Jackson的ObjectMapper用法

java类 转换为 json

可以直接序列化为Json字符串：

objectMapper.writeValueAsString(car);
复制代码

或者，可以序列化到文件，文件内容是Json字符串：

objectMapper.writeValue(new File("target/car.json"), car);
复制代码

json 转换为 java类

从字符串：

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
objectMapper.readValue(json, Car.class); 
复制代码

从文件：

objectMapper.readValue(new File("target/json_car.json"), Car.class);
复制代码

从URL：

objectMapper.readValue(new URL("target/json_car.json"), Car.class);
复制代码

json转换为Jackson JsonNode

String json = "{ \"color\" : \"Black\", \"type\" : \"FIAT\" }";
JsonNode jsonNode = objectMapper.readTree(json);
String color = jsonNode.get("color").asText();
// Output: color -> Black
复制代码

json 转换为 java集合

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
List<Car> listCar = objectMapper.readValue(jsonCarArray, new TypeReference<List<Car>>(){});
复制代码

json 转换为 Map

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Map<String, Object> map = objectMapper.readValue(json, new TypeReference<Map<String,Object>>(){});
复制代码

ObjectMapper的常用配置

忽略不识别的字段（json属性与目标实体存在属性上的差异）：

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
复制代码

允许原始值为null：

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);
复制代码

允许将枚举序列化/反序列化为数字：

objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);
复制代码

配置自定义序列化/反序列化器

假设有一个序列化器：

public class CustomCarSerializer extends StdSerializer<Car> {
     
    public CustomCarSerializer() {
        this(null);
    }
 
    public CustomCarSerializer(Class<Car> t) {
        super(t);
    }
 
    @Override
    public void serialize(
      Car car, JsonGenerator jsonGenerator, SerializerProvider serializer) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("car_brand", car.getType());
        jsonGenerator.writeEndObject();
    }
}
复制代码

一个反序列化器：

public class CustomCarDeserializer extends StdDeserializer<Car> {
     
    public CustomCarDeserializer() {
        this(null);
    }
 
    public CustomCarDeserializer(Class<?> vc) {
        super(vc);
    }
 
    @Override
    public Car deserialize(JsonParser parser, DeserializationContext deserializer) {
        Car car = new Car();
        ObjectCodec codec = parser.getCodec();
        JsonNode node = codec.readTree(parser);
         
        // try catch block
        JsonNode colorNode = node.get("color");
        String color = colorNode.asText();
        car.setColor(color);
        return car;
    }
}
复制代码

用ObjectMapper使用他们：

//添加自定义序列化器
module.addSerializer(Car.class, new CustomCarSerializer());
//添加自定义反序列化器
module.addDeserializer(Car.class, new CustomCarDeserializer());
复制代码

处理日期格式化

ObjectMapper objectMapper = new ObjectMapper();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
objectMapper.setDateFormat(df);
复制代码

处理集合

反序列化为数组：

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
Car[] cars = objectMapper.readValue(jsonCarArray, Car[].class);
复制代码

反序列化为集合：

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
List<Car> listCar = objectMapper.readValue(jsonCarArray, new TypeReference<List<Car>>(){});
复制代码

? 代码仓库 ? 参考文章

转载于:https://juejin.im/post/5c4970c6e51d4551b7482487

weixin_34088598
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jackson使用
xigedd的博客
04-18 477
jackson使用 文章目录jackson使用1、什么是jackson2、使用jackson1、导入依赖2、编写web.xml3、编写springmvc-servlet.xml4、编写User5、编写JackController6、测试结果3、解决乱码4、@RestController5、返回不同的对象6、整合工具类 1、什么是jackson JSON的一种解析工具 前面讲到在JavaScript层面上可以直接将对象和字符串进行互换 Jackson可以在java层面上将对象和字符串进行互换 2、使用j
@JsonTypeInfo 逻辑名称 @JsonSubTypes、@JsonTypeName
赵丙双的博客
05-05 7599
@JsonTypeInfo 逻辑名称 @JsonSubTypes、@JsonTypeName@JsonTypeName@JsonSubTypeExampleJava ObjectsSerializing and deserializinginclude = JsonTypeInfo.As.WRAPPER_OBJECT原文链接 @JsonTypeInfo 的 use = JsonTypeInfo.Id.CLASS，会将完全限定类名序列化为类型标识符。当非 Java 客户端使用被序列化的 JSON 时，Java
Jackson注解使用分析
骑个小蜗牛的博客
02-02 7066
Jackson常用注解 1. 常用注解汇总 2. 注解使用分析 @JsonInclude @JsonAnyGetter @JsonAnySetter @JsonNaming @JsonAutoDetect @JacksonInject @JsonAlias @JsonValue @JsonMerge @JsonRawValue @JsonEnumDefaultValue @JsonFilter @JsonSerialize @JsonDeserialize @JacksonAnnotation @Jacks
序列化 @JacksonAnnotationsInside
最新发布
qq_69998459的博客
07-05 247
JacksonAnnotationsInside是一个Jackson注解，用于指示在序列化和反序列化JSON时，只处理当前类的注解，而不处理继承自父类的注解。using属性指定了序列化器类DictDataJsonSerializer1，该类需要实现JsonSerializer接口并重写serialize方法来定义如何将对象序列化为JSON格式。通过使用这个注解，当Java对象被序列化为JSON时，会使用DictDataJsonSerializer1类中定义的序列化逻辑来转换对象为JSON格式。
jackson annotations注解详解
热门推荐
清风抚白杨
11-18 19万+
jackson 1.x和2.x版本的注解是放置在不同的包下的 1
Jackson 注解及配置大全
lizsy的博客
04-19 2726
注解应用于属性，反序列化时集合类型属性时，将Json中的元素与字段中的默认元素融合。
Jackson详解
Java后端技术栈
11-21 2946
Spring Boot框架中使用Jackson的处理总结_八一菜刀的专栏-CSDN博客 Spring Boot框架中使用Jackson的处理总结 1.前言 通常我们在使用Spring Boot框架时，如果没有特别指定接口的序列化类型，则会使用Spring Boot框架默认集成的Jackson框架进行处理，通过Jackson框架将服务端响应的数据序列化成JSON格式的数据。 本文主要针对在Spring Boot框架中使用Jackson进行处理的经验进行总结，同时也结合在实际开发场景中碰到的问题以及解决
Jackson框架使用指南.pdf
09-30
Jackson框架是Java中广泛使用的序列化和反序列化库，尤其在处理JSON数据时表现出色。它能够方便地将Java对象转换为JSON格式的字符串，同时也能将JSON字符串转换回Java对象，使得数据交换变得更加简单。相较于其他如...
Spring boot中Jackson的操作指南
08-26
Spring Boot 中 Jackson 的操作指南 Jackson 是一个流行的 Java 库，用来将 Java 对象转换为 JSON 格式，并将 JSON 转换回 Java 对象。在 Spring Boot 项目中，Jackson 是默认的 JSON 处理器。下面是关于 Spring ...
Jackson 开发指南
04-27
在开始使用Jackson之前，你需要下载相应的jar包。Jackson的全集jar包可以在官方网站上找到，例如在1.7.6版本，可以从http://jackson.codehaus.org/1.7.6/jackson-all-1.7.6.jar获取。如果需要处理XML，还需要添加...
Jackson简单用法
ywb201314的专栏
04-14 497
jackson简单用法 Name类： [java] view plain copy   public class Name {       private String firstName;       private String lastName;       public Name(){}       public Name(S
Jackson Annotation学习笔记
Varus学习笔记
11-17 5148
复制去Google翻译翻译结果
java：jackson 五：Custom Jackson Annotation
a232884c的博客
12-30 248
jackson自定义注解使用（包含自定义jackson的序列化器和反序列化器方式）
Jackson自定义序列化与反序列化注解
qq_32434535的博客
07-28 2701
Jackson自定义序列化与反序列化注解
jackson对json转化技巧
入眸幻灭的博客
03-23 1861
好多框架都使用jackson工具进行json转化，现介绍一些使用技巧，本篇使用的jackson版本是2.4.2涉及到的jar包：cglib-nodep-2.2.jar,jackson-annotations-2.4.2.jar,jackson-core-2.4.2.jar,jackson-databind-2.4.2.jar本文以数据服务的角度针对后台ElasticSearch和客户需求的场景进行...
Jackson之ObjectMapper对象的使用
blwinner的专栏
08-21 2万+
文章目录1 简介2 Jackson的数据绑定3 Jackson ObjectMapper对象示例4 反序列化ObjectMapper从JSON属性匹配到Java属性的过程从JSON字符串读取Java对象从JSON Reader对象读取Java对象从JSON文件读取Java对象从URL获取JSON数据读取Java对象从Java InputStream获取JSON数据读取Java对象从字节数组获取J...
Jackson第二篇【从JSON字符串中取值】
成长的道路我们一起走过……
10-28 724
     第一篇咱们主要学习了实体与json的相互转换的问题，但是咱们需要的是数据 你转换18遍我取不到数据也是扯淡，那么今天咱们就一起学习一下如何从使用Jackson从Json字符串中取值。废话不说直接上代码(注意第一篇里面的方法我都移到JsonProcessUtil里面了方便使用 )。     从Json字符串中取出指定节点的值   public ...
分享一个关于jackson的Json工具类
weixin_34364135的博客
08-03 136
直接贴代码： import org.codehaus.jackson.map.DeserializationConfig.Feature; import org.codehaus.jackson.map.ObjectMapper; import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion; import or...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值