Jackson详细介绍

Jackson 是一个能够将java对象序列化为JSON字符串，也能够将JSON字符串反序列化为java对象的框架。 

本文的所有内容都可以从 Java JSON Jackson Introduction 中找到,这里记录下来供自己以后参考，如果时间充足，建议阅读原文。

这是另一篇介绍自定义（反）序列化的文章 http://www.baeldung.com/jackson-custom-serialization

无论是序列化还是反序列化，Jackson都提供了三种方式：

1. JSON <--> Java Object 

2. JSON <--> JsonNode Tree（类似于XML的DOM树）

3. JSON <--> Json Stream （这是一个低层次的api，很强大，但是很繁琐）

Jackson提供了很多有用的注解来定制序列化，但是我们完全不用它的注解也可以完成绝大多数的工作。下面就从上面三种方式来一一介绍。

 

JSON <--> Java Object 

下面的Person类是一个普通的java POJO。它含有基本类型（包括String、Date）和一些集合类型，以及一个自定义的Address类型。

注意： 默认情况下，Jackson会处理所有public的属性和拥有getter方法的属性（反序列化需要setter）

import java.util.ArrayList;import java.util.Arrays;import java.util.Date;import java.util.HashMap;import java.util.List;import java.util.Map;public class Person {    private String name;    private int age;    public Date birth;    private Address address;    private List<String> friends = new ArrayList<>();    public Map<String, String> info = new HashMap<>();        public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public List<String> getFriends() {        return friends;    }    public void setFriends(List<String> friends) {        this.friends = friends;    }    public Address getAddress() {        return address;    }    public void setAddress(Address address) {        this.address = address;    }        //注意这个默认构造器，如果没有默认的构造器，应该有一个@JsonCreator修饰的构造器    public Person(){}        public Person(String name, int age, Address address, Date birth, String... friends){        this.name = name;        this.age = age;        this.address = address;        this.birth = birth;        this.friends.addAll(Arrays.asList(friends));    }        @Override    public String toString() {        StringBuffer sb = new StringBuffer();        sb.append("name: " + this.name + "\n");        sb.append("age: " + this.age + "\n");        sb.append("address: " + this.address + "\n");        sb.append("birth: " + this.birth + "\n");        this.friends.forEach(x -> sb.append("friend:"+ x + "\n"));                return sb.toString();    }}

 

public class Address {    public String homeAddress;    public String workAddress;        //跟Person一样，我们也必须提供一个无参的默认构造器    public Address(){}        public Address(String homeAddress, String workAddress) {        this.homeAddress = homeAddress;        this.workAddress = workAddress;    }    @Override    public String toString() {        return "home:" + this.homeAddress + "  " + "work:" + this.workAddress;    }}

 

下面我们使用Jackson来(反)序列化 这个Person对象。

序列化：

import java.io.File;import java.io.IOException;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;public class SerializeTest {    public static void main(String[] args) throws ParseException, JsonGenerationException, JsonMappingException, IOException {        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");        Date birth = format.parse("2010-10-10");                Address address = new Address("New York", "Tokyo");        Person person = new Person("zhangsan", 11, address, birth, "weiying", "caifang");        person.info.put("height", "175cm");        person.info.put("weight", "80kg");                //使用ObjectMapper来序列化和反序列化        ObjectMapper mapper = new ObjectMapper();                //配置序列化的输出缩进        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);        //如果没有DateFormat，ObjectMapper将会把Date类型序列化为毫秒数         mapper.setDateFormat(format);        //按照map的key的自然排序来产生序列化结果        mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);                //序列化的过程就这一行代码，当然也可以选择输出到文件或其他流中        mapper.writeValue(new File("person.json"), person);    }}

 

反序列化：

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.core.JsonParseException;import com.fasterxml.jackson.databind.DeserializationFeature;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class DeserializeTest {    public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException {        //反序列化同样从ObjectMapper开始        ObjectMapper mapper = new ObjectMapper();                //配置在反序列化过程中如果json字符串中存在无法匹配的属性不会失败        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);        //上面的configure(xxx,false) 等同于disable(xxx),例如下面这行和上面作用是一样的。        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);                //反序列化的过程也仅仅只有一行代码，同样可以从文件或其他流等输入中进行反序列化        Person person = mapper.readValue(new File("person.json"), Person.class);                System.out.println(person);    }}

 在上面的例子中我们看到了Jackson最基本的（反）序列化过程，下面我们介绍一些用来定制（反）序列化的注解：

1.@JsonProperty - 在默认情况下，Jackson会处理所有public的属性和拥有getter（序列化）和setter（反序列化）的属性。但是我们可以使用 @JsonProperty来手动指定我们希望jackson处理的属性。于此同时，我们可以改变java对象映射到json中的属性名称（默认是相同的）。@JsonProperty相当于JAXB中的@XmlElement注解。

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.annotation.JsonProperty;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;/** * 这个Dog类型没有任何public的属性和getter方法，但是我们使用@JsonProperty可以手动指定希望（反）序列化的属性，并能指定希望映射到json中的属性名称 */public class Dog {    @JsonProperty("dog_name")    private String name = "dahuang";    private int age;        @JsonProperty("dog_age")    private int tellYourAge(){        return this.age;    }        @JsonProperty("dog_age")    private void giveMeAge(int age){        this.age = age;    }        @Override    public String toString() {        return "dog(name: " + name + ";age: " + age + ")";    }        public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();        //Jackson序列化空对象默认为失败        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);        //配置ObjectMapper有两种方式，除了上面那种，下面这行代码是等价的。        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);        //配置序列化格式        mapper.enable(SerializationFeature.INDENT_OUTPUT);        //上面这行代码同样等价于下面这行        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);                mapper.writeValue(new File("dog.json"), new Dog());            Dog dog = mapper.readValue(new File("dog.json"), Dog.class);        System.out.println(dog);    }}

 

2.@JsonCreator - 在上面Person的例子中，我们除了定义了一个有参数的构造器外，还必须定义一个无参的默认构造器，这是因为在反序列化的过程中，Jackson不知道该向那个有参数的构造器中传递什么参数。 我们可以在构造器上使用 @JsonCreator，并在参数列表中使用@JsonProperty，这样在反序列化时Jackson就知道该如何使用这个构造器了，这个时候我们也就没必要定义那个无参的默认构造器了。

注意@JsonCreator仅仅在反序列化的过程中有用。

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class Dog {    public String name;    public int age;        @Override    public String toString() {        return this.name + ":" + this.age;    }    //在反序列化的过程中，Jackson会将json串中的name属性传递给dog_name参数, 把json串中的age属性传递给dog_age参数。    @JsonCreator    public Dog(@JsonProperty("name") String dog_name, @JsonProperty("age") int dog_age){        this.name = dog_name;        this.age = dog_age;    }        public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();        mapper.writeValue(new File("dog.json"), new Dog("dahuang", 11));                Dog dog = mapper.readValue(new File("dog.json"), Dog.class);        System.out.println(dog);    }}

 

3.@JsonAnyGetter and @JsonAnySetter - 设想这样一种场景：除了java对象中明确指定的属性（包括使用@JsonProperty修饰指定的）外，我们希望能够随机的增加一些其他属性，让这些随机的属性也可以映射到json中去。这个时候我们就可以将这些不确定的属性放到一个map中去，并使用@JsonAnyGetter和@JsonAnySetter来修饰处理这个map的方法，然后Jackson就可以处理这些不确定的属性了。这两个属性相当于JAXB中的@XmlAnyElement和@XMLAnyAttribute。

import java.io.File;import java.io.IOException;import java.util.HashMap;import java.util.Map;import com.fasterxml.jackson.annotation.JsonAnyGetter;import com.fasterxml.jackson.annotation.JsonAnySetter;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class Dog {    private Map<String, String> any = new HashMap<>();        @JsonAnyGetter    public Map<String, String> getAny(){        return this.any;    }        @JsonAnySetter    public void setAny(String key, String value){        this.any.put(key, value);    }    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        Dog dog = new Dog();        //suck a big dog!!!        dog.setAny("height", "175cm");        dog.setAny("weight", "80kg");                ObjectMapper mapper = new ObjectMapper();                mapper.writerWithDefaultPrettyPrinter().writeValue(new File("dog.json"), dog);                Dog dog2 = mapper.readValue(new File("dog.json"), Dog.class);        dog2.getAny().forEach((x, y) -> System.out.println(x + "-->" + y));    }}

 

4.@JsonIgnoreProperties and @JsonIgnore - 如果我们不希望Jackson处理java对象中public的属性或者拥有getter方法的属性，我们就可以使用这两个属性来忽略它们，相当于JAXB中@XmlTransient。

import java.io.IOException;import com.fasterxml.jackson.annotation.JsonIgnore;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;@JsonIgnoreProperties({"name", "age"})public class Dog {    public String name = "dahuang";    public int age = 11;    @JsonIgnore    public String home = "CHN";    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);        //Dog的所有属性都已经被忽略了，所以此时应该序列化为一个空json串        mapper.writeValue(System.out, new Dog());    }}

 

除了使用@JsonIgnoreProperties and @JsonIgnore来忽略特定属性外，还可以像下面这样忽略空的属性：

import java.io.IOException;import java.util.ArrayList;import java.util.List;import com.fasterxml.jackson.annotation.JsonInclude.Include;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;public class Dog {    public String name = "";    public List<String> info = new ArrayList<>();    public List<String> info2 = null;        public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);                //下面这行代码会忽略所有null或者空的属性，所以Dog此时依旧会被序列化为空JSON串        mapper.setSerializationInclusion(Include.NON_EMPTY);        mapper.writeValue(System.out, new Dog());    }}

 

5.在序列化的过程中保存类型信息

下面定义了一个父类Animal和它的两个子类Dog和Cat，Person类有一个Animal类型的属性。

Animal：

import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;public class Animal {    public String name;    public int age;    @JsonCreator    public Animal(@JsonProperty("name") String name, @JsonProperty("age") int age){        this.name = name;        this.age = age;    }}

 

Dog：

import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;public class Dog extends Animal{    public String size;        @JsonCreator    public Dog(@JsonProperty("name") String name, @JsonProperty("age") int age, @JsonProperty("size") String size){        super(name, age);        this.size = size;    }}

 

Cat:

import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;public class Cat extends Animal{    public String color;        @JsonCreator    public Cat(@JsonProperty("name") String name, @JsonProperty("age") int age, @JsonProperty("color") String color){        super(name, age);        this.color = color;    }}

 

Person:

public class Person {    public Animal animal;}

 

我们现在为Person的animal属性设置为Dog对象，然后序列化Person对象，之后再用得到的json串反序列化。

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.DeserializationFeature;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class Test {    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        Person person = new Person();        person.animal = new Dog("dahuang", 11, "big");                ObjectMapper mapper = new ObjectMapper();        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);                mapper.writeValue(new File("person.json"), person);                Person p2 = mapper.readValue(new File("person.json"), Person.class);        //在序列化的时候我们为Person对象animal属性赋予的是一个Dog对象，但是反序列化后得到的animal属性仅仅是一个animal对象。        //实际上，如果Animal是一个抽象类型的话，此时就会报错了。        System.out.println(p2.animal.getClass().getName());    }}

 

在上面的例子序列化的结果是：

{  "animal" : {    "name" : "dahuang",    "age" : 11,    "size" : "big"  }}

 

在上面的结果中我们看到Jackson并没有将animal属性的具体类型信息保存下来，这样在反序列化的时候，Jackson就无法知道之前序列化时的真正类型，这就是上面反序列化后得到的是一个Animal而不是Dog的原因。

我们修改Animal如下：

import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;import com.fasterxml.jackson.annotation.JsonSubTypes;import com.fasterxml.jackson.annotation.JsonSubTypes.Type;import com.fasterxml.jackson.annotation.JsonTypeInfo;import com.fasterxml.jackson.annotation.JsonTypeInfo.As;@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = As.PROPERTY, property = "@class")@JsonSubTypes({ @Type(value = Dog.class, name = "lion"), @Type(value = Cat.class, name = "elephant") })public class Animal {    public String name;    public int age;    @JsonCreator    public Animal(@JsonProperty("name") String name, @JsonProperty("age") int age){        this.name = name;        this.age = age;    }}

 

然后再次执行上面那段序列化和反序列化的代码，便可以得到Person的animal属性是一个Dog对象了。 序列化的json为：

{  "animal" : {    "@class" : "com.massclouds.info.Dog",    "name" : "dahuang",    "age" : 11,    "size" : "big"  }}

 我们看到上面的json结果中多了一个@class的属性，它就代表了animal属性的类型信息。

 当我们直接序列化一个Animal的list或者以Animal为value的map时，上面的设置依旧无法将类型信息保存到json串中，下面我们演示如何直接（反）序列化包含Animal的list和map（注意此时Animal上的注解依旧要有）。

序列化：

import java.io.File;import java.io.IOException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;public class SerializeList {    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        List<Animal> animal_list = new ArrayList<>();        animal_list.add(new Dog("dahuang", 11, "big"));        animal_list.add(new Cat("miaomiao", 11, "grey"));                Map<String, Animal> animal_map = new HashMap<>();        animal_map.put("dog", new Dog("dahuagn", 11, "big"));        animal_map.put("cat", new Cat("miaomiao", 11, "white"));                ObjectMapper mapper = new ObjectMapper();        mapper.enable(SerializationFeature.INDENT_OUTPUT);                mapper.writerFor(new TypeReference<List<Animal>>(){}).writeValue(new File("list.json"), animal_list);                mapper.writerFor(new TypeReference<Map<String, Animal>>(){}).writeValue(new File("map.json"), animal_map);    }}

 

反序列化：

import java.io.File;import java.io.IOException;import java.util.List;import java.util.Map;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class SerializeList {    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();                List<Animal> animal_list = mapper.readValue(new File("list.json"), new TypeReference<List<Animal>>(){});        animal_list.forEach(animal -> System.out.println(animal.getClass().getName()));                Map<String, Animal> animal_map = mapper.readValue(new File("map.json"), new TypeReference<Map<String, Animal>>(){});        animal_map.forEach((key, value) -> System.out.println(key + " --> " + value.getClass().getName()));    }}

 

上面需要注意的地方就是 由于Class对象中是不能携带泛型信息的，所以需要使用TypeReference。

 

6. Mix-in 

当我们使用的是第三方类库中的Java类型时，我们无法直接在类型上使用注解，此时我们可以使用Jackson提供的Mix-in功能。

我们有一个Dog类如下：

public class Dog {    public String name;    private int age;        public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }        public Dog(String name, int age){        this.name = name;        this.age = age;    }}

 

我们需要定义一个抽象类，如果我们希望在Dog类的什么地方使用注解，我们就在这个抽象类中定义一个相同的声明（属性或者方法），然后使用注解，例如我们希望在Dog中的getAge方法上使用@JsonProperty注解，那么我们就在这个抽象类中定义一个名称为getAge的抽象方法，然后再在这个抽象方法上使用@JsonProperty。下面是这个抽象类的实现：

import com.fasterxml.jackson.annotation.JsonCreator;import com.fasterxml.jackson.annotation.JsonProperty;public abstract class DogMixin{    @JsonProperty("dog_name")    public String name;        @JsonProperty("dog_age")    public abstract int getAge();        @JsonProperty("dog_age")    public abstract void setAge(int age);        @JsonCreator    public DogMixin(@JsonProperty("dog_name") String name,@JsonProperty("dog_age") int age){        //这里可以啥都没有。。。    }}

 

然后在序列化的时候，像下面这样使用，就可以跟直接在Dog类中使用注解产生一样的效果了。

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.core.JsonGenerationException;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper;public class Test {    public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {        ObjectMapper mapper = new ObjectMapper();        //注册我们使用的Mixin抽象类        mapper.addMixIn(Dog.class, DogMixin.class);                Dog dog = new Dog("dahuang", 11);        mapper.writerWithDefaultPrettyPrinter().writeValue(new File("dog.json"), dog);                Dog dog2 = mapper.readValue(new File("dog.json"), Dog.class);        System.out.println(dog2.getAge() + " : " + dog2.name);    }}

 

JSON <--> JsonNode Tree

就如同XML的DOM树一样，我们同样可以通过一颗json节点树来构建json，当然也可以将一个json字符串反序列化为一颗节点树。

Tree2JSON

import java.io.FileOutputStream;import java.io.IOException;import com.fasterxml.jackson.core.JsonFactory;import com.fasterxml.jackson.core.JsonGenerator;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.JsonNodeFactory;import com.fasterxml.jackson.databind.node.ObjectNode;public class Tree2JSON {    public static void main(String[] args) throws IOException {        JsonFactory jsonFactory = new JsonFactory();        JsonGenerator generator = jsonFactory.createGenerator(new FileOutputStream("tree.json"));                ObjectMapper mapper = new ObjectMapper();                JsonNodeFactory factory = new JsonNodeFactory(false);        //生成一个根节点        ObjectNode person = factory.objectNode();        //普通属性直接添加即可        person.put("name", "zhangsan");        person.put("age",  11);                //可以生成一个对象节点，然后把这个节点加入为根节点的子节点        ObjectNode address = factory.objectNode();        address.put("homeAddress", "New York");        address.put("workAddress", "Tokyo");        person.set("address", address);        //同样可以生成一个Array节点， 然后把这个Array节点加入为根节点的子节点        ArrayNode friends = factory.arrayNode();        ObjectNode friend1 = factory.objectNode();        friend1.put("name", "weiying");                ObjectNode friend2 = factory.objectNode();        friend2.put("name", "caifang");                friends.add(friend1).add(friend2);        person.set("friends", friends);                mapper.writeTree(generator, person);    }}

 

产生的json字符串为（我不知道在这种情况下序列化这个JSON，要是你知道请告诉我）：

{"name":"zhangsan","age":11,"address":{"homeAddress":"New York","workAddress":"Tokyo"},"friends":[{"name":"weiying"},{"name":"caifang"}]}

 

下面将这个JSON串反序列化为一颗树，并遍历这颗树：

import java.io.File;import java.io.IOException;import java.util.Iterator;import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.JsonNodeType;public class JSON2Tree {    public static void main(String[] args) throws JsonProcessingException, IOException {        ObjectMapper mapper = new ObjectMapper();        // ObjectMapper读取json，返回根节点        JsonNode root = mapper.readTree(new File("tree.json"));        review(root);    }    // 递归遍历整棵树    private static void review(JsonNode root) {        if (root.getNodeType().equals(JsonNodeType.OBJECT)) {            Iterator<String> fieldNames = root.fieldNames();            while (fieldNames.hasNext()) {                String fieldName = fieldNames.next();                JsonNode node = root.get(fieldName);                System.out.println(fieldName);                review(node);            }        } else if (root.getNodeType().equals(JsonNodeType.ARRAY)) {            ArrayNode array = (ArrayNode) root;            Iterator<JsonNode> iter = array.iterator();            iter.forEachRemaining(x -> review(x));        } else {            System.out.println(root);        }    }}

 

JSON <--> Json Stream 

Jackson提供了一种低层次的操作json的api，简单的说，就是Jackson读取json串后，会依次将json中的每个标志都产生相应的token，例如"{"表示对象的开始，那么Jackson 就产生一个表示对象开始的token。它很强大，但是很繁琐，不推荐使用。

import java.io.File;import java.io.IOException;import com.fasterxml.jackson.core.JsonFactory;import com.fasterxml.jackson.core.JsonParseException;import com.fasterxml.jackson.core.JsonParser;import com.fasterxml.jackson.core.JsonToken;public class StramParser {    public static void main(String[] args) throws JsonParseException, IOException {        JsonFactory factory = new JsonFactory();        JsonParser parser = factory.createParser(new File("person.json"));                while(!parser.isClosed()){            //这里仅仅简单的打印出token的类型和值（如果有的话）            JsonToken token = parser.nextToken();            System.out.println(token);            System.out.println(parser.getText());        }    }}

 

import java.io.IOException;import com.fasterxml.jackson.core.JsonFactory;import com.fasterxml.jackson.core.JsonGenerator;public class StreamGenerator {    public static void main(String[] args) throws IOException {        JsonFactory factory = new JsonFactory();        JsonGenerator generator = factory.createGenerator(System.out);         // start writing with {        generator.writeStartObject();        generator.writeFieldName("name");        generator.writeString("zhangsan");        generator.writeFieldName("address");        // start an array        generator.writeStartArray();        generator.writeStartObject();        generator.writeStringField("homeAddress", "New York");        generator.writeEndObject();        generator.writeStartObject();        generator.writeStringField("workAddress", "Tokyo");        generator.writeEndObject();        generator.writeEndArray();        generator.writeEndObject();         generator.close();    }}