jackson注解使用说明

最新推荐文章于 2024-04-24 12:06:15 发布
最新推荐文章于 2024-04-24 12:06:15 发布
阅读量7.8k 收藏 6
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouyecheng/article/details/79562425
版权

GitHub：https://github.com/FasterXML/jackson-annotations

1、属性命名（Property Naming）

 @JsonProperty：用于指明属性的名称。

import java.util.Date;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
@JsonIgnoreProperties(ignoreUnknown=true)
public class Article {

    private Long id;
    
    private String title;
    
    private String description;
    
    private List<Author> authors;
    
    //createDate->create_date
    @JsonProperty("create_date")
    private Date createDate;
}

测试：

	@Test
	public void jsonPropertyTest() throws IOException {
		List<Author> authors = Lists.newArrayList(
				Author.builder().name("zyc").fields(Lists.newArrayList("java", "sql")).build(),
				Author.builder().name("llp").fields(Lists.newArrayList("cad", "excel")).build());
		Article article = Article.builder().authors(authors).createDate(new Date()).description("use @JsonProperty change the property name.").id(168L)
				.title("testJsonProperty").build();
		ObjectMapper objMapper = new ObjectMapper();
		//序列化
		String jsonStr = objMapper.writeValueAsString(article);
		System.out.println("序列化结果：" + jsonStr);
		//反序列化
		Article atl = objMapper.readValue(jsonStr, Article.class);
		System.out.println("反序列化结果：" + atl);
	}
序列化结果：{"id":168,"title":"testJsonProperty","description":"use @JsonProperty change the property name.","authors":[{"name":"zyc","fields":["java","sql"]},{"name":"llp","fields":["cad","excel"]}],"create_date":1521046139016}
反序列化结果：Article(id=168, title=testJsonProperty, description=use @JsonProperty change the property name., authors=[Author(name=zyc, fields=[java, sql]), Author(name=llp, fields=[cad, excel])], createDate=Thu Mar 15 00:48:59 CST 2018)

2、属性包含（Property Inclusion）

@JsonAutoDetect：用于指定自动发现字段的级别。

fieldVisibility：字段属性的可见范围。

getterVisibility：getter的可见范围（对象序列化成json字符串时的可见范围）。

isGetterVisibility：is-getter的可见范围（如boolean类型的getter）。

setterVisibility：setter的可见范围（json字符串反序列化成对象时的可见范围）。

creatorVisibility：构造方法的可见范围。

可见范围是一个枚举，包括：

Visibility.ANY：表示从private到public修饰，都可见。

Visibility.NON_PRIVATE：表示除private修饰不可见外，其他都可见。

Visibility.PROTECTED_AND_PUBLIC：protected和public可见。

Visibility.PUBLIC_ONLY：仅public可见。

Visibility.NONE：所以皆不可见。

Visibility.DEFAULT：缺省，所有被public修饰的属性、getter和所有setter(不管能见度)皆可见。

测试属性可见性：

先试ANY，protected修饰可见

@JsonIgnoreProperties(ignoreUnknown=true)
@JsonAutoDetect(fieldVisibility=Visibility.ANY)
public class Person {
	
	protected String name = "zyc";
	
	public boolean boy = true;

	@Override
	public String toString() {
		return "Person [name=" + name + ", boy=" + boy + "]";
	}
	
}
        @Test
	public void JsonAutoDetectTest() throws IOException {
		Person person = new Person();
		ObjectMapper objMapper = new ObjectMapper();
		// 序列化
		String jsonStr = objMapper.writeValueAsString(person);
		System.out.println("序列化结果：" + jsonStr);
		// 反序列化
		Person p = objMapper.readValue("{\"name\":\"llp\", \"boy\":true}", Person.class);
		System.out.println("反序列化结果：" + p);
	}
序列化结果：{"name":"zyc","boy":true}
反序列化结果：Person [name=llp, boy=true]

再试PUBLIC_ONLY，protected不可见

