1. package com.jackson.json.treemodel;  
2.   
3. import java.io.File;  
4. import java.io.FileWriter;  
5.   
6. import com.fasterxml.jackson.core.JsonFactory;  
7. import com.fasterxml.jackson.core.JsonGenerator;  
8. import com.fasterxml.jackson.databind.ObjectMapper;  
9. import com.fasterxml.jackson.databind.SerializationFeature;  
10. import com.fasterxml.jackson.databind.node.ArrayNode;  
11. import com.fasterxml.jackson.databind.node.JsonNodeFactory;  
12. import com.fasterxml.jackson.databind.node.ObjectNode;  
13.   
14. public class SerializationExampleTreeModel {  
15.       
16.     public static void main(String[] args) throws Exception {  
17.         //创建一个节点工厂,为我们提供所有节点  
18.         JsonNodeFactory factory = new JsonNodeFactory(false);  
19.         //创建一个json factory来写tree modle为json  
20.         JsonFactory jsonFactory = new JsonFactory();  
21.         //创建一个json生成器  
22.         JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File("country2.json")));  
23.         //注意，默认情况下对象映射器不会指定根节点，下面设根节点为country  
24.         ObjectMapper mapper = new ObjectMapper();  
25.         ObjectNode country = factory.objectNode();  
26.           
27.         country.put("country_id", "China");  
28.         country.put("birthDate", "1949-10-01");  
29.           
30.         //在Java中，List和Array转化为json后对应的格式符号都是"obj:[]"  
31.         ArrayNode nation = factory.arrayNode();  
32.         nation.add("Han").add("Meng").add("Hui").add("WeiWuEr").add("Zang");  
33.         country.set("nation", nation);  
34.           
35.         ArrayNode lakes = factory.arrayNode();  
36.         lakes.add("QingHai Lake").add("Poyang Lake").add("Dongting Lake").add("Taihu Lake");  
37.         country.set("lakes", lakes);  
38.           
39.         ArrayNode provinces = factory.arrayNode();  
40.         ObjectNode province = factory.objectNode();  
41.         ObjectNode province2 = factory.objectNode();  
42.         province.put("name","Shanxi");  
43.         province.put("population", 37751200);  
44.         province2.put("name","ZheJiang");  
45.         province2.put("population", 55080000);  
46.         provinces.add(province).add(province2);  
47.         country.set("provinces", provinces);  
48.           
49.         ObjectNode traffic = factory.objectNode();  
50.         traffic.put("HighWay(KM)", 4240000);  
51.         traffic.put("Train(KM)", 112000);  
52.         country.set("traffic", traffic);  
53.           
54.         mapper.configure(SerializationFeature.INDENT_OUTPUT, true);  
55.         mapper.writeTree(generator, country);  
56.     }  
57.   
58. }  

1. {"country_id":"China","birthDate":"1949-10-01","nation":["Han","Meng","Hui","WeiWuEr","Zang"],"lakes":["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"],"provinces":[{"name":"Shanxi","population":37751200},{"name":"ZheJiang","population":55080000}],"traffic":{"HighWay(KM)":4240000,"Train(KM)":112000}}  

