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