@JsonIgnoreProperties(ignoreUnknown=true)
@JsonAutoDetect(fieldVisibility=Visibility.PUBLIC_ONLY)
public class Person {
	
	protected String name = "zyc";
	
	public boolean boy = true;

	@Override
	public String toString() {
		return "Person [name=" + name + ", boy=" + boy + "]";
	}
	
}
序列化结果：{"boy":true}
反序列化结果：Person [name=zyc, boy=true]

测试getter、setter可见性

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown=true)
@JsonAutoDetect(getterVisibility=Visibility.NON_PRIVATE)
public class Person {
    
    private String name = "zyc";
    
    private boolean boy = true;

    //getterVisibility=Visibility.NON_PRIVATE: protected 修饰的name可见
    protected String getName() {
        return name;
    }

    //setter默认所有可见，所以反序列化都会被赋值
    private void setName(String name) {
        this.name = name;
    }

    //isGetterVisibility默认为public修饰可见，所有序列化时，没有boy属性
    private boolean isBoy() {
        return boy;
    }

    private void setBoy(boolean boy) {
        this.boy = boy;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", boy=" + boy + "]";
    }
    
}

序列化结果：{"name":"zyc"}
反序列化结果：Person [name=llp, boy=true]

@JsonIgnore：用于忽略指定属性，当该注解出现在field、getter、setter或者构造方法中任意一个上时，都意味着忽略所有（即序列化和反序列化都被忽略）；有一种情况，当getter上注解@JsonIgnore而setter上注解@JsonProperty，就会出现“只读”情况（read from input, but is not written output）。

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class House {
	
	private String name;
	
	//仅仅注解 @JsonIgnore时，序列化和反序列化都忽略
	@JsonIgnore
//	@JsonProperty
	private String address;

	public String getName() {
		return name;
	}

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

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "House [name=" + name + ", address=" + address + "]";
	}

}
@Test
    public void JsonIgnoreTest() throws Exception {
        House house = new House();
        house.setName("my house");
        house.setAddress("深圳");
        ObjectMapper objMapper = new ObjectMapper();
        // address被忽略
        String jsonStr = objMapper.writeValueAsString(house);
        System.out.println("序列化结果：" + jsonStr);
        // address被忽略
        House h = objMapper.readValue("{\"name\":\"your house\", \"address\":\"深圳南山\"}", House.class);
        System.out.println("反序列化结果：" + h);
    }

序列化结果：{"name":"my house"}
反序列化结果：House [name=your house, address=null]

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class House {
	
	private String name;
	
	//仅仅注解 @JsonIgnore时，序列化和反序列化都忽略
	@JsonIgnore
	//在属性上添加 @JsonProperty，结果是忽略不生效
	@JsonProperty
	private String address;

	public String getName() {
		return name;
	}

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

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "House [name=" + name + ", address=" + address + "]";
	}

}

序列化结果：{"name":"my house","address":"深圳"}
反序列化结果：House [name=your house, address=深圳南山] 
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class House {
    
    private String name;
    
    //仅仅注解 @JsonIgnore时，序列化和反序列化都忽略
    @JsonIgnore
    private String address;

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    //setter注解@JsonProperty，忽略被取消，和注解在属性上一样结果
    @JsonProperty
    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "House [name=" + name + ", address=" + address + "]";
    }

}

序列化结果：{"name":"my house","address":"深圳"}
反序列化结果：House [name=your house, address=深圳南山]

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class House {
	
	private String name;
	
	private String address;

	public String getName() {
		return name;
	}

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

	//getter注解 @JsonIgnore
	@JsonIgnore
	public String getAddress() {
		return address;
	}

	//setter注解@JsonProperty，出现“只读”情况
	@JsonProperty
	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "House [name=" + name + ", address=" + address + "]";
	}

}
序列化结果：{"name":"my house"}
反序列化结果：House [name=your house, address=深圳南山]
结论：当仅出现@JsonIgnore时，属性序列化和反序列化都被忽略；当@JsonIgnore和@JsonProperty同时出现，并且不是getter注解@JsonIgnore，setter注解@JsonProperty时，属性忽略被取消，正常序列化反序列化；当getter注解@JsonIgnore，setter注解@JsonProperty时，出现“只读”（getter注解@JsonProperty，setter注解@JsonIgnore是不存在只写的情况的^_^）。