1. package com.jackson.json.treemodel;  
2.   
3. import java.io.File;  
4. import java.util.Iterator;  
5.   
6. import com.fasterxml.jackson.databind.JsonNode;  
7. import com.fasterxml.jackson.databind.ObjectMapper;  
8.   
9. public class DeserializationExampleTreeModel1 {  
10.   
11.     public static void main(String[] args) throws Exception {  
12.         ObjectMapper mapper = new ObjectMapper();  
13.         // Jackson提供一个树节点被称为"JsonNode",ObjectMapper提供方法来读json作为树的JsonNode根节点  
14.         JsonNode node = mapper.readTree(new File("country2.json"));  
15.         // 看看根节点的类型  
16.         System.out.println("node JsonNodeType:"+node.getNodeType());  
17.         // 是不是一个容器  
18.         System.out.println("node is container Node ? "+node.isContainerNode());  
19.         // 得到所有node节点的子节点名称  
20.         System.out.println("---------得到所有node节点的子节点名称-------------------------");  
21.         Iterator<String> fieldNames = node.fieldNames();  
22.         while (fieldNames.hasNext()) {  
23.             String fieldName = fieldNames.next();  
24.             System.out.print(fieldName+" ");  
25.         }  
26.         System.out.println("\n-----------------------------------------------------");  
27.         // as.Text的作用是有值返回值，无值返回空字符串  
28.         JsonNode country_id = node.get("country_id");  
29.         System.out.println("country_id:"+country_id.asText() + " JsonNodeType:"+country_id.getNodeType());  
30.           
31.         JsonNode birthDate = node.get("birthDate");  
32.         System.out.println("birthDate:"+birthDate.asText()+" JsonNodeType:"+birthDate.getNodeType());  
33.           
34.         JsonNode nation = node.get("nation");  
35.         System.out.println("nation:"+ nation+ " JsonNodeType:"+nation.getNodeType());  
36.           
37.         JsonNode lakes = node.get("lakes");  
38.         System.out.println("lakes:"+lakes+" JsonNodeType:"+lakes.getNodeType());  
39.   
40.         JsonNode provinces = node.get("provinces");  
41.         System.out.println("provinces JsonNodeType:"+provinces.getNodeType());  
42.   
43.         boolean flag = true;  
44.         for (JsonNode provinceElements : provinces) {  
45.             //为了避免provinceElements多次打印，用flag控制打印，能体现provinceElements的JsonNodeType就可以了  
46.             if(flag){  
47.                 System.out.println("provinceElements JsonNodeType:"+provinceElements.getNodeType());  
48.                 System.out.println("provinceElements is container node? "+provinceElements.isContainerNode());  
49.                 flag = false;  
50.             }  
51.             Iterator<String> provinceElementFields = provinceElements.fieldNames();  
52.             while (provinceElementFields.hasNext()) {  
53.                 String fieldName = (String) provinceElementFields.next();  
54.                 String province;  
55.                 if ("population".equals(fieldName)) {  
56.                     province = fieldName + ":" + provinceElements.get(fieldName).asInt();  
57.                 }else{  
58.                     province = fieldName + ":" + provinceElements.get(fieldName).asText();  
59.                 }  
60.                 System.out.println(province);  
61.             }  
62.         }  
63.     }  
64. }  

1. node JsonNodeType:OBJECT  
2. node is container Node ? true  
3. ---------得到所有node节点的子节点名称-------------------------  
4. country_id birthDate nation lakes provinces traffic   
5. -----------------------------------------------------  
6. country_id:China JsonNodeType:STRING  
7. birthDate:1949-10-01 JsonNodeType:STRING  
8. nation:["Han","Meng","Hui","WeiWuEr","Zang"] JsonNodeType:ARRAY  
9. lakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAY  
10. provinces JsonNodeType:ARRAY  
11. provinceElements JsonNodeType:OBJECT  
12. provinceElements is container node? true  
13. name:Shanxi  
14. population:37751200  
15. name:ZheJiang  
16. population:55080000  

