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(); } }