Jackson的基本用法

最新推荐文章于 2024-06-07 14:20:49 发布
最新推荐文章于 2024-06-07 14:20:49 发布
阅读量244 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： json java
原文链接：http://www.cnblogs.com/whuxz/p/9538357.html
本文介绍了Java中使用Jackson处理JSON的相关内容。首先说明了Jackson依赖，引用jackson - databind即可。接着详细阐述了常用注解，如@JsonAnyGetter、@JsonIgnoreProperties等的作用及用法，还提及ObjectMapper常用配置，Jackson模型待补充。

一、依赖

    jackson依赖3个包，由于jackson-databind依赖于jackson-annotations，jackson-core，所以实际引用jackson-databind即可以。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.8.1</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.8.1</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.8.1</version>
</dependency>

 

二、常用注解

1、@JsonAnyGetter, @JsonAnySetter：用于将字符串中未映射到属性的值放在一个map；

@Data
public class DatasetDynamic {
    private String album_id;
    private String album_title;
    @J
    private Map<String , Object> otherProperties = new HashMap<String , Object>();

    @JsonCreator
    public DatasetDynamic(@JsonProperty("album_id") String album_id, @JsonProperty("album_title") String album_title) {
        this.album_id = album_id;
        this.album_title = album_title;
    }
    public Object get(String name) {
        return otherProperties.get(name);
    }
    @JsonAnyGetter
    public Map<String , Object> any() {
        return otherProperties;
    }
    @JsonAnySetter
    public void set(String name, Object value) {
        otherProperties.put(name, value);
    }
}

      {
      "album_id":"123",
      "album_title":"haha",
      "test1":"heihei",
      "test2":222
      }

　　输出：DatasetDynamic(album_id=123, album_title=haha, otherProperties={test2=222, test1=heihei}) 

 

2、@JsonIgnoreProperties和@JsonIgnore: 

用于标记属性，在json与java之间相互转化时，将忽略被此注解标记的属性。@JsonIgnoreProperties是类级别注解，可以忽略多个属性，@JsonIgnore用来标注单个属性。

@JsonIgnoreProperties({ "album_title" })
public class DatasetFilter {
    @JsonIgnore
    private String album_id;
    private String album_title;
    private Map<String , Object> otherProperties = new HashMap<String , Object>();
    private String album_comments;
}

　　

3、@JsonRawValue： 直接显示属性值，对字符串，即是去掉双引号。

public class PersonRawValue {
    public long   personId = 0;
    //@JsonRawValue
    public String address  = "$#";
}
不加注解显示：{"personId":0,"address":"$#"}
加注解显示：{"personId":0,"address":$#}

4、@JsonPropertyOrder：指对象属性序列化的顺序，指定顺序的先显示，没有指定的按照默认顺序在后面，@JsonFormat：时间格式化

@JsonPropertyOrder({"id","time","name"})
public class User {
   private Long id;
   private String name;
   private BigDecimal age;
   @JsonFormat(pattern = "yyyy-MM-dd")
   private Date date;
   @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
   private Timestamp time;
   public User(Long id, String name, Date date) {
      this.id = id;
      this.name = name;
      this.date = date;
   }
}

输出结果：

{
  "id" : 2,
  "time" : null,
  "name" : "theUser",
  "age" : null,
  "date" : "2018-07-23"
}

 

5、@JsonInclude：控制序列化时的显示，将该标记放在属性上，如果该属性为NULL则不参与序列化 。如果放在类上边,那对这个类的全部属性起作用 

Include.Include.ALWAYS 默认 
Include.NON_DEFAULT 属性为默认值不序列化 
Include.NON_EMPTY 属性为空（“”）或者为 NULL 都不序列化 
Include.NON_NULL 属性为NULL 不序列化 

@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class User {
   private Long id;
}

 

6、@JsonSerialize，@JsonDeserialize： 自定义序列化

// 自定义反序列化
public class ItemDeserializer extends JsonDeserializer<Item> {
    @Override
    public Item deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
            throws IOException, JsonProcessingException {
        JsonNode jsonNode = jsonParser.readValueAsTree();
        int id = jsonNode.path("id").intValue();
        String itemName = jsonNode.get("itemName").asText();
        Long userId = jsonNode.get("owner").asLong();
        return new Item(id, itemName, new User(userId, ""));
    }
}
// 自定义序列化
public class ItemSerializer extends JsonSerializer<Item> {
    @Override public void serialize(Item item, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeNumberField("id", item.id);
        jsonGenerator.writeStringField("itemName", item.itemName);
        jsonGenerator.writeNumberField("owner", item.getOwner().getId());
        //jsonGenerator.writeObjectField("owner", item.owner);
        jsonGenerator.writeEndObject();
    }
}

 应用方法有2种：

（1）注解方式：

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonSerialize(using = ItemSerializer.class)
@JsonDeserialize(using = ItemDeserializer.class)
public class Item {
    public int id;
    public String itemName;
    public User owner;
}

（2）代码方式：

SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Item.class, new ItemSerializer());
simpleModule.addDeserializer(Item.class, new ItemDeserializer());
ObjectMapper mapper = JacksonUtil.getNewDefaultMapper();
mapper.registerModule(simpleModule);
//...

 

