依赖maven:

  1.    <dependency>
  2.             <groupId>com.fasterxml.jackson.core</groupId>
  3.             <artifactId>jackson-databind</artifactId>
  4.             <version>2.6.5</version>
  5.         </dependency>
  6.  
  7.         <dependency>
  8.             <groupId>com.fasterxml.jackson.core</groupId>
  9.             <artifactId>jackson-core</artifactId>
  10.             <version>2.6.5</version>
  11.         </dependency>
  12.  
  13.         <dependency>
  14.             <groupId>com.fasterxml.jackson.core</groupId>
  15.             <artifactId>jackson-annotations</artifactId>
  16.             <version>2.6.5</version>
  17.         </dependency>

code:

User:

  1. import lombok.*;
  2.  
  3. @Data
  4. @ToString
  5. @NoArgsConstructor
  6. @AllArgsConstructor
  7. public class User {
  8.     private int id;
  9.     private String name;
  10.     private String email;
  11.     private String address;
  12.     private Birthday birthday;
  13. }

Birthday:

  1. import lombok.*;
  2.  
  3. @Data
  4. @ToString
  5. @NoArgsConstructor
  6. @AllArgsConstructor
  7. public class Birthday {
  8.     private String birthday;
  9. }

User2:

  1. import lombok.AllArgsConstructor;
  2. import lombok.Data;
  3. import lombok.NoArgsConstructor;
  4. import lombok.ToString;
  5.  
  6. @Data
  7. @ToString
  8. @NoArgsConstructor
  9. @AllArgsConstructor
  10. public class User2 {
  11.     private int id;
  12.     private String name;
  13.     private String email;
  14. //    private String address;
  15. //    private Birthday birthday;
  16. }

