Jackson -控制字段被序列化/反序列化

于 2020-05-12 16:09:52 发布
阅读量1.6k 收藏
点赞数
分类专栏： Jackson 文章标签： java json spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u014580317/article/details/106078557
版权
本文详细介绍了如何使用Jackson库控制Java对象的字段在序列化和反序列化过程中的可见性，包括通过public字段、getter和setter方法、全局配置ObjectMapper以及使用@JsonIgnore和@JsonProperty注解来实现对特定字段的控制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.概述

在本文中，我们将学习各种方法来控制一个字段是否被Jackson进行列化/反序列化。

2.public 使字段序列化和反序列化

确保字段可序列化和反序列化的最简单方法是将字段声明为public。

声明EmployeeAccessLevel类，字段包含四种访问权限，如下所示：

public class EmployeeAccessLevel {

    private     String name;
    int age;
    protected   float  salary;
    public  boolean  isLeader;

    public EmployeeAccessLevel() {
    }

    public EmployeeAccessLevel(String name, int age, float salary, boolean isLeader) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.isLeader = isLeader;
    }
    // 没有 setters 和 getters 方法
}

在EmployeeAccessLevel类的四个字段中，默认情况下，仅将公共isLeader序列化为JSON：

    @Test //根据字段的访问权限，确定序列化那些字段
    public void feildAccessLevelsSerializable() throws JsonProcessingException {

        ObjectMapper mapper = new ObjectMapper();
        EmployeeAccessLevel employee = new EmployeeAccessLevel("Jack", 26, 5000, false);
        String valueAsString = mapper.writeValueAsString(employee);
        System.out.println(valueAsString);
    }

执行上述代码，输出结果为：

{"isLeader":false}

反序列化代码如下：

@Test //根据字段的访问权限，确定反序列化那些字段
public void feildAccessLevelsDeserializable() throws IOException {
    String jsonAsString = "{\"isLeader\":\"true\"}";
    ObjectMapper mapper = new ObjectMapper();

    EmployeeAccessLevel employeeObject = mapper.readValue(jsonAsString,       EmployeeAccessLevel.class);

    assertNotNull(employeeObject);

    System.out.println(employeeObject);
    //EmployeeAccessLevel{name='null', age=0, salary=0.0, isLeader=true}
}

3. Getter使非public 字段序列化和反序列化

另一种使字段（尤其是非public字段）可序列化的方法是为它添加一个getter方法:

public class EmployeeWithGetter {

    private String name;
    private int age;
    private float salary;
    private boolean isLeader;

    public EmployeeWithGetter() {
    }

    public EmployeeWithGetter(String name, int age, float salary, boolean isLeader) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.isLeader = isLeader;
    }

    //字段访问权限为private时，提供getter方法可以将进行序列化和反序列化
    public String getName() {
        return name;
    }
}

我们期望name字段可序列化，其他字段不可序列化，因为它没有getter：

    @Test //字段访问权限为private时，可以提供getter方法进行序列化
    public void getterAddedSerializable() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        EmployeeWithGetter employee = new EmployeeWithGetter("Jack", 26, 5000, false);

        String valueAsString = mapper.writeValueAsString(employee);

        System.out.println(valueAsString);
    }

执行上述代码，输出结果为：

{"name":"Jack"}

getter也可以使私有字段反序列化，因为一旦有一个getter，字段就被认为是一个属性。测试代码如下:

    @Test //字段访问权限为private时，可以提供getter方法进行反序列化
    public void getterAddedDeserializable() throws IOException {
        String jsonAsString = "{\"name\":\"Jack\"}";
        ObjectMapper mapper = new ObjectMapper();

        EmployeeWithGetter employeeObject = mapper.readValue(jsonAsString, EmployeeWithGetter.class);

        assertNotNull(employeeObject);
        assertThat(employeeObject.getName(), equalTo("Jack"));

        System.out.println(employeeObject);
    }
//输出结果：EmployeeWithGetter{name='Jack', age=0, salary=0.0, isLeader=false}

4. Setter使非public字段只能反序列化