7、@JsonCreator ：解决多态性问题，通过注解，可以在序列化时，保存具体的类型信息到json中，当json反序列到java对象时，就可以根据具体类型信息创建正确的java对象。

当str -> bean时会调用@JsonCreator注解的构造函数，如果没有此注解，则默认调用无参构造函数

@Data
public class Lion extends Animal {
    private String name;
    @JsonCreator
    public Lion(@JsonProperty("name") String name) {
        this.name = name;
    }
}
public static void main(String[] args) throws IOException {
    Lion lion = new Lion("jack");
    log.info(JacksonUtil.toJson(lion));
    log.info(JacksonUtil.jsonToBean(JacksonUtil.toJson(lion), Lion.class));
}

 输出：

  "@class" : "vo.Lion",
  "name" : "jack",
  "sound" : null,
  "type" : null,
  "endangered" : null
} 
 [2018-08-26 21:03:47] main  INFO test.annotation.Test1.main(Test1.java:26) Lion(name=jack)

 修改类：

@Data
@NoArgsConstructor
public class Lion extends Animal {
    private String name;
    public Lion(String name) {
        this.name = name;
    }
}
// 输出结果：
  "@class" : "vo.Lion",
  "name" : "jack",
  "sound" : null,
  "type" : null,
  "endangered" : null
} 
 [2018-08-26 21:08:46] main  INFO test.annotation.Test1.main(Test1.java:26) Lion(name=jack)

 

8、@JsonTypeInfo、@JsonSubTypes：解决多态性问题，通过注解，可以在序列化时，保存具体的类型信息到json中，当json反序列到java对象时，就可以根据具体类型信息创建正确的java对象

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class")
@JsonSubTypes({ @Type(value = Lion.class, name = "lion"), @Type(value = Elephant.class, name = "elephant") })
@Data
public abstract class Animal {
    @JsonProperty("name")
    String name;
    @JsonProperty("sound")
    String sound;
    @JsonProperty("type")
    String type;
    @JsonProperty("endangered")
    Boolean endangered;
}

@Data
public class Zoo {
    public String name;
    public String city;
    public List<Animal> animals = new ArrayList<Animal>();

    @JsonCreator
    public Zoo(@JsonProperty("name") String name,@JsonProperty("city") String city) {
        this.name = name;
        this.city = city;
    }
    public List<Animal> addAnimal(Animal animal) {
        animals.add(animal);
        return animals;
    }
}

@Data
@NoArgsConstructor
public class Lion extends Animal {
    private String name;
    @JsonCreator
    public Lion(@JsonProperty("name") String name) {
        this.name = name;
    }
}

@Data
@NoArgsConstructor
public class Elephant extends Animal {
    @JsonProperty
    private String name;
    @JsonCreator
    public Elephant(@JsonProperty("name") String name) {
        this.name = name;
    }
}

    public static void main(String[] args) throws IOException {
        Zoo zoo = new Zoo("London zoo", "London");
        Lion lion = new Lion("Simba");
        Elephant elephant = new Elephant("Manny");
        zoo.addAnimal(lion).add(elephant);
        String jsonStr = JacksonUtil.toJson(zoo);
        log.info(jsonStr);
        log.info(JacksonUtil.jsonToBean(jsonStr, Zoo.class));
    }

 输出：