1. package com.jackson.json.treemodel;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5. import java.util.Iterator;  
6.   
7. import com.fasterxml.jackson.core.JsonProcessingException;  
8. import com.fasterxml.jackson.databind.JsonNode;  
9. import com.fasterxml.jackson.databind.ObjectMapper;  
10.   
11. public class DeserializationExampleTreeModle2 {  
12.       
13.     public static void main(String[] args) throws JsonProcessingException, IOException{  
14.         ObjectMapper mapper = new ObjectMapper();  
15.         JsonNode node = mapper.readTree(new File("country2.json"));  
16.         //path方法获取JsonNode时，当对象不存在时，返回MISSING类型的JsonNode  
17.         JsonNode missingNode = node.path("test");  
18.         if(missingNode.isMissingNode()){  
19.             System.out.println("JsonNodeType : " + missingNode.getNodeType());  
20.         }  
21.   
22.         System.out.println("country_id:"+node.path("country_id").asText());  
23.           
24.         JsonNode provinces = node.path("provinces");  
25.         for (JsonNode provinceElements : provinces) {  
26.             Iterator<String> provincesFields = provinceElements.fieldNames();  
27.             while (provincesFields.hasNext()) {  
28.                 String fieldName = (String) provincesFields.next();  
29.                 String province;  
30.                 if("name".equals(fieldName)){  
31.                     province = fieldName +":"+ provinceElements.path(fieldName).asText();  
32.                 }else{  
33.                     province = fieldName +":"+ provinceElements.path(fieldName).asInt();  
34.                 }  
35.                 System.out.println(province);  
36.             }  
37.         }  
38.     }  
39.   
40. }  

1. JsonNodeType : MISSING  
2. country_id:China  
3. name:Shanxi  
4. population:37751200  
5. name:ZheJiang  
6. population:55080000  

目录

• json格式的字符串与对象的互相转换
• Jackson 简介
• jackson特点
• json格式的字符串与对象的转换
• Jackson进行json转对象,对象转json总结
• JavaBean准备
• json字符串和对象互转
• json数组字符串和数组（集合）对象互转

package cn.hestyle.bean;
public class Book {
	private String id;
	private String name;
	private double price;
	private int pnum;
	private String category;
	private String description;
	