1.查看基础类型的序列化与反序列化：

  1. import com.fasterxml.jackson.databind.ObjectMapper;
  2. import lombok.val;
  3.  
  4. import java.io.IOException;
  5. import java.util.ArrayList;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Map;
  9.  
  10. public class test{
  11.  
  12.     private final static ObjectMapper objectMapper = new ObjectMapper();
  13.  
  14.     public static void main(String[] args) {
  15.  
  16.         User user = new User();
  17.         user.setAddress("asdf");
  18.         user.setAddress("中国河南省");
  19.         user.setEmail("xiaokui_wingfly@sina.com.cn");
  20.         user.setId(1);
  21.         user.setName("X-rapido");
  22.         user.setBirthday(new Birthday("2015-08-06"));
  23.  
  24.         List<String> list = new ArrayList<String>();
  25.         list.add("a");
  26.         list.add("b");
  27.         list.add("c");
  28.  
  29.         Map<String, Object> map = new HashMap<String, Object>();
  30.         map.put("a", "1");
  31.         map.put("b", "2");
  32.         map.put("c", "3");
  33.         map.put("list", list);
  34.  
  35.         String []sz = {"a","b","c"};
  36.  
  37.         try {
  38.             System.out.println(objectMapper.writeValueAsString(user));
  39.             System.out.println(objectMapper.writeValueAsString(list));
  40.             System.out.println(objectMapper.writeValueAsString(map));
  41.             System.out.println(objectMapper.writeValueAsString(sz));
  42.  
  43.             String s = "{\"name\":\"X-rapido\"}";
  44.             // Json转换JavaBean
  45.             User a = objectMapper.readValue(s, User.class);
  46.             System.out.println(a.getName());
  47.  
  48.             // JavaBean转换Json
  49.             System.out.println(objectMapper.writeValueAsString(a));
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  54. }

Output:

  1. {"id":1,"name":"X-rapido","email":"xiaokui_wingfly@sina.com.cn","address":"中国河南省","birthday":{"birthday":"2015-08-06"}}
  2. ["a","b","c"]
  3. {"a":"1","b":"2","c":"3","list":["a","b","c"]}
  4. ["a","b","c"]
  5. X-rapido
  6. {"id":0,"name":"X-rapido","email":null,"address":null,"birthday":null}

2.有这么种情况，就是字符串反序列化为对象，但是字符串中的很多字段我都不需要，只需要一部分，这个时候怎么反序列化：

  1. import com.fasterxml.jackson.databind.DeserializationFeature;
  2. import com.fasterxml.jackson.databind.ObjectMapper;
  3. import lombok.val;
  4.  
  5. import java.io.IOException;
  6.  
  7. public class test{
  8.  
  9.     private final static ObjectMapper objectMapper = new ObjectMapper();
  10.     public static void main(String[] args) {
  11.  
  12.         //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
  13.         //因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
  14.         objectMapper .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  15.  
  16.         User user = new User();
  17.         user.setAddress("asdf");
  18.         user.setAddress("中国河南省");
  19.         user.setEmail("xiaokui_wingfly@sina.com.cn");
  20.         user.setId(1);
  21.         user.setName("X-rapido");
  22.         user.setBirthday(new Birthday("2015-08-06"));
  23.  
  24.         try {
  25.             System.out.println("========begin=======");
  26.             val content=objectMapper.writeValueAsString(user);
  27.             System.out.println(content);
  28.             User2 u=objectMapper.readValue(content,User2.class);
  29.             System.out.println(objectMapper.writeValueAsString(u));
  30.             System.out.println("========end=======");
  31.  
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36. }

Output:

  1. ========begin=======
  2. {"id":1,"name":"X-rapido","email":"xiaokui_wingfly@sina.com.cn","address":"中国河南省","birthday":{"birthday":"2015-08-06"}}
  3. {"id":1,"name":"X-rapido","email":"xiaokui_wingfly@sina.com.cn"}
  4. ========end=======

注意：

  1.         objectMapper .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

如果不加这个会报错：

  1. ========begin=======
  2. {"id":1,"name":"X-rapido","email":"xiaokui_wingfly@sina.com.cn","address":"中国河南省","birthday":{"birthday":"2015-08-06"}}
  3. com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "address" (class com.qhong.json.User2), not marked as ignorable (3 known properties: "id", "email", "name"])
  4.  at [Source: {"id":1,"name":"X-rapido","email":"xiaokui_wingfly@sina.com.cn","address":"中国河南省","birthday":{"birthday":"2015-08-06"}}; line: 1, column: 76] (through reference chain: com.qhong.json.User2["address"])
  5.     at com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException.from(UnrecognizedPropertyException.java:51)
  6.     at com.fasterxml.jackson.databind.DeserializationContext.reportUnknownProperty(DeserializationContext.java:839)
  7.     at com.fasterxml.jackson.databind.deser.std.StdDeserializer.handleUnknownProperty(StdDeserializer.java:1045)
  8.     at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.handleUnknownProperty(BeanDeserializerBase.java:1352)
  9.     at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.handleUnknownVanilla(BeanDeserializerBase.java:1330)
  10.     at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:264)
  11.     at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:125)
  12.     at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:3736)
  13.     at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2726)
  14.     at com.qhong.json.test.main(test.java:29)