[2018-08-26 21:18:24] main  INFO test.annotation.Test1.main(Test1.java:26) {
  "name" : "London zoo",
  "city" : "London",
  "animals" : [ {
    "@class" : "vo.Lion",
    "name" : "Simba",
    "sound" : null,
    "type" : null,
    "endangered" : null
  }, {
    "@class" : "vo.Elephant",
    "name" : "Manny",
    "sound" : null,
    "type" : null,
    "endangered" : null
  } ]
} 
 [2018-08-26 21:18:24] main  INFO test.annotation.Test1.main(Test1.java:27) Zoo(name=London zoo, city=London, animals=[Lion(name=Simba), Elephant(name=Manny)])

 这里面有个问题，Jackson是如何识别具体的实现类？有2个问题解答：（1）区分实现类的标识？（2）标识如何写入？

注解：@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class")  //使用类限定名区分，标识作为数据的史弟属性定入

具体参数：

use:定义使用哪一种类型识别码，它有下面几个可选值：
1、JsonTypeInfo.Id.CLASS：使用完全限定类名做识别
2、JsonTypeInfo.Id.MINIMAL_CLASS：若基类和子类在同一包类，使用类名(忽略包名)作为识别码
3、JsonTypeInfo.Id.NAME：一个合乎逻辑的指定名称
4、JsonTypeInfo.Id.CUSTOM：自定义识别码，
5、JsonTypeInfo.Id.NONE：不使用识别码
include(可选):指定识别码是如何被包含进去的，它有下面几个可选值：
1、JsonTypeInfo.As.PROPERTY：作为数据的兄弟属性
2、JsonTypeInfo.As.EXISTING_PROPERTY：作为POJO中已经存在的属性
3、JsonTypeInfo.As.EXTERNAL_PROPERTY：作为扩展属性
4、JsonTypeInfo.As.WRAPPER_OBJECT：作为一个包装的对象
5、JsonTypeInfo.As.WRAPPER_ARRAY：作为一个包装的数组

 

三、ObjectMapper常用配置：

    private static ObjectMapper mapper = new ObjectMapper();

    static {
        mapper.enable(SerializationFeature.INDENT_OUTPUT); //化化输出
        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); //序列化空的POPJ
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); //不将date转化成timestamp
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); //忽略未知属性
        mapper.disable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); //不将空转化为null
        mapper.disable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES); //允许没有引号的字段名（非标准）
        mapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }

 

四、Jackson模型：【待补充】

 

附1：封装类

/**
 * 例1：String str = JacksonUtil.toJson(userList);
 * 例2：User u = JacksonUtil.jsonToBean(str, User.class);
 * 例3：List<User> userList = JacksonUtil.jsonTo(str, new TypeReference<List<User>>(){});
 * 例4：Map<String, User> map = JacksonUtil.jsonTo(str, new TypeReference<Map<String, User>(){});
 */

@Log4j2
public class JacksonUtil {
    private static ObjectMapper mapper = new ObjectMapper();