上节测试可以看到，getter可以使私有字段既可序列化又可反序列化。但是，setter只会将非public字段反序列化:

public class EmployeeWithSetter {

    private String name;

    //Setter使非public字段只能反序列化
    public void setName(String name) {
        this.name = name;
    }

    public String accessName() {
        return name;
    }

    @Override
    public String toString() {
        return "EmployeeWithSetter{" +
                "name='" + name + '\'' +
                '}';
    }
}

上述代码，name字段只有一个setter。我们有一个获取name的方法accessName，但这不是标准的getter方法。

运行反序列化测试代码：

    @Test
    public  void setterAddedDeserializable() throws IOException {
         String jsonAsString = "{\"name\":\"Jack\"}";
         ObjectMapper mapper = new ObjectMapper();

         EmployeeWithSetter employee = mapper.readValue(jsonAsString, EmployeeWithSetter.class);

        assertNotNull(employee);
        System.out.println(employee);
        //输出结果：EmployeeWithSetter{name='Jack'}
    }

正如我们所说的，setter只能使字段可反序列化，而不能序列化，序列化测试代码如下：

    @Test
    public  void setterAddedSerializable() throws IOException {
         ObjectMapper mapper = new ObjectMapper();

         EmployeeWithSetter dtoObject = new EmployeeWithSetter();

         String dtoAsString = mapper.writeValueAsString(dtoObject);
         assertThat(dtoAsString, not(containsString("name")));
         System.out.println(dtoAsString);
    }

运行测试代码，输出如下错误信息

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class com.wxbsusht.jackson.field.EmployeeWithSetter and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS)

5.所有字段全局可序列化

在某些情况下，您可能无法直接修改源代码，但是，我们希望配置Jackson处理非public字段能够序列化和反序列化。此时，我们可以在ObjectMapper级别上进行全局配置，方法是打开autodetection函数，使public字段或getter/setter方法进行序列化，或者为所有字段打开序列化:

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, Visibility.NONE);
        mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

以下测试用例验证EmployeeAccessLevel的所有成员字段（包括非公共字段）是否可序列化：

    @Test
    public void accessLevelsSetVisibility() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, Visibility.NONE);
        mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

        EmployeeAccessLevel employee = new EmployeeAccessLevel("Jack", 26, 8000, false);

        String valueAsString = mapper.writeValueAsString(employee);
        System.out.println(valueAsString);
    }

执行上述代码，输出结果为：

{"name":"Jack","age":26,"salary":8000.0,"isLeader":false}

6.忽略有关序列化或反序列化的字段

有时我们只需要忽略其中一个字段，而不需要同时忽略多个字段。Jackson都能灵活的处理这些需求。

下面的示例声明一个User对象，其中包含敏感的密码信息，不应该将其序列化为JSON。为此，我们只需在密码的getter上添加@JsonIgnore注释，在setter上添加@JsonProperty注释来实现字段的反序列化:

public class User {
    private String name;
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JsonIgnore
    public String getPassword() {
        return password;
    }

    @JsonProperty
    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

序列化测试代码如下，密码信息将不会序列化为JSON：

    @Test
    public  void userIsSerialized() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user=new User();
        user.setName("Jack");
        user.setPassword("123456");
        String userAsString = mapper.writeValueAsString(user);
        System.out.println(userAsString);
    }

执行上述代码，输出结果如下：

{"name":"Jack"}

反序列化测试代码如下，包含密码的JSON字符串被反序列化为User对象：

    @Test
    public  void userIsDeserializable() throws JsonProcessingException {
        String jsonAsString = "{\"name\":\"Jack\",\"password\":\"123456\"}";

        ObjectMapper mapper = new ObjectMapper();

        User userObject = mapper.readValue(jsonAsString, User.class);

        System.out.println(userObject);
        assertThat(userObject.getPassword(), equalTo("123456"));
        //User{name='Jack', password='123456'}
    }

要了解更多关于Jackson的用法，扫一扫，关注我（攻城狮susht），一起学习，一起进步​

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值