3.怎么反序列化对象数组：

  1. import com.fasterxml.jackson.databind.DeserializationFeature;
  2. import com.fasterxml.jackson.databind.ObjectMapper;
  3. import lombok.val;
  4.  
  5. import java.io.IOException;
  6. import java.util.ArrayList;
  7. import java.util.Arrays;
  8. import java.util.List;
  9.  
  10. public class test{
  11.     private final static ObjectMapper objectMapper = new ObjectMapper();
  12.     public static void main(String[] args) {
  13.         //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
  14.         //因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
  15.         objectMapper .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  16.  
  17.         List<User> arr= Arrays.asList(
  18.                     new User(1, "name1", "email1", "address1", new Birthday("2016-08-01")),
  19.                     new User(2 ,"name2", "email2", "address2", new Birthday("2016-08-02")),
  20.                     new User(3, "name3", "email3", "address3", new Birthday("2016-08-03"))
  21.         );
  22.  
  23.         try {
  24.             System.out.println("========begin=======");
  25.             val content=objectMapper.writeValueAsString(arr);
  26.             System.out.println(content);
  27.             List<User> list=objectMapper.readValue(content,new com.fasterxml.jackson.core.type.TypeReference<List<User>>(){});
  28.             System.out.println(objectMapper.writeValueAsString(list));
  29.             System.out.println("另外的方式：");
  30.            // List<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));
  31.             List<User> list2=objectMapper.readValue(content,objectMapper.getTypeFactory().constructCollectionType(ArrayList.class,User.class));
  32.             System.out.println(objectMapper.writeValueAsString(list2));
  33.             System.out.println("========end=======");
  34.  
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

Output:

  1. ========begin=======
  2. [{"id":1,"name":"name1","email":"email1","address":"address1","birthday":{"birthday":"2016-08-01"}},{"id":2,"name":"name2","email":"email2","address":"address2","birthday":{"birthday":"2016-08-02"}},{"id":3,"name":"name3","email":"email3","address":"address3","birthday":{"birthday":"2016-08-03"}}]
  3. [{"id":1,"name":"name1","email":"email1","address":"address1","birthday":{"birthday":"2016-08-01"}},{"id":2,"name":"name2","email":"email2","address":"address2","birthday":{"birthday":"2016-08-02"}},{"id":3,"name":"name3","email":"email3","address":"address3","birthday":{"birthday":"2016-08-03"}}]
  4. 另外的方式：
  5. [{"id":1,"name":"name1","email":"email1","address":"address1","birthday":{"birthday":"2016-08-01"}},{"id":2,"name":"name2","email":"email2","address":"address2","birthday":{"birthday":"2016-08-02"}},{"id":3,"name":"name3","email":"email3","address":"address3","birthday":{"birthday":"2016-08-03"}}]
  6. ========end=======

还有一些其他的特殊情况，比如json对象key没有双引号等

  1. import com.fasterxml.jackson.annotation.JsonInclude;
  2. import com.fasterxml.jackson.core.JsonGenerator;
  3. import com.fasterxml.jackson.core.JsonParser;
  4. import com.fasterxml.jackson.core.type.TypeReference;
  5. import com.fasterxml.jackson.databind.DeserializationFeature;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import com.fasterxml.jackson.databind.SerializationFeature;
  8. import lombok.AllArgsConstructor;
  9. import lombok.Data;
  10. import lombok.NoArgsConstructor;
  11. import lombok.ToString;
  12. import java.util.List;
  13.  
  14. public class test2{
  15.     private final static  ObjectMapper mapper= new ObjectMapper();
  16.         public static void main(String[] args) {
  17.           try {
  18.               mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  19.               // 如果为空则不输出
  20.               mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
  21.               // 对于空的对象转json的时候不抛出错误
  22.               mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
  23.               // 禁用序列化日期为timestamps
  24.               mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  25.               // 禁用遇到未知属性抛出异常
  26.               mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  27.               // 视空字符传为null
  28.               mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
  29.  
  30.               // 低层级配置
  31.               mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
  32.               // 允许属性名称没有引号
  33.               mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
  34.               // 允许单引号
  35.               mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
  36.               // 取消对非ASCII字符的转码
  37.               mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, false);
  38.  
  39.               //mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
  40.               String str = " [\n" +
  41.                       "    {\n" +
  42.                       "        \"symbol\": \"sh603111\", \n" +
  43.                       "        \"code\": \"603111\", \n" +
  44.                       "        \"name\": \"康尼机电\", \n" +
  45.                       "        \"trade\": \"14.530\", \n" +
  46.                       "        \"pricechange\": \"0.770\", \n" +
  47.                       "        \"changepercent\": \"5.596\", \n" +
  48.                       "        \"buy\": \"14.530\", \n" +
  49.                       "        \"sell\": \"14.540\", \n" +
  50.                       "        \"settlement\": \"13.760\", \n" +
  51.                       "        \"open\": \"13.820\", \n" +
  52.                       "        \"high\": \"14.540\", \n" +
  53.                       "        \"low\": \"13.820\", \n" +
  54.                       "        \"volume\": 18591408, \n" +
  55.                       "        \"amount\": 266138177, \n" +
  56.                       "        \"ticktime\": \"15:00:00\", \n" +
  57.                       "        \"per\": 44.339, \n" +
  58.                       "        \"pb\": 7.731, \n" +
  59.                       "        \"mktcap\": 1072870.86225, \n" +
  60.                       "        \"nmc\": 697004.688465, \n" +
  61.                       "        \"turnoverratio\": 3.87563\n" +
  62.                       "    }, \n" +
  63.                       "    {\n" +
  64.                       "        \"symbol\": \"sz300355\", \n" +
  65.                       "        \"code\": \"300355\", \n" +
  66.                       "        \"name\": \"蒙草生态\", \n" +
  67.                       "        \"trade\": \"12.330\", \n" +
  68.                       "        \"pricechange\": \"0.620\", \n" +
  69.                       "        \"changepercent\": \"5.295\", \n" +
  70.                       "        \"buy\": \"12.330\", \n" +
  71.                       "        \"sell\": \"12.340\", \n" +
  72.                       "        \"settlement\": \"11.710\", \n" +
  73.                       "        \"open\": \"11.640\", \n" +
  74.                       "        \"high\": \"12.580\", \n" +
  75.                       "        \"low\": \"11.640\", \n" +
  76.                       "        \"volume\": 142839605, \n" +
  77.                       "        \"amount\": 1741652819, \n" +
  78.                       "        \"ticktime\": \"15:06:03\", \n" +
  79.                       "        \"per\": 35.229, \n" +
  80.                       "        \"pb\": 6.27, \n" +
  81.                       "        \"mktcap\": 1978030.485873, \n" +
  82.                       "        \"nmc\": 1428385.32288, \n" +
  83.                       "        \"turnoverratio\": 12.33009\n" +
  84.                       "    }\n" +
  85.                       "]";
  86.               System.out.println(str);
  87.               List<riseInfo> list = mapper.readValue(str, new TypeReference<List<riseInfo>>() {
  88.               });
  89.               System.out.println(list.size());
  90.           }catch (Exception ex){
  91.               System.out.println(ex.getMessage());
  92.               System.out.println(ex.getStackTrace());
  93.           }
  94.         }
  95. }
  96.  
  97. @Data
  98. @ToString
  99. @NoArgsConstructor
  100. @AllArgsConstructor
  101. class riseInfo {
  102.     private String symbol;
  103.     private String code;
  104.     private String name;
  105. }

Output:

  1.  [
  2.     {
  3.         "symbol": "sh603111",
  4.         "code": "",
  5.         "name": "康尼机电",
  6.         "trade": "14.530",
  7.         "pricechange": "0.770",
  8.         "changepercent": "5.596",
  9.         "buy": "14.530",
  10.         "sell": "14.540",
  11.         "settlement": "13.760",
  12.         "open": "13.820",
  13.         "high": "14.540",
  14.         "low": "13.820",
  15.         "volume": ,
  16.         "amount": ,
  17.         "ticktime": "15:00:00",
  18.         "per": 44.339,
  19.         "pb": 7.731,
  20.         "mktcap": 1072870.86225,
  21.         "nmc": 697004.688465,
  22.         "turnoverratio": 3.87563
  23.     },
  24.     {
  25.         "symbol": "sz300355",
  26.         "code": "",
  27.         "name": "蒙草生态",
  28.         "trade": "12.330",
  29.         "pricechange": "0.620",
  30.         "changepercent": "5.295",
  31.         "buy": "12.330",
  32.         "sell": "12.340",
  33.         "settlement": "11.710",
  34.         "open": "11.640",
  35.         "high": "12.580",
  36.         "low": "11.640",
  37.         "volume": ,
  38.         "amount": ,
  39.         "ticktime": "15:06:03",
  40.         "per": 35.229,
  41.         "pb": 6.27,
  42.         "mktcap": 1978030.485873,
  43.         "nmc": 1428385.32288,
  44.         "turnoverratio": 12.33009
  45.     }
  46. ]

添加配置即可！

http://blog.csdn.net/langzi7758521/article/details/52072457

http://www.cnblogs.com/kakag/p/5054772.html

http://www.cnblogs.com/dupang/p/5673097.html

https://codeday.me/bug/20170221/3548.html

Jackson 使用和注意项的更多相关文章

  1. 使用jackson对Java对象与JSON字符串相互转换的一些总结

    本文为菠萝大象原创,如要转载请注明出处.http://www.blogjava.net/bolo 代码无真相,为了最简单的说明,我直接上代码. public class User { private  ...

  2. jackson的简单实用实例(json)

    一个json格式的字符串比如: {"status":10001,"code":"HDkGzI","pubkey":&qu ...

  3. JSON(三）——java中对于JSON格式数据的解析之json-lib与jackson

    java中对于JSON格式数据的操作,主要是json格式字符串与JavaBean之间的相互转换.java中能够解析JSON格式数据的框架有很多,比如json-lib,jackson,阿里巴巴的fast ...

  4. Jackson解析XML

    使用Jackson maven项目的pom.xml依赖 <dependency> <groupId>com.fasterxml.jackson.dataformat</g ...

  5. Jackson 工具类使用及配置指南

    目录 前言 Jackson使用工具类 Jackson配置属性 Jackson解析JSON数据 Jackson序列化Java对象 前言 Json数据格式这两年发展的很快,其声称相对XML格式有很对好处: ...

  6. JSON类库Jackson与JSON-lib性能对比[转]

    Jackson:http://jackson.codehaus.org/ JSON-lib:http://json-lib.sourceforge.net/ Gson:http://code.goog ...

  7. Jackson工具类使用及配置指南、高性能配置（转）

    Jackson使用工具类 通常,我们对JSON格式的数据,只会进行解析和封装两种,也就是JSON字符串--->Java对象以及Java对象--->JSON字符串. public class ...

  8. 两款JSON类库Jackson与JSON-lib的性能对比(新增第三款测试)

    本篇文章主要介绍了"两款JSON类库Jackson与JSON-lib的性能对比(新增第三款测试)",主要涉及到两款JSON类库Jackson与JSON-lib的性能对比(新增第三款 ...

  9. jackson 进行json与java对象转换 之一

    代码无真相,为了最简单的说明,我直接上代码. public class User { private String name; private Gender gender; private List& ...

随机推荐

  1. vue - 组件的创建

    组件的创建 vue的核心基础就是组件的使用,玩好了组件才能将前面学的基础更好的运用起来.组件的使用更使我们的项目解耦合.更加符合vue的设计思想MVVM. 那接下来就跟我看一下如何在一个Vue实例中使 ...

  2. Windows server 2016 安装及ORACLE 12C 安装

    首先创建虚拟机,选择windows server 2016 启动虚拟机,进入安装界面,语言默认中文,选择下一步 选择标准安装(桌面) 选择接受条款 选择自定义安装 进行分区,如下图所示 进行安装 设定 ...

  3. LightOJ 1027 - A Dangerous Maze(求期望)

    题目链接:http://lightoj.com/volume_showproblem.php?problem=1027 题意:又一个迷宫,有n个门,每个门又一个值num,如果num>0 说明在n ...

  4. 总结web应用中常用的各种cache（转）

    add by zhj:还没来得及看,有空再细看 原文:https://ruby-china.org/topics/19389 cache是提高应用性能重要的一个环节,写篇文章总结一下用过的各种对于动态 ...

  5. Infopath表单&Reproting Service在IE11下问题解决

    一.打开表单出现错误:“对象不支持“addEventListener”属性或方法”错误 解决方法: 1. IE11浏览器--->选项 2. 勾选"在兼容性视图中显示intranet站点 ...

  6. IO流（1）File类构造方法

    构造方法: * File(String pathname):根据一个路径得到File对象 * File(String parent, String child):根据一个目录和一个子文件/目录得到Fi ...

  7. fork 了别人的仓库后，如何将自己的代码和原仓库保持一致

    fork 了别人的仓库后,如何将自己的代码和原仓库保持一致 git remote add upstream http:// git fetch upstream  

  8. Selenium+Java元素定位之一

    通过id进行定位 driver.findElement(By.id("kw")).sendKeys("博客园"); 通过name进行定位 driver.find ...

  9. Outlier Detection

    1)正态分布数据,飘出95%的可能是异常值.变量var正态标准化,|var|<=1.96的可能是异常值,further chk needed!large sample better. 对于偏态分 ...

  10. SpringMyBatisDay01

    1.Spring简介 Spring是一个开源轻量级应用开发框架,其目的是用于简化企业级应用程序的开发,降低侵入性Spring提供IOC和AOP功能,可以将组件(就是类)之间的耦合度降至最低,解耦,便于 ...