    static {
        mapper.enable(SerializationFeature.INDENT_OUTPUT); //化化输出
        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); //序列化空的POPJ
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); //不将date转化成timestamp
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); //忽略未知属性
        mapper.disable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); //不将空转化为null
        mapper.disable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES); //允许没有引号的字段名（非标准）
        mapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }

    public JacksonUtil() {
    }

    public static ObjectMapper getNewMapper() {
        return new ObjectMapper();
    }

    public static ObjectMapper getNewDefaultMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); //序列化空的POPJ
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); //不将date转化成timestamp
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); //忽略未知属性
        mapper.disable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); //不将空转化为null
        mapper.disable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES); //允许没有引号的字段名（非标准）
        mapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        return mapper;
    }

    public static <T> String toJson(T t) {
        return toJson(t, null);
    }

    public static <T> T jsonTo(String json, TypeReference<T> typeReference) {
        return jsonTo(json, typeReference, null);
    }

    public static <T> T jsonToBean(String json, Class<T> clazz) {
        return jsonToBean(json, clazz, null);
    }

    public static <T> T fileToBean(File file, Class<T> clazz) {
        return fileToBean(file, clazz, null);
    }

    public static <T> String toJson(T t, ObjectMapper objectMapper) {
        if (Objects.isNull(t))
            return null;
        try {
            return objectMapper == null ? mapper.writeValueAsString(t) : objectMapper.writeValueAsString(t);
        } catch (JsonProcessingException e) {
            log.error("to json error:" + t, e);
            return null;
        }
    }

    public static <T> T jsonToBean(String json, Class<T> clazz, ObjectMapper objectMapper) {
        if (StringUtils.isBlank(json))
            return null;
        try {
            return objectMapper == null ? mapper.readValue(json, clazz) : objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            log.error("json to bean error:" + json, e);
            return null;
        }
    }

    public static <T> T fileToBean(File file, Class<T> clazz, ObjectMapper objectMapper) {
        if (!file.exists())
            return null;
        try {
            return objectMapper == null ? mapper.readValue(file, clazz) : objectMapper.readValue(file, clazz);
        } catch (IOException e) {
            log.error("file to bean error:" + file.getName(), e);
            return null;
        }
    }

    public static <T> T jsonTo(String json, TypeReference<T> typeReference, ObjectMapper objectMapper) {
        if (StringUtils.isBlank(json))
            return null;
        try {
            return objectMapper == null ? mapper.readValue(json, typeReference) : objectMapper.readValue(json, typeReference);
        } catch (Exception e) {
            log.error("json to map error:" + json, e);
            return null;
        }
    }

    public static <T> T jsonTo(String json, Class<T> clazz, ObjectMapper objectMapper) {
        if (StringUtils.isBlank(json))
            return null;
        try {
            return mapper.readValue(json, new TypeReference<T>(){});
        } catch (Exception e) {
            log.error("json to map error:" + json, e);
            return null;
        }
    }
}

　　

 

 

 









 

转载于:https://www.cnblogs.com/whuxz/p/9538357.html