	public Book() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Book(String id, String name, double price, int pnum, String category, String description) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
		this.pnum = pnum;
		this.category = category;
		this.description = description;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	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 int getPnum() {
		return pnum;
	}
	public void setPnum(int pnum) {
		this.pnum = pnum;
	}
	public String getCategory() {
		return category;
	}
	public void setCategory(String category) {
		this.category = category;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	@Override
	public String toString() {
		return "Book [id=" + id + ", name=" + name + ", price=" + price + ", pnum=" + pnum + ", category=" + category
				+ ", description=" + description + "]";
	}
}

package cn.hestyle.utils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import cn.hestyle.bean.Book;
public class JacksonDemo01 {
	public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {
		ObjectMapper objectMapper = new ObjectMapper();
		//将对象转换为json格式的字符串
		Book book = new Book("1001", "Java入门到入土", 99.9, 100, "编程开发", "你懂得！");
		String bookJsonStr = objectMapper.writeValueAsString(book);
		System.out.println(bookJsonStr);
		//将集合、数组对象转换为json格式的字符串
		List<Book> bookList = new ArrayList<Book>();
		bookList.add(new Book("1001", "Java入门到入土", 99.9, 100, "编程开发", "你懂得！"));
		bookList.add(new Book("1002", "Python入门到入土", 89.9, 100, "编程开发", "你懂得！"));
		bookList.add(new Book("1003", "C++入门到入土", 89.9, 200, "编程开发", "你懂得！"));
		String bookListJsonStr = objectMapper.writeValueAsString(bookList);
		System.out.println(bookListJsonStr);
		
		//将json格式的字符串转化为对象
		//字符串中含有双引号，需要使用反斜杠转义
		String bookString = "{\"id\":\"1001\",\"name\":\"Java入门到入土\",\"price\":99.9,\"pnum\":100}";
		//Book必须有无参的构造方法
		Book book2 = objectMapper.readValue(bookString, Book.class);
		System.out.println(book2);
	}
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Company {
    private String companyName;
    private List<WebSite> webSites;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class WebSite {
    private String webSiteName;
    private List<User> users;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String userId;
    private String username;
    private String password;
}

    /**
     * 序列化：对象转json字符串，包含多个数组
     *
     */
    @Test
    public void testObject2Json2() {
        User user2 = new User("1","上海辟谣专属队","职业辟谣，不信谣，不传谣，呵呵");
        List<User> users = new ArrayList<>();
        users.add(user2);
        WebSite webSite = new WebSite();
        webSite.setWebSiteName("xxxxxx.com");
        webSite.setUsers(users);
        List<WebSite> webSites = new ArrayList<>();
        webSites.add(webSite);
        Company company = new Company();
        company.setCompanyName("yyyyyy");
        company.setWebSites(webSites);
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String jsonString = objectMapper.writeValueAsString(company);
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

    @Test
    public void testJson2Object() {
        String json = "{\"companyName\":\"yyyyyy\",\"webSites\":[" +
                "{\"webSiteName\":\"xxxxxx.com\",\"users\":[{\"userId\":\"1\",\"username\":\"上海辟谣专属队\",\"password\":\"职业辟谣，不信谣，不传谣，呵呵\"}]}" +
                "]}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            Company company = objectMapper.readValue(json, Company.class);
            System.out.println(company.getWebSites().get(0).getUsers().get(0).getUsername());
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

    /**
     * 序列化：数组对象转json数组类型的字符串
     *
     */
    @Test
    public void testObjectArray2JsonArrayString() {
        User user1 = new User("1","上海带刀沪卫","带刀大佬");
        User user2 = new User("1","上海辟谣专属队","职业辟谣，不信谣，不传谣，呵呵");
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String json = objectMapper.writeValueAsString(users);
            System.out.println(json);
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

    /**
     * 反序列化：数组类型的json字符串转对象数组
     *
     */
    @Test
    public void testJsonArrayString2ObjectArray() {
        String json = "[" +
                "{\"userId\":\"1\",\"username\":\"上海带刀沪卫\",\"password\":\"带刀大佬\"}" +
                ",{\"userId\":\"1\",\"username\":\"上海辟谣专属队\",\"password\":\"职业辟谣，不信谣，不传谣，呵呵\"}" +
                "]";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
			//错误写法
            List<User> list = objectMapper.readValue(json, List.class);
            list.forEach(user -> {
                System.out.println(user.getUsername());
            });
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

    /**
     * 反序列化：数组类型的json字符串转对象数组
     *
     */
    @Test
    public void testJsonArrayString2ObjectArray() {
        String json = "[" +
                "{\"userId\":\"1\",\"username\":\"上海带刀沪卫\",\"password\":\"带刀大佬\"}" +
                ",{\"userId\":\"1\",\"username\":\"上海辟谣专属队\",\"password\":\"职业辟谣，不信谣，不传谣，呵呵\"}" +
                "]";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            TypeReference<List<User>> typeReference = new TypeReference<List<User>>() {
            };
            List<User> list = objectMapper.readValue(json, typeReference);
            list.forEach(user -> {
                System.out.println(user.getUsername());
            });
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

    @Test
    public void testJsonArrayString2ObjectArray2() {
        String json = "[" +
                    "{" +
                    "\"companyName\":\"yyyyyy\",\"webSites\":[" +
                            "{\"webSiteName\":\"xxxxxx.com\",\"users\":[" +
                                "{\"userId\":\"1\",\"username\":\"上海辟谣专属队\",\"password\":\"职业辟谣，不信谣，不传谣，呵呵\"}" +
                                "]" +
                            "}" +
                        "]" +
                    "}" +
                "]";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            TypeReference<List<Company>> typeReference = new TypeReference<List<Company>>() {
            };
            List<Company> list = objectMapper.readValue(json, typeReference);
            list.forEach(company -> {
                System.out.println(company.getWebSites().get(0).getUsers().get(0).getUsername());
            });
        } catch (JsonProcessingException e) {
            log.error("error: ", e);
        }
    }

• mysql5.6 解析JSON字符串方式(支持复杂的嵌套格式)
• 使用JSON.toJSONString格式化成json字符串时保留null属性
• Mysql怎么存储json格式数据详解
• json文件书写格式详解
• Json格式详解
• JSON 格式的弊端与解决方法(真实示例)