@JsonIgnoreProperties：作用于实体类的注解（注解在属性貌似没效果），用于忽略某些属性，如果指定ignoreUnknown=true，则反序列化时忽略所有未知的属性；allowGetters使得被忽略的属性在序列化时是可见的，即序列化时忽略失效了；allowSetters对应反序列化。

@JsonIgnoreProperties(value={"cpu", "mainboard"}, allowGetters=true)
public class Computer {
	
	private String cpu;
	
	private String memory;
	
	private String os;

	public String getCpu() {
		return cpu;
	}

	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	public String getMemory() {
		return memory;
	}

	public void setMemory(String memory) {
		this.memory = memory;
	}

	public String getOs() {
		return os;
	}

	public void setOs(String os) {
		this.os = os;
	}

	@Override
	public String toString() {
		return "Computer [cpu=" + cpu + ", memory=" + memory + ", os=" + os + "]";
	}
@Test
	public void JsonIgnorePropertiesTest() throws Exception {
		Computer cpt = new Computer();
		cpt.setCpu("i7-U6700HQ");
		cpt.setMemory("16G");
		cpt.setOs("windows 10");
		// 序列化
		ObjectMapper objMapper = new ObjectMapper();
		String jsonStr = objMapper.writeValueAsString(cpt);
		System.out.println("序列化结果：" + jsonStr);
		// 注意这里，如果忽略的属性数组里不包含mainboard，则会抛出com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException异常
		Computer computer = objMapper.readValue(
				"{\"cpu\":\"爱妻六代\", \"os\":\"centos7\",\"memory\":\"8G\",\"mainboard\":\"华硕主板\"}", Computer.class);
		System.out.println("反序列化结果：" + computer);
	}
序列化结果：{"cpu":"i7-U6700HQ","memory":"16G","os":"windows 10"}
反序列化结果：Computer [cpu=null, memory=8G, os=centos7]

@JsonIgnoreType：作用于类，表示被注解该类型的属性（这里不是指被注解类的成员变量，而是被注解类作为别的类的成员变量）将不会被序列化和反序列化。@JsonIgnoreType(value=false)表示该注解不起作用，默认为true。

public class Car {
	
	private String name;
	
	private double price;
	
	private Owner owner;

	public String getName() {
		return name;
	}

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

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public Owner getOwner() {
		return owner;
	}

	public void setOwner(Owner owner) {
		this.owner = owner;
	}

}
import com.fasterxml.jackson.annotation.JsonIgnoreType;

@JsonIgnoreType
public class Owner {
	
	private String name;
	
	public Owner() {
	}