jackson所需要的包
08-02
包括的内容为jackson-module-jaxb-annotations-2.8.1.jar、jackson-jr-all-2.4.3.jar、jackson-dataformat-xml-2.7.4.jar、jackson-databind-2.4.5.jar、jackson-core-2.2.3.jar、com.fasterxml.jackson.annotations.jar。欢迎你下载使用，谢谢！
Jackson使用方法1
08-08
在本文中，我们将深入探讨Jackson库的基本使用方法，特别是如何将JavaBean对象转换为JSON字符串，并了解如何忽略特定属性。 首先，使用Jackson库进行JSON操作，你需要引入相应的jar包。在标题和描述中提到的，你...
Jackson 的使用
飞一站的博客
09-23 652
目录 Jackson 的使用 一些转换参数设置 设置对象不存在不报错和处理long格式日期 不返回null值对象属性 指定属性绑定关系 简单的泛型对象反系列化 多层嵌套的泛型对象的反系列化 一些坑点 Jackson 的使用 一些转换参数设置 设置对象不存在不报错和处理long格式日期 - /** - * 返回mapper，忽略未知参数、使用long解析时间 - * - * @return - */ - public stati
字符串json怎么把双引号去掉_如何删除双引号"从Json字符串
weixin_39545017的博客
12-21 1075
I'm getting double quotes for below 'data' field in JSON response like this -{"bID" : 1000013253,"bTypeID" : 1,"name" : "Test1""data" : "{"bc": { "b": { "t": 1, "r": 1, "c": "n...
ObjectMapper 的一些坑
AlbenXie的博客
08-19 2126
相信做过Java 开发对这个类应该不陌生,没错,这个类是jackson提供的，主要是用来把对象转换成为一个json字符串返回到前端, 现在大部分数据交换都是以json来传输的,所以这个很重要,那你到底又对这个类有着有多少了解呢，下面我说一下我遇到的一些坑 首先，先把我要说的几个坑需要设置的属性贴出来先 ObjectMapper objectMapper = new ObjectMapper(); //序列化的时候序列对象的所有属性 objectMapper.setSerializationIn
jackson生成json字符串不加双引号
kavit_587的专栏
05-11 9809
ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false); String items = objectMapper.writeValueAsString(shareImages); 做个记录mark下，怕忘了
Jackson的用法实例分析
09-04
Jackson是Java中广泛使用的JSON处理库，以其高效和强大的功能而闻名。Jackson库提供了一组API，用于将Java对象转换为JSON格式的数据，反之亦然，即序列化和反序列化。本文将深入探讨Jackson的核心类`ObjectMapper`，...
深入解析Jackson的基本使用方法
在本篇博文中，我们将探讨Jackson的简单用法，这将涵盖如何使用Jackson将Java对象转换为JSON格式，以及如何将JSON字符串解析回Java对象。对于想要在项目中快速实现JSON数据处理的开发者而言，Jackson提供了一个轻量...
Java之Jackson的基本使用案例讲解.docx
10-17
除了基本的对象绑定，Jackson还支持更复杂的JSON处理，如类型转换、配置定制、自定义序列化和反序列化逻辑，以及对JSON Schema的支持。这些特性使得Jackson成为Java开发中处理JSON的首选库之一。通过熟练掌握Jackson...
Jackson使用方法1.docx
08-25
本文将详细介绍Jackson的使用方法，包括基本配置、对象转换为JSON字符串、忽略特定属性等核心概念。 首先，要使用Jackson库，你需要在项目中引入三个核心的JAR包： 1. `jackson-annotations-2.2.1.jar`：包含...
Jackson依赖的资源包
01-03
Jackson所依赖的一些资源包（commons-beanutils-1.7.0\commons-beanutils-1.7.0\commons-beanutils-1.7.0\ezmorph-1.0.2\jackson-core\json-lib-2.3-jdk15\jackson-mapper）
jackson解析必备的三个jar包
11-17
jackson解析必备的三个jar包：jackson-annotations-2.2.3、jackson-core-2.2.3、jackson-databind-2.2.3
使用jackson的jar包的相关问题
weixin_43358264的博客
10-28 1375
1.使用jackson需要导入的jar包以及导入的方法 需要的jar包一般含有三个： jackson-annotations-2.1.2.jar jackson-core-2.1.2.jar jackson-databind-2.1.2.jar 其中版本自选 下载地址 所需jar包的各个版本的下载地址https://repo1.maven.org/maven2/com/fasterxml/jackson/core/ 下载之后直接导入如下图所示的位置： 2.使用jackson可能出现的问题如下图 ..
jackson改变json值_除了FastJson，你也应该了解一下Jackson（二）
weixin_39678426的博客
11-22 434
概览上一篇文章介绍了Jackson中的映射器ObjectMapper，以及如何使用它来实现Json与Java对象之间的序列化和反序列化，最后介绍了Jackson中一些序列化/反序列化的高级特性。而本文将会介绍Jackson中的一些常用的(序列化/反序列化)注解，并且通过示例来演示如何使用这些注解，从而来提高我们在处理Json上的工作效率。序列化注解@JsonAnyGetter@JsonA...
spring:基于SimpleModule实现动态管理jackson的序列化器(JsonSerializer)和反序列化器(JsonDeserializer)
最新发布
10km的专栏
06-07 2252
这些例子，给我一个错觉，以为必须要在构造ObjectMapper实例时就要将定义了指定类型的序列化器的Module实例注册到 ObjectMapper实例才能生效。最近的工作中，我需要实现能在spring环境下，在服务运行时根据服务方法的不同动态修改数据类型的序列化器。我当前使用的jackson版本是2.12.5，我以为高版本会增加这样的方法，但是我查了最新版本，仍然没有，好吧，只能另外想办法了。有了上面的经验，我又如法炮制，研究了增加反序列化器的方法。如果我增加了序列化器后，能够序列化器清除缓存，那么。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值