阅读 242

ObjectMapper 如何忽略字段大小写

ObjectMapper 如何忽略字段大小写

这篇文章主要介绍了使用ObjectMapper实现忽略字段大小写操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

ObjectMapper 忽略字段大小写

核心代码：

1
2
3
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);

例子：

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Test{
    public static void main(String[] args) {
  try {
   A a = new A();
   a.lastname = "jack";
   ObjectMapper mapper = new ObjectMapper();
   mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
   mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
   A2 convertValue = new A2();
     mapper.updateValue(convertValue, a);
   System.out.println(convertValue);
  } catch (JsonMappingException e) {
   e.printStackTrace();
  }
 }
  
 public static class A{
  String lastname;
  public String getLastname() {
   return lastname;
  }
  
  public void setLastname(String lastname) {
   this.lastname = lastname;
  }
 }
  
 public static class A2{
  String lastName;
  
  public String getLastName() {
   return lastName;
  }
  
  public void setLastName(String lastName) {
   this.lastName = lastName;
  }
  
  @Override
  public String toString() {
   return "A2 [lastName=" + lastName + "]";
  }  
 }
}

ObjectMapper 的一些坑

相信做过Java 开发对这个类应该不陌生,没错,这个类是jackson提供的，主要是用来把对象转换成为一个json字符串返回到前端,

现在大部分数据交换都是以json来传输的,所以这个很重要,那你到底又对这个类有着有多少了解呢，下面我说一下我遇到的一些坑

首先，先把我要说的几个坑需要设置的属性贴出来先

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ObjectMapper objectMapper = new ObjectMapper();
   
  //序列化的时候序列对象的所有属性
  objectMapper.setSerializationInclusion(Include.ALWAYS);
   
  //反序列化的时候如果多了其他属性,不抛出异常
  objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
   
  //如果是空对象的时候,不抛异常
  objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
   
  //取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
  objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
  objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"))

简单说一下这个类的基本用法，以下采用代码块加截图的形式来说明和部分文字件数

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
package com.shiro.test;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class Main2 {
 public static void main(String[] args) throws Exception{
  ObjectMapper objectMapper = new ObjectMapper();
  //序列化的时候序列对象的所有属性
  objectMapper.setSerializationInclusion(Include.ALWAYS);
  //取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
  objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
  objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
   
  Person person = new Person(1, "zxc", new Date());
  //这是最简单的一个例子,把一个对象转换为json字符串
  String personJson = objectMapper.writeValueAsString(person);
  System.out.println(personJson);
   
  //默认为true,会显示时间戳
  objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
  personJson = objectMapper.writeValueAsString(person);
  System.out.println(personJson);
 }
}

输出的信息如下

objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)的作用

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
package com.shiro.test;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class Main2 {
    public static void main(String[] args) throws Exception{
        ObjectMapper objectMapper = new ObjectMapper();
        //序列化的时候序列对象的所有属性
        objectMapper.setSerializationInclusion(Include.ALWAYS);
        //如果是空对象的时候,不抛异常,也就是对应的属性没有get方法
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
         
        Person person = new Person(1, "zxc", new Date());
  
        String personJson = objectMapper.writeValueAsString(person);
        System.out.println(personJson);
         
        //默认是true,即会抛异常
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, true);
        personJson = objectMapper.writeValueAsString(person);
        System.out.println(personJson);
    }
}

对应的person类此时为

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
33
34
35
36
37
38
package com.shiro.test;
import java.util.Date;
public class Person {
    private Integer id;
    private String name;
    private Date birthDate;
//  public Integer getId() {
//      return id;
//  }
//  public void setId(Integer id) {
//      this.id = id;
//  }
//  public String getName() {
//      return name;
//  }
//  public void setName(String name) {
//      this.name = name;
//  }
//  public Date getBirthDate() {
//      return birthDate;
//  }
//  public void setBirthDate(Date birthDate) {
//      this.birthDate = birthDate;
//  }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", birthDate=" + birthDate + "]";
    }
    public Person(Integer id, String name, Date birthDate) {
        super();
        this.id = id;
        this.name = name;
        this.birthDate = birthDate;
    }  
    public Person() {
        // TODO Auto-generated constructor stub
    }
}

结果如下

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
package com.shiro.test;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Main2 {
    public static void main(String[] args) throws Exception{
        ObjectMapper objectMapper = new ObjectMapper();
        //序列化的时候序列对象的所有属性
        objectMapper.setSerializationInclusion(Include.ALWAYS);
        //反序列化的时候如果多了其他属性,不抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         
//      Person person = new Person(1, "zxc", new Date());
  
//      String personJson = objectMapper.writeValueAsString(person);
//      System.out.println(personJson);
         
        //注意,age属性是不存在在person对象中的
        String personStr = "{\"id\":1,\"name\":\"zxc\",\"age\":\"zxc\"}";
         
        Person person = objectMapper.readValue(personStr, Person.class);
        System.out.println(person);
         
        //默认为true
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
        person = objectMapper.readValue(personStr, Person.class);
        System.out.println(person);    
    }
}

执行后的结果如下

这些便是这几个属性的作用所以，由于第一个比较简单我就这样说一下吧

Include.ALWAYS 是序列化对像所有属性

Include.NON_NULL 只有不为null的字段才被序列化

Include.NON_EMPTY 如果为null或者 空字符串和空集合都不会被序列化

然后再说一下如何把一个对象集合转换为一个 Java里面的数组

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
33
34
35
36
37
38
39
40
package com.shiro.test;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Main2 {
    public static void main(String[] args) throws Exception{
        ObjectMapper objectMapper = new ObjectMapper();
        //序列化的时候序列对象的所有属性
        objectMapper.setSerializationInclusion(Include.NON_DEFAULT);
         
        Person person1 = new Person(1, "zxc", new Date());
        Person person2 = new Person(2, "ldh", new Date());
         
        List<Person> persons = new ArrayList<>();
        persons.add(person1);
        persons.add(person2);
         
        //先转换为json字符串
        String personStr = objectMapper.writeValueAsString(persons);
         
        //反序列化为List<user> 集合,1需要通过 TypeReference 来具体传递值
        List<Person> persons2 = objectMapper.readValue(personStr, new TypeReference<List<Person>>() {});
         
        for(Person person : persons2) {
            System.out.println(person);
        }
         
        //2,通过 JavaType 来进行处理返回
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Person.class);
        List<Person> persons3 = objectMapper.readValue(personStr, javaType);
         
        for(Person person : persons3) {
            System.out.println(person);
        }
    }
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

  • 如何利用Jackson序列化忽略指定类型的属性详解

  • Jackson库中objectMapper的用法

  • 举例讲解Java的Jackson库中ObjectMapper类的使用

  • Java使用ObjectMapper的简单示例


原文链接：https://blog.csdn.net/weixin_42713970/article/details/88061100


    文章分类
    后端
    文章标签
    objectmapper
    字段
    小写
    版权声明：本站是系统测试站点，无实际运营。本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 XXXXXXo@163.com 举报，一经查实，本站将立刻删除。
    相关推荐