	public Owner(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Owner [name=" + name + "]";
	}

}

@Test
	public void JsonIgnoreTypeTest() throws JsonProcessingException {
		Car car = new Car();
		car.setName("迈腾");
		car.setPrice(23.49);
		car.setOwner(new Owner("zyc"));
		
		ObjectMapper objMapper = new ObjectMapper();
		String jsonStr = objMapper.writeValueAsString(car);
		System.out.println("结果：" + jsonStr);
	}
结果：{"name":"迈腾","price":23.49}
@JsonInclude：用于定义序列化时是否包括某些“non-values”(空值或空值)；可作用于属性，也可以用于类(对类的所有属性有效)。
  • Include.ALWAYS表示无论对象的属性是不是空，都输出到json字符串中
  • Include.NON_NULL表示序列化生成的json字符串仅包括非null的字段属性，为null的属性被忽略
  • Include.NON_ABSENT相当于NON_NULL的增强版，比如jdk和谷歌Guava的Optional类型对象，不是null，但它的isPresent方法返回false
  • Include.NON_EMPTY表示非空：指非null，非""，集合isEmpty()==true等都将被忽略
  • Include.NON_DEFAULT表示属性值为缺省值时不序列化，如int类型属性==0，String类型属性==null等
  • Include.CUSTOM这个要结合注解JsonInclude.valueFilter和JsonInclude.contentFilter使用，这两个注解会指定一个Class，然后默认调用这个Class的空参构造方法，返回的对象eques属性值的话，序列化时就忽略。如使用注解：@JsonInclude(valueFilter=String.class)，然后javabean中String name="";则这个name在序列化为json时将被忽略，因为"".equals(new String())
  • Include.USE_DEFAULTS理解不了：Pseudo-value used to indicate that the higher-level defaults make sense, to avoid overriding inclusion value. For example, if returned for a property this would use defaults for the class that contains property, if any defined; and if none defined for that, then global serialization inclusion details.









Zhouyecheng
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用Jackson在Java中处理JSON
07-23
`rename.txt`可能是关于如何使用Jackson进行文件名转换或存储的说明。 总的来说，Jackson提供了一套强大的工具，使得在Java中处理JSON变得简单而高效。无论是简单的对象转换，还是复杂的数据结构，Jackson都有相应...
jackson-core-2.2.1.jar
10-05
三、使用说明 在IDEA中，将`jackson-core-2.2.1.jar`引入项目后，即可开始使用Jackson提供的功能。例如，我们可以创建一个简单的Java对象，然后利用`ObjectMapper`将其转换为JSON字符串： ```java import ...
Jackson的注解
lpfasd123的博客
04-16 323
Jackson JSON工具包包含一组Java注释，您可以使用它们来影响如何将JSON读入对象，或者从对象生成JSON。 Read + Write注释 既影响从JSON读取Java对象，也影响将Java对象写入JSON的注解，称为“读取+写入注释”。以下部分更详细地解释了Jackson的读写注释。 @JsonIgnore Jackson注释@JsonIgn...
Jackson之注解大全
热门推荐
blwinner的专栏
08-19 1万+
Jackson简介
Json的常用注解
最新发布
code_xu的博客
04-24 790
作用于类，可以自定义多态的类型标识符，这个平时很少用到，主要是现有的一般就已经满足绝大多数的需求了，如果你需要比较特别的类型标识符，建议使用这2个注解，自己定制基于TypeResolverBuilder和TypeIdResolver的类即可。作用于方法，在反序列化时用来处理遇到未知的属性的时候调用，在本文前面我们知道可以通过注解@JsonIgnoreProperties(ignoreUnknown=true)来过滤未知的属性，但是如果需要这些未知的属性。作用于子类，用来为多态子类指定类型标识符的值。
Jackson注解详解
寂寞的博客
09-10 1772
随着fastjson的壮大，漏洞也越来越多，是时候考虑下Jackson了，下面对Jackson近30个注解逐个解释。 引入依赖 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.11.2</version
jackson的常用注解
如斯，如己
03-16 2786
目录 属性命名 财产包含 属性文档、元数据 反序列化和序列化细节 反序列化细节 序列化细节 类型处理 对象引用，身份 元注释 与 JAX-RS 一起使用（DropWizard，Jersey） 属性命名 @JsonProperty（也表示要包含属性）用于表示外部属性名称，数据格式中使用的名称（JSON或其他支持的数据格式之一） @JsonProperty.value: 要使用的名称 @JsonProperty.index: 要使用的物理索引，如果数据格式（JSON 除外
jackson annotations注解详解
dearbaba_8520的博客
05-23 388
官方WIKI：https://github.com/FasterXML/jackson-databind/wiki jackson 1.x和2.x版本的注解是放置在不同的包下的 1.
jackson2.x主要jar包
01-07
Jackson是Java领域中广泛使用的JSON处理库，由FasterXML公司开发并维护。它提供了高效、功能丰富的支持，包括序列化、反序列化以及JSON数据绑定。Jackson 2.x版本是其一个重要的更新系列，引入了许多增强功能和优化...
Java中使用JSON格式数据工具类及使用说明
06-03
如果你的`TestJavaDemo`中包含了Jackson，你可以看到如何使用`@JsonProperty`等注解来控制序列化和反序列化的行为。 6. **Fastjson库** Fastjson是阿里巴巴提供的高性能的JSON库，它的性能通常优于Gson和Jackson。...
Jackson注解大全，你都学会了吗？
IT学习社
07-21 2429
Jackson常用注解 序列化注解 @JsonAnyGetter 像普通属性一样序列化Map public class ExtendableBean { public String name; private Map<String, String> properties; @JsonAnyGetter public Map<String, String> getProperties() { return properties;
Jackson常用注解介绍
夜黑博客
04-21 6044
1 排除属性 @JsonIgnore，一般标记在属性或方法上；作用于序列化与反序列化； @JsonIgnoreProperties，如果是代理类，由于无法标记在属性或方法上，所以，可以标记在类声明上；也作用于反序列化时的字段解析； 有时POJO包括了一些你不希望输出的属性，在这种情况下，你可以进行如下操作： public class Value { public int value
Jackson常用注解及用法
郝大侠的博客
07-05 638
IO: 面向流，每次都要请求cpu操作，通过DMI进行通信。 NIO （new io）JDK1.4：在通道（每次不需要请求cpu）中，将缓冲块运输到目的地； AIO （async io）JDK1.7：异步回调处理消息。 当需要大量的通信（文件、字符、字节）通信，可以选择NIO或者AIO方式提高通信效率。 场景 zk ...
Jackson - @JsonInclude之USE_DEFAULTS
Aubergines的专栏
11-04 1459
指定了JsonInclude.Include＃value的USE_DEFAULTS，以便可以使用更高级别的默认值。如果在属性上使用此选项@JsonInclude，则将使用类的设置（如果存在），否则将使用全局序列化包含规则（通过设置ObjectMapper）。 例子 Java对象 @JsonInclude(JsonInclude.Include.NON_EMPTY) public class Employee { private String name; private String dept;
REST Assured 40 - @JsonIgnoreProperties Annotation – Serialization Or Deserialization Or Both 移除字段
wumingxiaoyao的博客
09-13 137
REST Assured 系列汇总 之 REST Assured 40 - @JsonIgnoreProperties Annotation – Serialization Or Deserialization 移除字段 前提条件： 阅读到本文时，请先阅读如下两篇文章： POJO 的 Getter & Setter 方法如何影响 Serialization 系列化 & Deserialization 反序列化 @JsonIgnore Annotation – Serialization 和
@JsonIgnoreProperties 的使用
qq_36614280的博客
12-12 4673
@JsonIgnoreProperties(ignoreUnknown = true)将json转化成实体类的时候，json中的字段和实体类 allowSetters = true（默认是false），允许反序列化。 allowGetters= true（默认是false），允许序列化。 ...
[Spring]~@JsonIgnoreProperties（类级序列化控制）
帝风
12-04 1834
用法 @JsonIgnoreProperties(ignoreUnknown = true) 如果json 字符串中的字段数量多于类的字段时会报错，加上注解则正常。 实体 //@JsonIgnoreProperties(ignoreUnknown = true) public class JsonTestModel { String name; Date time; p...
Jackson详解及其常用注解
qq_37634156的博客
10-09 1089
常用注解 1、@JsonIgnore @JsonIgnore此注解用于属性或者方法上（最好是属性上），用来完全忽略被注解的字段和方法对应的属性，即便这个字段或方法可以被自动检测到或者还有其他的注解，一般标记在属性或者方法上，返回的json数据即不包含该属性。 因此：getAuthorities()所返回的内容不会出现在返回结果中。 案例：使密码不显示 在实体对象中的password属性上加@JsonIgnore，前端将接收不到密码 import com.fasterxml.jackson.an
jacksonxmlproperty注解说明
03-16
JacksonXmlProperty注解是Jackson库中用于XML序列化和反序列化的注解之一。它用于指定Java对象属性在XML中的名称，以及在反序列化时将XML元素映射到Java对象属性的名称。该注解可以用于类的字段或getter和setter方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值