jackson用于java对象到 json 的序列化与反序列化。还支持xml格式。

应用场景: web service要实现跨机器传送对象, 那么就需要有一种技术能把对象转换为特定格式的信息。为了实现跨平台（比如把java对象转化为c#或c++对象），又考虑到方便人们阅读，所以基于字符串规则的转换是最理想的。json就是这样一个轻量级的数据交换格式，而jackson是一个实现该功能的很好用的框架。

1.maven依赖

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

2.常用注解

@com.fasterxml.jackson.annotation. JsonPropertyOrder
指定序列化为json串时的各字段顺序
@com.fasterxml.jackson.annotation. JsonIgnoreProperties
指定序列化为json串时排除的一些字段

当 @JsonIgnoreProperties( ignoreUnknown = true)时, 用于反序列化时, jsonStr 中多余的field会被忽略, 否则报错 Unrecognized field异常.

@JsonAutoDetect
@JsonPropertyOrder(value = {"price", "name"})
@JsonIgnoreProperties(value = {"year"})
public class Book {
	public String name = "Physics";
	public String price = "123";
	public String year = "2015";
	@Produces(MediaType.APPLICATION_JSON)
	public Book wsBook(){
		return new Book();

 @com.fasterxml.jackson.annotation.JsonProperty
 字段在序列化时只用指定的别名
 
3. 常用函数
 
com.fasterxml.jackson.databind.ObjectMapper.ObjectMapper()
 
核心类 ObjectMapper 的构造函数，得到的对象是线程安全的，建议在程序中作为静态成员直接用。
 
3.1 自定义对象 <---> json
 
<T> T com.fasterxml.jackson.databind.ObjectMapper.readValue(File src, Class<T> valueType)
 
从文件中直接反序列化，当然，文件中是json格式的字符串。
 
<T> T com.fasterxml.jackson.databind.ObjectMapper.readValue(String content,Class<T> valueType)
 
从字符串中反序列化。
 
public void writeValue(File resultFile, Object value)
 
将对象序列化到文件中去。文件是json格式的文本文件。
 
String com.fasterxml.jackson.databind.ObjectMapper.writeValueAsString(Object value) 
 
将对象序列化成json格式的string。
 
3.2 泛型及实现类指定
 
<T> T com.fasterxml.jackson.databind.ObjectMapper.readValue(URL src,TypeReference   valueTypeRef) 
 
反序列化时指定泛型参数。这个函数很有用，如：
 
public static ConcurrentHashMap<String,Integer> readMapFromFile(File file) throws JsonParseException, JsonMappingException, IOException{
		//new an anonymous class
		return objectMapper.readValue(file, new TypeReference<ConcurrentHashMap<String,Integer>>() {});
# 例子二
String featuresStr="[[5.1,3.3,1.7,0.5],[5.0,2.3,3.3,1.0],[6.4,2.8,5.6,2.2]]";
ArrayList<ArrayList<Double>> c=objectMapper.readValue(featuresStr,new TypeReference<ArrayList<ArrayList<Double>>() {});
 
指定反序列化时的实现类: 如果是List接口，默认实现类是ArrayList。如果写明了LinkedList等，那么反序列化后就是LinkedList。
 
3.3 缩进
 
ObjectMapper objectMapper=new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
 
此时序列化后的json带缩进，方便肉眼看。
 
3.4 代码示例
 
 * jackson使用Sample
 * 1.类可以嵌套类
 * 2.类中的成员变量若为private权限，必须有public getter()方法，可以没有setter()方法
 * 3.类中的成员变量若为public权限，就不需要自己再写 getter()与setter()
 * 4.ObjectMapper is thread-safe
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
class Book {
	private String name = "Physics";
	public String getName() {
		return name;
	// public void setName(String name) {
	// this.name = name;
class Student {
	private int age = 7;
	private int grade = 1;
	private String name = "XiaoMing";
	private Book book = new Book();
	public int getAge() {
		return age;
	public void setAge(int age) {
		this.age = age;
	public int getGrade() {
		return grade;
	public void setGrade(int grade) {
		this.grade = grade;
	public String getName() {
		return name;
	public void setName(String name) {
		this.name = name;
	public Book getBook() {
		return book;
	public void setBook(Book book) {
		this.book = book;
public class A {
	static ObjectMapper objectMapper = new ObjectMapper();
	void serializeDemo() throws JsonProcessingException {
		Student student = new Student();
		System.out.println(objectMapper.writeValueAsString(student));
	void deserializeDemo() throws JsonParseException, JsonMappingException,
			IOException {
		String json = "{\"age\":7,\"grade\":1,\"name\":\"XiaoMing\",\"book\":{\"name\":\"Physics\"}}";
		Student student = objectMapper.readValue(json, Student.class);
		System.out.println(student.getName());
	public static void main(String[] args) throws IOException {
		A a = new A();
		System.out.println("serializeDemo:");
		a.serializeDemo();
		System.out.println("\ndeserializeDemo:");
		a.deserializeDemo();
 * serializeDemo:
 * {"age":7,"grade":1,"name":"XiaoMing","book":{"name":"Physics"}}
 * deserializeDemo: XiaoMing
4. jsonNode
 
4.1 解析 node
 
场景: 有时我们没有完整的目标class定义, 无法反序列化. 但我们只关心其中部分字段, 就可以解析为 jsonNode格式.
 
com.fasterxml.jackson.databind.JsonNode
 
json同xml类似，背后的数据结构都是树。JsonNode 因此而来.
 
JsonNode com.fasterxml.jackson.databind.ObjectMapper.readTree(String content)
 
读取json，得到root节点。有多个重载, 也可直接读文件.
 
JsonNode com.fasterxml.jackson.databind.JsonNode.get(String fieldName)
 
获取指定的孩子node。若不存在返回null。
 
String com.fasterxml.jackson.databind.JsonNode.asText()
 
将当前节点的内容以string格式输出。
 
String com.fasterxml.jackson.databind.JsonNode.asText(String defaultValue)
 
当指定的节点不存在时返回形参中的默认值。
 
com.fasterxml.jackson.databind.node.ArrayNode
 
当处理数组时,就可以将JsonNode转为这个ArrayNode.
 
4.2 生成node
 
private JsonNodeFactory jsonNodeFactory = JsonNodeFactory.instance;
jsonNodeFactory.arrayNode();
jsonNodeFactory.objectNode();
objectMapper.createArrayNode();
objectMapper.createObjectNode();
 
5.xml
 
在以上依赖的基础上添加：
 
<dependency>
	<groupId>com.fasterxml.jackson.dataformat</groupId>
	<artifactId>jackson-dataformat-xml</artifactId>
	<version>2.13.1</version>
</dependency>
 
5.1 常用类与函数
 
com.fasterxml.jackson.dataformat.xml.XmlMapper
 它是ObjectMapper类的子类，用于处理xml。
 
注意mapper.enable(SerializationFeature.INDENT_OUTPUT);是不支持的。
 
                    jackson用于java对象到json的序列化与反序列化。还支持xml格式。jackson用于实现json与java对象的序列与反序列化。web service要实现跨机器传送对象那么就需要有一种技术能把对象转换为特定格式的信息。为了实现跨平台（比如把java对象转化为c#或c++对象），又考虑到方便人们阅读，所以基于字符串规则的转换是最理想的。json就是这样一个轻量级的数据交换格式，而j...
				
jackson解析xml文件或xml格式请求以及踩坑经历
最近写的接口要被外部接口调用,请求格式为xml,在网上搜索,有的是用代码去解析的例如 使用HttpServletRequest.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(request.getInputStream(), "UTF-8"));
StringBuffer xml = new StringBuffer();
				
  最近负责一个从第三方接口获取数据，并对数据封装的项目，项目中也有用到json格式数据，因此堪虑用Jackson中的jackson-dataformat-xml来解析xml，具体如下：
maven引入jar包
GradeDomain
public class GradeDomain {
@JacksonXmlProperty(localName = &amp;quot;gradeId&amp;quot;,isAttri...
				
Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。
前面有介绍过json-lib这个框架，在线博文：http://www.open-open.com/lib/view/open1327991992093.html
相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区
				
Jackson-操作XML
Jackson是一个处理JSON的类库，不过它也通过jackson-dataformat-xml包提供了处理XML的功能。Jackson建议我们在处理XML的时候使用woodstox-core包，它是一个XML的实现，比JDK自带XML实现更加高效，也更加安全。
Jackson常用注解
1、@JacksonXmlRootElement
@JacksonXmlRootElement注解有两个属性：
namespace属性：用于指定XML根元素命名空间的名称。
localna
				
什么是Jackson
Jackson是处理JSON和XML格式化的类库。Jackson是一个功能强大的Java序列化库，能够将java对象序列化为JSON字符串，也能够将JSON字符串反序列化为java对象的框架。
Jackson的json库提供了3种API：Streaming API （性能最好）、Tree Model （最灵活）、Data Binding（最方便）。本文未标识处均为Data Binding应用。
ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在Obje
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.0</version>
</dependency>
xml文件demo：
<?xml version="1.0" enco
				
Jackson实现xml序列化和反序列化
本文介绍Jackson 2.X中提供的xml序列化功能。仅介绍基本操作，不涉及复杂和自定义功能。
1. XmlMapper对象
XmlMapper是Jackson 2.x中提供我们实现xml序列化的主要类，因此首先需要创建其实例：
XmlMapper mapper = new XmlMapper();
想要maven依赖脚本为：
<dependen...
				
Jackson是一个非常流行的Java库，用于将Java对象序列化为JSON格式，或将JSON格式的数据反序列化为Java对象。下面是使用Jackson进行JSON序列化和解析的示例代码：
1. 导入Jackson库的依赖：
```xml
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>
2. 创建一个Java对象：
```java
public class Person {
    private String name;
    private int age;
    private List<String> hobbies;
    // 省略getter和setter方法
3. 将Java对象序列化为JSON格式：
```java
ObjectMapper objectMapper = new ObjectMapper();
Person person = new Person();
person.setName("张三");
person.setAge(20);
person.setHobbies(Arrays.asList("篮球", "游泳"));
String json = objectMapper.writeValueAsString(person);
System.out.println(json);
输出结果：
```json
{"name":"张三","age":20,"hobbies":["篮球","游泳"]}
4. 将JSON格式的数据反序列化为Java对象：
```java
String json = "{\"name\":\"张三\",\"age\":20,\"hobbies\":[\"篮球\",\"游泳\"]}";
Person person = objectMapper.readValue(json, Person.class);
System.out.println(person.getName());
System.out.println(person.getAge());
System.out.println(person.getHobbies());
输出结果：
[篮球, 游泳]
以上就是使用Jackson进行JSON序列化和解析的方法。
                    yichudu: 
                    与面向对象相对的叫面向过程, 因后者散乱难以维护, 所以提倡封装与解耦, 就有了面向对象. 
类是面向对象的产物, 类与对象就仿佛模板与实例, 程序与进程的关系, 前者是静态的抽象的, 后者是具体的, 有明确的生命周期的.
这种基础宽泛的问题适合去知乎.