精华内容
下载资源
问答
  • Jackson 框架

    2017-09-28 14:59:23
    Jackson 开发 jar可以将Java对象转成json格式的字符串,也可以将Java对象转换成xml格式的文档,同样可以将json字符串转换成Java对象或是将xml字符串转换成Java对象。
  • 本篇文章主要介绍了java的Jackson框架实现轻易转换JSON,Jackson将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象,有兴趣的可以了解一下。
  • Jackson框架

    2017-03-23 18:42:54
    Jackson框架 一、Jackson简介  Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。相比json-lib框架,Jackson所依赖的jar包较少,简单易用并且性能也要相对高些。 二、...

    Jackson框架

    一、Jackson简介

           Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。相比json-lib框架,Jackson所依赖的jar包较少,简单易用并且性能也要相对高些。

    二、Jackson使用

    2.1、ObjectMapper的使用

        建立两个类Address、Employee

    public class Address {
        private String street;
        private String city;
        private int zipCode;
        public String getStreet() {
            return street;
        }
        public void setStreet(String street) {
            this.street = street;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
        public int getZipCode() {
            return zipCode;
        }
        public void setZipcode(int zipcode) {
            this.zipCode = zipcode;
        }
        @Override
        public String toString(){
            return getStreet() + ", "+getCity()+", "+getZipCode();
        }
    }

    public class Employee {
        private int id;
        private String name;
        private int age;
        private BigDecimal salary;
        private String designation;
        private Address address;
        private long[] phoneNumbers;
        private Map<String, String> personalInformation;
        /*Getter and Setter Methods*/
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        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 BigDecimal getSalary() {
            return salary;
        }
    
        public void setSalary(BigDecimal salary) {
           this.salary = salary;
        }
        public String getDesignation() {
            return designation;
        }
    
        public void setDesignation(String designation) {
            this.designation = designation;
        }
        public Address getAddress() {
            return address;
        }
    
        public void setAddress(Address address) {
            this.address = address;
        }
        public long[] getPhoneNumbers() {
            return phoneNumbers;
        }
    
        public void setPhoneNumbers(long[] phoneNumbers) {
            this.phoneNumbers = phoneNumbers;
        }
        public Map<String, String> getPersonalInformation() {
            return personalInformation;
        }
        public void setPersonalInformation(Map<String, String> personalInformation) {
            this.personalInformation = personalInformation;
        }
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("ID: " + getId() + "\n");
            sb.append("Name: " + getName() + "\n");
            sb.append("Age: " + getAge() + "\n");
            sb.append("Salary: $" + getSalary() + "\n");
            sb.append("Designation: " + getDesignation() + "\n");
            sb.append("Phone Numbers: " + Arrays.toString(getPhoneNumbers()) + "\n");
            sb.append("Address: " + getAddress() + "\n");
            sb.append("Personal Information:" + getPersonalInformation() + "\n");
            return sb.toString();
    
        }
    
    }

    json格式的文件data.json如下:

    {
      	 "id" : 123,
     	 "name" : "Henry Smith",
     	 "age" : 28,
      	 "salary" : 2000,
     	 "designation" : "Programmer",
      	 "address" : {
        	"street" : "Park Avn.",
        	"city" : "Westchester",
        	"zipcode" : 10583
     	 },
      	"phoneNumbers" : [ 654321, 222333 ],
      	"personalInformation" : {
        	"gender" : "Male",
        	"maritialstatus" : "Married"
    	}
    }

    1、从文件中读取json或向文件中写入json

    //Jackson读取json文件,将json数据转化为对象
    	public void testJsonToObject() throws JsonParseException, JsonMappingException, IOException{
            ObjectMapper objectMapper = new ObjectMapper();
            Employee emp = objectMapper.readValue(new File("src/data.json"), Employee.class);
            System.out.println(emp.toString());
    	}
    	//Jackson将java对象转化为json字符串并输出
    	public void testObjectTojson() throws JsonParseException, JsonMappingException, IOException{
            ObjectMapper objectMapper = new ObjectMapper();
            Employee emp = objectMapper.readValue(new File("src/data.json"), Employee.class);
            //将对象转化为json格式,并存入到文件中
            objectMapper.writeValue(new File("src/data1.json"), emp);
            //将对象转化为json格式数据,并输出到控制台上
            objectMapper.writeValue(System.out, emp);
            
    //        StringWriter  str =new StringWriter();
    //        JsonGenerator s=new JsonFactory().createGenerator(str);
    //        objectMapper.writeValue(s, emp);
    //        String data =new String();
    //        str.write(data);
    //        System.out.println(data);
    	}

    2、从InputStream读入或向OutPutStream写出

    public void testInputStream() throws JsonParseException, JsonMappingException, IOException{
            ObjectMapper objectMapper = new ObjectMapper();
            Employee emp = objectMapper.readValue(new FileInputStream("src/data.json"), Employee.class);
            System.out.println(emp.toString());
    	}
    	public void testOutPutStream() throws JsonParseException, JsonMappingException, IOException{
            ObjectMapper objectMapper = new ObjectMapper();
            Employee emp = objectMapper.readValue(new File("src/data.json"), Employee.class);
            //将对象转化为json格式,并存入到文件中
            objectMapper.writeValue(new FileOutputStream("src/data1.json"), emp);
    
            //JsonNode node = mapper.readTree(new File("country2.json"));
    
           //将对象转化为json格式数据,并输出到控制台上
            objectMapper.writeValue(System.out, emp);
    
    	}

    3、从URL中读取数据(若URL返回的满足Employee类的json数据)

    Employee emp1 = objectMapper.readValue("http://www.xxx.com/xxx", Employee.class);
    JsonNode jsonNode = objectMapper.readTree("http://www.xxx.com/xxx");
    

    4、常用的方法

    //将user对象转化为json格式字符串
    String json=mapper.writeValueAsString(user)
    
    //将json格式的字符串转化为对象,示例如下:
    Map m = mapper.readValue(json, Map.class)
    Employee emp = objectMapper.readValue(new File("src/data.json"), Employee.class);
    

    2.2、JsonGenerator

    public void testJsonGenerator() throws IOException{
    		URL url =new URL("http://www.xxx.com/xxx");
    		URLConnection urlConnection = url.openConnection();
    		urlConnection.setDoOutput(true);
    		urlConnection.setDoInput(true);
    		
    		//产生一个JsonGenerator类
    		JsonFactory jsonFactory = new JsonFactory();
    		JsonGenerator jsonGenerator = jsonFactory.createGenerator(urlConnection.getOutputStream(), JsonEncoding.UTF8);
    		jsonGenerator.writeString("wwwwwwwww");		
    		jsonGenerator.writeStartObject();
    		jsonGenerator.writeStringField("brand", "Mercedes");
    		jsonGenerator.writeNumberField("doors", 5);
    		jsonGenerator.writeEndObject();
    		jsonGenerator.close();
    	}






    展开全文
  • 史上最全的Jackson框架使用教程

    千次阅读 2020-08-28 23:36:04
    简单介绍别再使用 fastJson 了!漏洞天天报,Bug 修不完。快来拥抱 Jackson 吧!Jackson 是用来序列化和反序列化 json 的 Java 的开源框架。Spring...

    简单介绍

    别再使用 fastJson 了!漏洞天天报,Bug 修不完。快来拥抱 Jackson 吧!

    Jackson 是用来序列化和反序列化 json 的 Java 的开源框架。Spring MVC 的默认 json 解析器便是 Jackson。与其他 Java 的 json 的框架 Gson 等相比, Jackson 解析大的 json 文件速度比较快;Jackson 运行时占用内存比较低,性能比较好;Jackson 有灵活的 API,可以很容易进行扩展和定制。

    Jackson 的 1.x 版本的包名是 org.codehaus.jackson ,当升级到 2.x 版本时,包名变为 com.fasterxml.jackson,本文讨论的内容是基于最新的 Jackson 的 2.9.1 版本。

    Jackson 的核心模块由三部分组成。

    • jackson-core,核心包,提供基于"流模式"解析的相关 API,它包括 JsonPaser 和 JsonGenerator。Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。

    • jackson-annotations,注解包,提供标准注解功能;

    • jackson-databind ,数据绑定包, 提供基于"对象绑定" 解析的相关 API ( ObjectMapper ) 和"树模型" 解析的相关 API (JsonNode);基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。

    在了解 Jackson 的概要情况之后,下面介绍 Jackson 的基本用法。

    导入依赖

    若想在 Java 代码中使用 Jackson 的核心模块的 jar 包 ,需要在 pom.xml 中添加如下信息。

    <dependency> 
    <groupId>com.fasterxml.jackson.core</groupId> 
    <artifactId>jackson-databind</artifactId> 
    <version>2.9.1</version> 
    </dependency>
    

    jackson-databind 依赖 jackson-corejackson-annotations,当添加 jackson-databind 之后, jackson-corejackson-annotations 也随之添加到 Java 项目工程中。在添加相关依赖包之后,就可以使用 Jackson。

    快速入门

    Jackson 最常用的 API 就是基于"对象绑定" 的 ObjectMapper。下面是一个 ObjectMapper 的使用的简单示例。

    准备一个名称为 Person 的 Java 对象:

    public class Person {
        // 正常case
        private String name;
        // 空对象case
        private Integer age;
        // 日期转换case
        private Date date;
        // 默认值case
        private int height;
    }
    

    使用示例:

    @Test
    public void test1() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // 造数据
        Person person = new Person();
        person.setName("Tom");
        person.setAge(40);
        person.setDate(new Date());
        System.out.println("序列化");
        String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
        System.out.println(jsonString);
        System.out.println("反序列化");
        Person deserializedPerson = mapper.readValue(jsonString, Person.class);
        System.out.println(deserializedPerson);
    }
    

    打印输出:

    序列化
    {
    "name" : "Tom",
    "age" : 40,
    "date" : 1594634846647,
    "man" : null,
    "height" : 0
    }
    反序列化
    JackSonTest.Person(name=Tom, age=40, date=Mon Jul 13 18:07:26 CST 2020, man=null, height=0)
    

    ObjectMapper 通过 writeValue 系列方法将 java 对象序列化为 json,并将 json 存储成不同的格式,String(writeValueAsString),Byte Array(writeValueAsString),Writer, File,OutStream 和 DataOutput。

    ObjectMapper 通过 readValue 系列方法从不同的数据源像 String , Byte Array, Reader,File,URL, InputStream 将 json 反序列化为 java 对象。

    统一配置

    在调用 writeValue 或调用 readValue 方法之前,往往需要设置 ObjectMapper 的相关配置信息。这些配置信息应用 java 对象的所有属性上。示例如下:

    //在反序列化时忽略在 json 中存在但 Java 对象不存在的属性
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    //在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //在序列化时自定义时间日期格式
    mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    //在序列化时忽略值为 null 的属性
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    //在序列化时忽略值为默认值的属性
    mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);
    

    更多配置信息可以查看 Jackson 的 DeserializationFeature,SerializationFeature 和 Include。

    重新运行单元测试1,打印输出:

    序列化
    {
      "name" : "Tom",
      "age" : 40,
      "date" : "2020-07-26 18:46:51"
    }
    反序列化
    JackSonTest.Person(name=Tom, age=40, date=Sun Jul 26 18:46:51 CST 2020, height=0)
    

    使用注解

    Jackson 根据它的默认方式序列化和反序列化 java 对象,若根据实际需要,灵活的调整它的默认方式,可以使用 Jackson 的注解。常用的注解及用法如下。

    注解用法
    @JsonProperty用于属性,把属性的名称序列化时转换为另外一个名称。示例:@JsonProperty("birth_date") private Date birthDate
    @JsonIgnore可用于字段、getter/setter、构造函数参数上,作用相同,都会对相应的字段产生影响。使相应字段不参与序列化和反序列化。
    @JsonIgnoreProperties该注解是类注解。该注解在Java类和JSON不完全匹配的时候使用。
    @JsonFormat用于属性或者方法,把属性的格式序列化时转换成指定的格式。示例:@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm") public Date getBirthDate()
    @JsonPropertyOrder用于类, 和 @JsonProperty 的index属性类似,指定属性在序列化时 json 中的顺序 , 示例:@JsonPropertyOrder({ "birth_Date", "name" }) public class Person
    @JsonCreator用于构造方法,和 @JsonProperty 配合使用,适用有参数的构造方法。示例:@JsonCreator public Person(@JsonProperty("name")String name) {…}
    @JsonAnySetter用于属性或者方法,设置未反序列化的属性名和值作为键值存储到 map 中 @JsonAnySetter public void set(String key, Object value) { map.put(key, value); }
    @JsonAnyGetter用于方法 ,获取所有未序列化的属性 public Map<String, Object> any() { return map; }
    @JsonNaming类注解。序列化的时候该注解可将驼峰命名的字段名转换为下划线分隔的小写字母命名方式。反序列化的时候可以将下划线分隔的小写字母转换为驼峰命名的字段名。示例:@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
    @JsonRootName类注解。需开启mapper.enable(SerializationFeature.WRAP_ROOT_VALUE),用于序列化时输出带有根属性名称的 JSON 串,形式如 {"root_name":{"id":1,"name":"zhangsan"}}。但不支持该 JSON 串反序列化。

    使用示例:

    // 用于类,指定属性在序列化时 json 中的顺序
    @JsonPropertyOrder({"date", "user_name"})
    // 批量忽略属性,不进行序列化
    @JsonIgnoreProperties(value = {"other"})
    // 用于序列化与反序列化时的驼峰命名与小写字母命名转换
    @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
    public static class User {
        @JsonIgnore
        private Map<String, Object> other = new HashMap<>();
    
        // 正常case
        @JsonProperty("user_name")
        private String userName;
        // 空对象case
        private Integer age;
        @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
        // 日期转换case
        private Date date;
        // 默认值case
        private int height;
    
        public User() {
        }
    
        // 反序列化执行构造方法
        @JsonCreator
        public User(@JsonProperty("user_name") String userName) {
            System.out.println("@JsonCreator 注解使得反序列化自动执行该构造方法 " + userName);
            // 反序列化需要手动赋值
            this.userName = userName;
        }
    
        @JsonAnySetter
        public void set(String key, Object value) {
            other.put(key, value);
        }
    
        @JsonAnyGetter
        public Map<String, Object> any() {
            return other;
        }
        // 本文默认省略getter、setter方法
    }
    

    单元测试:

    @Test
    public void test3() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // 造数据
        Map<String, Object> map = new HashMap<>();
        map.put("user_name", "Tom");
        map.put("date", "2020-07-26 19:28:44");
        map.put("age", 100);
        map.put("demoKey", "demoValue");
        String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
        System.out.println(jsonString);
        System.out.println("反序列化");
        User user = mapper.readValue(jsonString, User.class);
        System.out.println(user);
        System.out.println("序列化");
        jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
        System.out.println(jsonString);
    }
    

    打印输出:

    {
      "date" : "2020-07-26 19:28:44",
      "demoKey" : "demoValue",
      "user_name" : "Tom",
      "age" : 100
    }
    反序列化
    @JsonCreator 注解使得反序列化自动执行该构造方法Tom
    JackSonTest.User(other={demoKey=demoValue}, userName=Tom, age=100, date=Sun Jul 26 19:28:44 CST 2020, height=0)
    序列化
    {
      "date" : "2020-07-26 19:28:44",
      "user_name" : "Tom",
      "age" : 100,
      "height" : 0,
      "demoKey" : "demoValue"
    }
    

    日期处理

    不同类型的日期类型,JackSon 的处理方式也不同。

    普通日期

    对于日期类型为 java.util.Calendar, java.util.GregorianCalendar, java.sql.Date, java.util.Date, java.sql.Timestamp,若不指定格式,在 json 文件中将序列化为 long 类型的数据。显然这种默认格式,可读性差,转换格式是必要的。

    JackSon 有很多方式转换日期格式。

    • 注解方式,使用 @JsonFormat 注解指定日期格式。

    • ObjectMapper 方式,调用 ObjectMapper 的方法 setDateFormat,将序列化为指定格式的 string 类型的数据。

    Local日期

    对于日期类型为 java.time.LocalDate, java.time.LocalDateTime,还需要添加代码 mapper.registerModule(new JavaTimeModule()),同时添加相应的依赖 jar 包。

    导入依赖:

    <dependency> 
      <groupId>com.fasterxml.jackson.datatype</groupId> 
      <artifactId>jackson-datatype-jsr310</artifactId> 
      <version>2.9.1</version> 
    </dependency>
    

    对于 Jackson 2.5 以下版本,需要添加代码 mapper.registerModule(new JSR310Module ())

    使用示例:

    @Data
    public static class Student {
        // 正常case
        private String name;
        // 日期转换case
        private LocalDateTime date;
    }
    
    @Test
    public void test4() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // 必须添加对LocalDate的支持
        mapper.registerModule(JavaTimeModule());
        // 造数据
        Student student = new Student();
        student.setName("Tom");
        student.setDate(LocalDateTime.now());
        System.out.println("序列化");
        String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);
        System.out.println(jsonString);
        System.out.println("反序列化");
        Student deserializedPerson = mapper.readValue(jsonString, Student.class);
        System.out.println(deserializedPerson);
    }
    
    private Module JavaTimeModule() {
        JavaTimeModule module = new JavaTimeModule();
        String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
        String DATE_FORMAT = "yyyy-MM-dd";
        String TIME_FORMAT = "HH:mm:ss";
        module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
        module.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        module.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern((TIME_FORMAT))));
        module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
        module.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        module.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(TIME_FORMAT)));
        return module;
    }
    

    打印输出:

    序列化
    {
      "name" : "Tom",
      "date" : "2020-07-26 23:10:42"
    }
    反序列化
    JackSonTest.Student(name=Tom, date=2020-07-26T23:10:42)
    

    Joda日期

    对于日期类型为 org.joda.time.DateTime,还需要添加代码 mapper.registerModule(new JodaModule()),同时添加相应的依赖 jar 包

    <dependency> 
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-joda</artifactId> 
      <version>2.9.1</version> 
    </dependency>
    

    对象集合

    Jackson 对泛型反序列化也提供很好的支持。

    List

    对于 List 类型 ,可以调用 constructCollectionType 方法来序列化,也可以构造 TypeReference 来序列化。

    使用示例:

    @Test
    public void test5() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        CollectionType javaType = mapper.getTypeFactory().constructCollectionType(List.class, Person.class);
        // 造数据
        List<Person> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Person person = new Person();
            person.setName("Tom");
            person.setAge(new Random().nextInt(100));
            person.setDate(new Date());
            list.add(person);
        }
        System.out.println("序列化");
        String jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(list);
        System.out.println(jsonInString);
        System.out.println("反序列化:使用 javaType");
        List<Person> personList = mapper.readValue(jsonInString, javaType);
        System.out.println(personList);
        System.out.println("反序列化:使用 TypeReference");
        List<Person> personList2 = mapper.readValue(jsonInString, new TypeReference<List<Person>>() {
        });
        System.out.println(personList2);
    }
    

    打印输出:

    序列化
    [ {
      "name" : "Tom",
      "age" : 33,
      "date" : 1595778639371,
      "height" : 0
    }, {
      "name" : "Tom",
      "age" : 3,
      "date" : 1595778639371,
      "height" : 0
    }, {
      "name" : "Tom",
      "age" : 36,
      "date" : 1595778639371,
      "height" : 0
    } ]
    反序列化:使用 javaType
    [JackSonTest.Person(name=Tom, age=33, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=3, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=36, date=Sun Jul 26 23:50:39 CST 2020, height=0)]
    反序列化:使用 TypeReference
    [JackSonTest.Person(name=Tom, age=33, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=3, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=36, date=Sun Jul 26 23:50:39 CST 2020, height=0)]
    

    Map

    对于 map 类型, 与 List 的实现方式相似。

    使用示例:

    @Test
    public void test6() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        //第二参数是 map 的 key 的类型,第三参数是 map 的 value 的类型
        MapType javaType = mapper.getTypeFactory().constructMapType(HashMap.class, String.class, Person.class);
        // 造数据
        Map<String, Person> map = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            Person person = new Person();
            person.setName("Tom");
            person.setAge(new Random().nextInt(100));
            person.setDate(new Date());
            map.put("key" + i, person);
        }
        System.out.println("序列化");
        String jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
        System.out.println(jsonInString);
        System.out.println("反序列化: 使用 javaType");
        Map<String, Person> personMap = mapper.readValue(jsonInString, javaType);
        System.out.println(personMap);
        System.out.println("反序列化: 使用 TypeReference");
        Map<String, Person> personMap2 = mapper.readValue(jsonInString, new TypeReference<Map<String, Person>>() {
        });
        System.out.println(personMap2);
    }
    

    打印输出:

    序列化
    {
      "key1" : {
        "name" : "Tom",
        "age" : 95,
        "date" : 1595778740606,
        "height" : 0
      },
      "key2" : {
        "name" : "Tom",
        "age" : 27,
        "date" : 1595778740606,
        "height" : 0
      },
      "key0" : {
        "name" : "Tom",
        "age" : 98,
        "date" : 1595778740606,
        "height" : 0
      }
    }
    反序列化: 使用 javaType
    {key1=JackSonTest.Person(name=Tom, age=95, date=Sun Jul 26 23:52:20 CST 2020, height=0), key2=JackSonTest.Person(name=Tom, age=27, date=Sun Jul 26 23:52:20 CST 2020, height=0), key0=JackSonTest.Person(name=Tom, age=98, date=Sun Jul 26 23:52:20 CST 2020, height=0)}
    反序列化: 使用 TypeReference
    {key1=JackSonTest.Person(name=Tom, age=95, date=Sun Jul 26 23:52:20 CST 2020, height=0), key2=JackSonTest.Person(name=Tom, age=27, date=Sun Jul 26 23:52:20 CST 2020, height=0), key0=JackSonTest.Person(name=Tom, age=98, date=Sun Jul 26 23:52:20 CST 2020, height=0)}
    

    Array 和 Collection 的处理与 List,Map 相似,这里不再详述。

    属性可视化

    JackSon 默认不是所有的属性都可以被序列化和反序列化。默认的属性可视化的规则如下:

    • 若该属性修饰符是 public,该属性可序列化和反序列化。

    • 若属性的修饰符不是 public,但是它的 getter 方法和 setter 方法是 public,该属性可序列化和反序列化。因为 getter 方法用于序列化, 而 setter 方法用于反序列化。

    • 若属性只有 public 的 setter 方法,而无 public 的 getter 方 法,该属性只能用于反序列化。

    若想更改默认的属性可视化的规则,需要调用 ObjectMapper 的方法 setVisibility

    下面的示例使修饰符为 protected 的属性 name 也可以序列化和反序列化。

    public static class People {
        public int age;
        protected String name;
    }
    
    @Test
    public void test7() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // PropertyAccessor 支持的类型有 ALL,CREATOR,FIELD,GETTER,IS_GETTER,NONE,SETTER
        // Visibility 支持的类型有 ANY,DEFAULT,NON_PRIVATE,NONE,PROTECTED_AND_PUBLIC,PUBLIC_ONLY
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        // 造数据
        People people = new People();
        people.name = "Tom";
        people.age = 40;
        System.out.println("序列化");
        String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(people);
        System.out.println(jsonString);
        System.out.println("反序列化");
        People deserializedPerson = mapper.readValue(jsonString, People.class);
        System.out.println(deserializedPerson);
    }
    

    打印输出:

    序列化
    {
      "age" : 40,
      "name" : "Tom"
    }
    反序列化
    JackSonTest.People(age=40, name=Tom)
    

    属性过滤

    在将 Java 对象序列化为 json 时 ,有些属性需要过滤掉,不显示在 json 中 ,除了使用 @JsonIgnore 过滤单个属性或用 @JsonIgnoreProperties 过滤多个属性之外, Jackson 还有通过代码控制的方式。

    使用示例:

    @JsonFilter("myFilter")
    public interface MyFilter {
    }
    
    @Test
    public void test8() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //设置 addMixIn
        mapper.addMixIn(Person.class, MyFilter.class);
        //调用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法
        SimpleBeanPropertyFilter newFilter = SimpleBeanPropertyFilter.serializeAllExcept("age");
        //或重写 SimpleBeanPropertyFilter 的 serializeAsField 方法
        SimpleBeanPropertyFilter newFilter2 = new SimpleBeanPropertyFilter() {
            @Override
            public void serializeAsField(Object pojo, JsonGenerator jgen,
                                         SerializerProvider provider, PropertyWriter writer)
                    throws Exception {
                if (!writer.getName().equals("age")) {
                    writer.serializeAsField(pojo, jgen, provider);
                }
            }
        };
        //设置 FilterProvider
        FilterProvider filterProvider = new SimpleFilterProvider().addFilter("myFilter", newFilter);
        // 造数据
        Person person = new Person();
        person.setName("Tom");
        person.setAge(40); // 该属性将被忽略
        person.setDate(new Date());
        // 序列化
        String jsonString = mapper.setFilterProvider(filterProvider).writeValueAsString(person);
        System.out.println(jsonString);
    }
    

    打印输出:

    {"name":"Tom","date":1595780842754}
    

    自定义序列化类

    当 Jackson 默认序列化和反序列化的类不能满足实际需要,可以自定义新的序列化和反序列化的类。

    自定义序列化类:自定义的序列化类需要直接或间接继承 StdSerializer 或 JsonSerializer,同时需要利用 JsonGenerator 生成 json,重写方法 serialize,示例如下:

    public static class CustomSerializer extends StdSerializer<Person> {
        protected CustomSerializer() {
            super(Person.class);
        }
    
        @Override
        public void serialize(Person person, JsonGenerator jgen, SerializerProvider provider) throws IOException {
            jgen.writeStartObject();
            jgen.writeNumberField("age", person.getAge());
            jgen.writeStringField("name", person.getName());
            jgen.writeStringField("msg", "已被自定义序列化");
            jgen.writeEndObject();
        }
    }
    

    JsonGenerator 有多种 write 方法以支持生成复杂的类型的 json,比如 writeArray,writeTree 等 。若想单独创建 JsonGenerator,可以通过 JsonFactory() 的 createGenerator。

    自定义反序列化类:自定义的反序列化类需要直接或间接继承 StdDeserializer 或 StdDeserializer,同时需要利用 JsonParser 读取 json,重写方法 deserialize,示例如下:

    public static class CustomDeserializer extends StdDeserializer<Person> {
        protected CustomDeserializer() {
            super(Person.class);
        }
    
        @Override
        public Person deserialize(JsonParser jp, DeserializationContext ctxt)
                throws IOException, JsonProcessingException {
            JsonNode node = jp.getCodec().readTree(jp);
            Person person = new Person();
            int age = (Integer) ((IntNode) node.get("age")).numberValue();
            String name = node.get("name").asText();
            person.setAge(age);
            person.setName(name);
            return person;
        }
    }
    

    JsonParser 提供很多方法来读取 json 信息, 如 isClosed(), nextToken(), getValueAsString()等。若想单独创建 JsonParser,可以通过 JsonFactory() 的 createParser。

    定义好自定义序列化类和自定义反序列化类,若想在程序中调用它们,还需要注册到 ObjectMapper 的 Module,示例如下:

    @Test
    public void test9() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        // 生成 module
        SimpleModule module = new SimpleModule("myModule");
        module.addSerializer(new CustomSerializer());
        module.addDeserializer(Person.class, new CustomDeserializer());
        // 注册 module
        mapper.registerModule(module);
        // 造数据
        Person person = new Person();
        person.setName("Tom");
        person.setAge(40);
        person.setDate(new Date());
        System.out.println("序列化");
        String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
        System.out.println(jsonString);
        System.out.println("反序列化");
        Person deserializedPerson = mapper.readValue(jsonString, Person.class);
        System.out.println(deserializedPerson);
    }
    

    或者也可通过注解方式加在 java 对象的属性,方法或类上面来调用它们:

    • @JsonSerialize(using = CustomSerializer.class)

    • @JsonDeserialize(using = CustomDeserializer.class)

    树模型处理

    Jackson 也提供了树模型(tree model)来生成和解析 json。若想修改或访问 json 部分属性,树模型是不错的选择。树模型由 JsonNode 节点组成。程序中常常使用 ObjectNode,ObjectNode 继承于 JsonNode,示例如下:

    @Test
    public void test10() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        //构建 ObjectNode
        ObjectNode personNode = mapper.createObjectNode();
        //添加/更改属性
        personNode.put("name", "Tom");
        personNode.put("age", 40);
        ObjectNode addressNode = mapper.createObjectNode();
        addressNode.put("zip", "000000");
        addressNode.put("street", "Road NanJing");
        //设置子节点
        personNode.set("address", addressNode);
        System.out.println("构建 ObjectNode:\n" + personNode.toString());
        //通过 path 查找节点
        JsonNode searchNode = personNode.path("name");
        System.out.println("查找子节点 name:\n" + searchNode.asText());
        //删除属性
        ((ObjectNode) personNode).remove("address");
        System.out.println("删除后的 ObjectNode:\n" + personNode.toString());
        //读取 json
        JsonNode rootNode = mapper.readTree(personNode.toString());
        System.out.println("Json 转 JsonNode:\n" + rootNode);
        //JsonNode 转换成 java 对象
        Person person = mapper.treeToValue(personNode, Person.class);
        System.out.println("JsonNode 转对象:\n" + person);
        //java 对象转换成 JsonNode
        JsonNode node = mapper.valueToTree(person);
        System.out.println("对象转 JsonNode:\n" + node);
    }
    

    打印输出:

    构建 ObjectNode:
    {"name":"Tom","age":40,"address":{"zip":"000000","street":"Road NanJing"}}
    查找子节点 name:
    Tom
    删除后的 ObjectNode:
    {"name":"Tom","age":40}
    Json 转 JsonNode:
    {"name":"Tom","age":40}
    JsonNode 转对象:
    JackSonTest.Person(name=Tom, age=40, date=null, height=0)
    对象转 JsonNode:
    {"name":"Tom","age":40,"date":null,"height":0}
    

    作者:薛勤,互联网从业者,编程爱好者。

    本文首发自公众号:代码艺术(ID: onblog)未经许可, 禁止转载

    展开全文
  • NULL 博文链接:https://bugyun.iteye.com/blog/2279033
  • Jackson框架使用指南.pdf
  • NULL 博文链接:https://fanjf.iteye.com/blog/1455184
  • NULL 博文链接:https://bugyun.iteye.com/blog/2278997
  • Jackson 是当前用的比较广泛的,用来序列化和反序列化 json 的 Java 的开源框架Jackson 社 区相对比较活跃,更新速度也比较快, 从 Github 中的统计来看,Jackson 是最流行的 json 解析器之一 。 Spring MVC 的...

    Jackson 是当前用的比较广泛的,用来序列化和反序列化 json 的 Java 的开源框架。Jackson 社 区相对比较活跃,更新速度也比较快, 从 Github 中的统计来看,Jackson 是最流行的 json 解析器之一 。 Spring MVC 的默认 json 解析器便是 Jackson。 Jackson 优点很多。 Jackson 所依赖的 jar 包较少 ,简单易用。与其他 Java 的 json 的框架 Gson 等相比, Jackson 解析大的 json 文件速度比较快;Jackson 运行时占用内存比较低,性能比较好;Jackson 有灵活的 API,可以很容易进行扩展和定制。

    Jackson 的 1.x 版本的包名是 org.codehaus.jackson ,当升级到 2.x 版本时,包名变为 com.fasterxml.jackson,本文讨论的内容是基于最新的 Jackson 的 2.9.1 版本。

    Jackson 的核心模块由三部分组成。

    • jackson-core,核心包,提供基于”流模式”解析的相关 API,它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。
    • jackson-annotations,注解包,提供标准注解功能;
    • jackson-databind ,数据绑定包, 提供基于”对象绑定” 解析的相关 API ( ObjectMapper ) 和”树模型” 解析的相关 API (JsonNode);基于”对象绑定” 解析的 API 和”树模型”解析的 API 依赖基于”流模式”解析的 API。

    在了解 Jackson 的概要情况之后,下面介绍 Jackson 的基本用法。

    Jackson 的 基本用法

    若想在 Java 代码中使用 Jackson 的核心模块的 jar 包 ,需要在 pom.xml 中添加如下信息。

    清单 1.在 pom.xml 的 Jackson 的配置信息
    <dependency>
    	<groupId>com.fasterxml.jackson.core</groupId>
    	<artifactId>jackson-databind</artifactId>
    	<version>2.9.1</version>
    </dependency>
    

    jackson-databind 依赖 jackson-core 和 jackson-annotations,当添加 jackson-databind 之后, jackson-core 和 jackson-annotations 也随之添加到 Java 项目工程中。在添加相关依赖包之后,就可以使用 Jackson。

    ObjectMapper的使用

    Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper。下面是一个 ObjectMapper 的使用的简单示例。

    清单 2 . ObjectMapper 使用示例
    ObjectMapper mapper = new ObjectMapper();
    Person person = new Person();
    person.setName("Tom");
    person.setAge(40);
    String jsonString = mapper.writerWithDefaultPrettyPrinter()
    .writeValueAsString(person);
    Person deserializedPerson = mapper.readValue(jsonString, Person.class);
    

    ObjectMapper 通过 writeValue 系列方法 将 java 对 象序列化 为 json,并 将 json 存 储成不同的格式,String(writeValueAsString),Byte Array(writeValueAsString),Writer, File,OutStream 和 DataOutput。

    ObjectMapper 通过 readValue 系列方法从不同的数据源像 String , Byte Array, Reader,File,URL, InputStream 将 json 反序列化为 java 对象。

    信息配置

    在调用 writeValue 或调用 readValue 方法之前,往往需要设置 ObjectMapper 的相关配置信息。这些配置信息应用 java 对象的所有属性上。示例如下:

    清单 3 . 配置信息使用示例
    //在反序列化时忽略在 json 中存在但 Java 对象不存在的属性
     mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
        false);
     //在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ
     mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false)
     //在序列化时忽略值为 null 的属性
     mapper.setSerializationInclusion(Include.NON_NULL);
     //忽略值为默认值的属性
     mapper.setDefaultPropertyInclusion(Include.NON_DEFAULT);
    

    更多配置信息可以查看 Jackson 的 DeserializationFeature,SerializationFeature 和 I nclude。

    Jackson 的 注解的使用

    Jackson 根据它的默认方式序列化和反序列化 java 对象,若根据实际需要,灵活的调整它的默认方式,可以使用 Jackson 的注解。常用的注解及用法如下。

    表 1. Jackson 的 常用注解
    注解用法
    @JsonProperty用于属性,把属性的名称序列化时转换为另外一个名称。示例: @JsonProperty(“birth_ d ate”) private Date birthDate;
    @JsonFormat用于属性或者方法,把属性的格式序列化时转换成指定的格式。示例: @JsonFormat(timezone = “GMT+8”, pattern = “yyyy-MM-dd HH:mm”) public Date getBirthDate()
    @JsonPropertyOrder用于类, 指定属性在序列化时 json 中的顺序 , 示例: @JsonPropertyOrder({ “birth_Date”, “name” }) public class Person
    @JsonCreator用于构造方法,和 @JsonProperty 配合使用,适用有参数的构造方法。 示例: @JsonCreator public Person(@JsonProperty(“name”)String name) {…}
    @JsonAnySetter用于属性或者方法,设置未反序列化的属性名和值作为键值存储到 map 中 @JsonAnySetter public void set(String key, Object value) { map.put(key, value); }
    @JsonAnyGetter用于方法 ,获取所有未序列化的属性 public Map<string, object> any() { return map; }

    在了解 Jackson 的基本用法后,下面详细地介绍它的一些高阶应用。

    Jackson 的 高阶应用

    格式处理(含日期格式)

    不同类型的日期类型,Jackson 的处理方式也不同。

    • 对于日期类型为 java.util.Calendar,java.util.GregorianCalendar,java.sql.Date,java.util.Date,java.sql.Timestamp,若不指定格式, 在 json 文件中将序列化 为 long 类型的数据。显然这种默认格式,可读性差,转换格式是必要的。Jackson 有 很多方式转换日期格式。
    • 注解方式,请参照” Jackson 的注解的使用”的@ JsonFormat 的示例。
    • ObjectMapper 方式,调用 ObjectMapper 的方法 setDateFormat,将序列化为指定格式的 string 类型的数据。
    • 对于日期类型为 java.time.LocalDate,还需要添加代码 mapper.registerModule(new JavaTimeModule()),同时添加相应的依赖 jar 包
    清单 4 . JSR31 0 的配置信息
    <dependency>
    	<groupId>com.fasterxml.jackson.datatype</groupId>
    	<artifactId>jackson-datatype-jsr310</artifactId>
    	<version>2.9.1</version>
    </dependency>
    

    对于 Jackson 2.5 以下版本,需要添加代码 objectMapper.registerModule(new JSR310Module ())

    • 对于日期类型为 org.joda.time.DateTime,还需要添加代码 mapper.registerModule(new JodaModule()),同时添加相应的依赖 jar 包
    清单 5. joda 的 配置信息
    <dependency>
    	 <groupId>com.fasterxml.jackson.datatype</groupId>
    	 <artifactId>jackson-datatype-joda</artifactId>
    	 <version>2.9.1</version>
    </dependency>
    

    泛型反序列化

    Jackson 对泛型反序列化也提供很好的支持。

    • 对于 List 类型 ,可以调用 constructCollectionType 方法来序列化,也可以构造 TypeReference 来序列化。
    清单 6 . List 泛 型使用示例
     CollectionType javaType = mapper.getTypeFactory()
     .constructCollectionType(List.class, Person.class);
     List<Person> personList = mapper.readValue(jsonInString, javaType);
     List<Person> personList = mapper.readValue(jsonInString, new
        TypeReference<List<Person>>(){});
    
    • 对于 map 类型, 与 List 的实现方式相似。
    • 清单 7 . Map 泛型使用示例
      //第二参数是 map 的 key 的类型,第三参数是 map 的 value 的类型
       MapType javaType =
          mapper.getTypeFactory().constructMapType(HashMap.class,String.class,
          Person.class);
       Map<String, Person> personMap = mapper.readValue(jsonInString,
          javaType);
       Map<String, Person> personMap = mapper.readValue(jsonInString, new
          TypeReference<Map<String, Person>>() {});
      

      Array 和 Collection 的处理与 List,Map 相似,这里不再详述。

      属性可视化

      是 java 对象的所有的属性都被序列化和反序列化,换言之,不是所有属性都可视化,默认的属性可视化的规则如下:

      • 若该属性修饰符是 public,该属性可序列化和反序列化。
      • 若属性的修饰符不是 public,但是它的 getter 方法和 setter 方法是 public,该属性可序列化和反序列化。因为 getter 方法用于序列化, 而 setter 方法用于反序列化。
      • 若属性只有 public 的 setter 方法,而无 public 的 getter 方 法,该属性只能用于反序列化。

      若想更改默认的属性可视化的规则,需要调用 ObjectMapper 的方法 setVisibility。

      下面的示例使修饰符为 protected 的属性 name 也可以序列化和反序列化。

      清单 8 . 属性可视化示例
      mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
       public class Person {
      public int age;
       protected String name;
      }
       PropertyAccessor 支持的类型有 ALL,CREATOR,FIELD,GETTER,IS_GETTER,NONE,SETTER
       Visibility 支持的类型有 A
          NY,DEFAULT,NON_PRIVATE,NONE,PROTECTED_AND_PUBLIC,PUBLIC_ONLY
      

      属性过滤

      在将 Java 对象序列化为 json 时 ,有些属性需要过滤掉,不显示在 json 中 , Jackson 有多种实现方法。

      • 注解方式, 可以用 @JsonIgnore 过滤单个属性或用 @JsonIgnoreProperties 过滤多个属性,示例如下:
      清单 9 . 属性过滤示例一
      @JsonIgnore
      public int getAge()
      @JsonIgnoreProperties(value = { "age","birth_date" })
      public class Person
      
      • addMixIn 方法加注解方式@JsonIgnoreProperties。

      addMixIn 方法签名如下:

      public ObjectMapper addMixIn(Class<?> target, Class<?> mixinSource);

      addMixIn 方法的作用是用 mixinSource 接口或类的注解会重写 target 或 target 的子类型的注解。 用ixIn 设置

      Person peixIn 的 @JsonIgnoreProperties(“name”)所重写,最终忽略的属性为 name,最终生成的 json 如下:

      {“birthDate”:”2017/09/13″,”age”:40}

      • SimpleBeanPropertyFilter 方式。这种方式比前两种方式更加灵活,也更复杂一些。

      首先需要设置@JsonFilter 类或接口,其次设置 addMixIn,将@JsonFilter 作用于 java 对象上,最后调用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法或重写 S impleBeanPropertyFilter 的 serializeAsField 方法来过滤相关属性。示例如下:

      清单 11 . 属性过滤示例三
      
      //设置 Filter 类或接口
       @JsonFilter("myFilter")
      public interface MyFilter {}
      //设置 addMixIn
      mapper.addMixIn(Person.class, MyFilter.class);
      //调用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法
       SimpleBeanPropertyFilter newFilter =
       SimpleBeanPropertyFilter.serializeAllExcept("age");
      //或重写 SimpleBeanPropertyFilter 的 serializeAsField 方法
       SimpleBeanPropertyFilter newFilter = new SimpleBeanPropertyFilter() {
       @Override
       public void serializeAsField(Object pojo, JsonGenerator jgen,
       SerializerProvider provider, PropertyWriter writer)
       throws Exception {
       if (!writer.getName().equals("age")) {
       writer.serializeAsField(pojo, jgen, provider);
       }
       }
       };
      //设置 FilterProvider
       FilterProvider filterProvider = new SimpleFilterProvider()
       .addFilter("myFilter", newFilter);
       mapper.setFilterProvider(filterProvider).writeValueAsString(person);
      
      显示更多 Show more icon

      自定义序列化和反序列化

      当 Jackson 默认序列化和反序列化的类不能满足实际需要,可以自定义新的序列化和反序列化的类。

      • 自定义序列化类。自定义的序列化类需要直接或间接继承 StdSerializer 或 JsonSerializer,同时需要利用 JsonGenerator 生成 json,重写方法 serialize,示例如下:
      清单 12 . 自定义序列化
      
       public class CustomSerializer extends StdSerializer<Person> {
       @Override
       public void serialize(Person person, JsonGenerator jgen,
       SerializerProvider provider) throws IOException {
       jgen.writeStartObject();
       jgen.writeNumberField("age", person.getAge());
       jgen.writeStringField("name", person.getName());
       jgen.writeEndObject();
       }
       }
      
      显示更多 Show more icon

      JsonGenerator 有多种 write 方法以支持生成复杂的类型的 json,比如 writeArray,writeTree 等 。若想单独创建 JsonGenerator,可以通过 JsonFactory() 的 createGenerator。

      • 自定义反序列化类。自定义的反序列化类需要直接或间接继承 StdDeserializer 或 StdDeserializer,同时需要利用 JsonParser 读取 json,重写方法 deserialize,示例如下:
      清单 13 . 自定义序列化
      
      public class CustomDeserializer extends StdDeserializer<Person> {
       @Override
       public Person deserialize(JsonParser jp, DeserializationContext ctxt)
       throws IOException, JsonProcessingException {
       JsonNode node = jp.getCodec().readTree(jp);
       Person person = new Person();
       int age = (Integer) ((IntNode) node.get("age")).numberValue();
       String name = node.get("name").asText();
       person.setAge(age);
       person.setName(name);
      return person;
      }
       }
      
      显示更多 Show more icon

      JsonParser 提供很多方法来读取 json 信息, 如 isClosed(), nextToken(), getValueAsString()等。若想单独创建 JsonParser,可以通过 JsonFactory() 的 createParser。

      • 定义好自定义序列化类和自定义反序列化类,若想在程序中调用它们,还需要注册到 ObjectMapper 的 Module,示例如下:
      清单 14 . 注 册 M odule 示例
      
       SimpleModule module = new SimpleModule("myModule");
       module.addSerializer(new CustomSerializer(Person.class));
       module.addDeserializer(Person.class, new CustomDeserializer());
       mapper.registerModule(module);
       也可通过注解方式加在 java 对象的属性,方法或类上面来调用它们,
       @JsonSerialize(using = CustomSerializer.class)
       @JsonDeserialize(using = CustomDeserializer.class)
       public class Person
      
      显示更多 Show more icon

      树模型处理

      Jackson 也提供了树模型(tree model)来生成和解析 json。若想修改或访问 json 部分属性,树模型是不错的选择。树模型由 JsonNode 节点组成。程序中常常使用 ObjectNode,ObjectNode 继承于 JsonNode,示例如下:

      清单 15 . ObjectNode 生成和解析 json 示例
      
       ObjectMapper mapper = new ObjectMapper();
       //构建 ObjectNode
       ObjectNode personNode = mapper.createObjectNode();
       //添加/更改属性
       personNode.put("name","Tom");
       personNode.put("age",40);
       ObjectNode addressNode = mapper.createObjectNode();
       addressNode.put("zip","000000");
       addressNode.put("street","Road NanJing");
       //设置子节点
       personNode.set("address",addressNode);
       //通过 path 查找节点
       JsonNode searchNode = personNode.path("street ");
       //删除属性
       ((ObjectNode) personNode).remove("address");
       //读取 json
       JsonNode rootNode = mapper.readTree(personNode.toString());
       //JsonNode 转换成 java 对象
       Person person = mapper.treeToValue(personNode, Person.class);
       //java 对象转换成 JsonNode
       JsonNode node = mapper.valueToTree(person);
      
      显示更多 Show more icon

      结束语

      本文首先通过与其他 Java 的 json 的框架比较,介绍了 Jackson 的优点,并且描述了 Jackson 的 核心模块的组成,以及每个部分的作用。然后, 本文通过示例,讲解 Jackson 的基本用法,介绍了 ObjectMapper 的 write 和 read 方法,ObjectMapper 的配置信息设定,以及 jackson-annotations 包下注释的运用。最后,本文详细的介绍了 Jackson 的高阶用法,这也是本文的重点。这些高阶用法包括不同类型的日期格式处理(普通日期的类型,jdk 8 的日期类型,joda 的日期类型),List 和 Map 等泛型的反序列化,属性的可视化管理,Jackson 的 三种属性过滤方式,自定义序列化和反序列化的实现以及树模型的使用。通过本文的系统地讲解,相信读者对 Jackson 会有更深刻而全面的掌握。

      参考资源

      Jenkov.com 的 Jackson – ObjectMapper 部分 ,介绍 Jackson 的 ObjectMapper 的各种 write 和 read 方法 。

      原文地址:Jackson 框架的高阶应用

      这里补充一个LocalDateTime 序列化和解序列化的方法:

      // 如果json中有新增的字段并且是实体类类中不存在的,不报错
              mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
      
              // 下面配置解决LocalDateTime序列化的问题
              mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
              JavaTimeModule javaTimeModule = new JavaTimeModule();
      
              //日期序列化
              //javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
              //javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
              //javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
      
              //日期反序列化
              //javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
              //javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
              //javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
      
              mapper.registerModule(javaTimeModule);
      

      参考博客:记录一下ObjectMapper解析LoaclDateTime时间格式的问题

    展开全文
  • jackson-annotations-2.0.0.jar jackson-core-2.0.0.jar jackson-databind-2.0.0.jar json-lib-2.4-jdk15.jar
  • Jackson框架介绍

    千次阅读 2017-02-04 17:22:01
    Jackson 框架,轻易转换JSON Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。 前面有介绍过json-lib这个框架,在线博文:http://www.cnblogs.com/
    原文地址:http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html
    

    Jackson 框架,轻易转换JSON

    Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。

    前面有介绍过json-lib这个框架,在线博文:JSON-lib框架介绍

    相比json-lib框架,Jackson所依赖的jar包较少,简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃,更新速度也比较快。

    一、准备工作

    1、 下载依赖库jar包

    Jackson的jar all下载地址:http://jackson.codehaus.org/1.7.6/jackson-all-1.7.6.jar

    然后在工程中导入这个jar包即可开始工作

    官方示例:http://wiki.fasterxml.com/JacksonInFiveMinutes

    因为下面的程序是用junit测试用例运行的,所以还得添加junit的jar包。版本是junit-4.2.8

    如果你需要转换xml,那么还需要stax2-api.jar

    2、 测试类基本代码如下

    package com.hoo.test;
     
    import java.io.IOException;
    import java.io.StringWriter;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import org.codehaus.jackson.JsonEncoding;
    import org.codehaus.jackson.JsonGenerationException;
    import org.codehaus.jackson.JsonGenerator;
    import org.codehaus.jackson.JsonParseException;
    import org.codehaus.jackson.map.JsonMappingException;
    import org.codehaus.jackson.map.ObjectMapper;
    import org.codehaus.jackson.node.JsonNodeFactory;
    import org.codehaus.jackson.xml.XmlMapper;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    import com.hoo.entity.AccountBean;
     
    /**
     * <b>function:</b>Jackson 将java对象转换成JSON字符串,也可以将JSON字符串转换成java对象
     * jar-lib-version: jackson-all-1.6.2
     * jettison-1.0.1
     * @author hoojo
     * @createDate 2010-11-23 下午04:54:53
     * @file JacksonTest.java
     * @package com.hoo.test
     * @project Spring3
     * @blog http://blog.csdn.net/IBM_hoojo
     * @email hoojo_@126.com
     * @version 1.0
     */
    @SuppressWarnings("unchecked")
    public class JacksonTest {
        private JsonGenerator jsonGenerator = null;
        private ObjectMapper objectMapper = null;
        private AccountBean bean = null;
        
        @Before
        public void init() {
            bean = new AccountBean();
            bean.setAddress("china-Guangzhou");
            bean.setEmail("hoojo_@126.com");
            bean.setId(1);
            bean.setName("hoojo");
            
            objectMapper = new ObjectMapper();
            try {
                jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        @After
        public void destory() {
            try {
                if (jsonGenerator != null) {
                    jsonGenerator.flush();
                }
                if (!jsonGenerator.isClosed()) {
                    jsonGenerator.close();
                }
                jsonGenerator = null;
                objectMapper = null;
                bean = null;
                System.gc();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    3、 所需要的JavaEntity

    package com.hoo.entity;
     
    public class AccountBean {
        private int id;
        private String name;
        private String email;
        private String address;
        private Birthday birthday;
        
        //getter、setter
        
        @Override
        public String toString() {
            return this.name + "#" + this.id + "#" + this.address + "#" + this.birthday + "#" + this.email;
        }
    }

    Birthday

    package com.hoo.entity;
     
    public class Birthday {
        private String birthday;
        
        public Birthday(String birthday) {
            super();
            this.birthday = birthday;
        }
     
        //getter、setter
     
        public Birthday() {}
        
        @Override
        public String toString() {
            return this.birthday;
        }
    }

    二、Java对象转换成JSON

    1、 JavaBean(Entity/Model)转换成JSON

    /**
     * <b>function:</b>将java对象转换成json字符串
     * @author hoojo
     * @createDate 2010-11-23 下午06:01:10
     */
    @Test
    public void writeEntityJSON() {
        
        try {
            System.out.println("jsonGenerator");
            //writeObject可以转换java对象,eg:JavaBean/Map/List/Array等
            jsonGenerator.writeObject(bean);    
            System.out.println();
            
            System.out.println("ObjectMapper");
            //writeValue具有和writeObject相同的功能
            objectMapper.writeValue(System.out, bean);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    运行后结果如下:

    jsonGenerator
    {"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}
    ObjectMapper
    {"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}

    上面分别利用JsonGenerator的writeObject方法和ObjectMapper的writeValue方法完成对Java对象的转换,二者传递的参数及构造的方式不同;JsonGenerator的创建依赖于ObjectMapper对象。也就是说如果你要使用JsonGenerator来转换JSON,那么你必须创建一个ObjectMapper。但是你用ObjectMapper来转换JSON,则不需要JSONGenerator。

    objectMapper的writeValue方法可以将一个Java对象转换成JSON。这个方法的参数一,需要提供一个输出流,转换后可以通过这个流来输出转换后的内容。或是提供一个File,将转换后的内容写入到File中。当然,这个参数也可以接收一个JSONGenerator,然后通过JSONGenerator来输出转换后的信息。第二个参数是将要被转换的Java对象。如果用三个参数的方法,那么是一个Config。这个config可以提供一些转换时的规则,过指定的Java对象的某些属性进行过滤或转换等。

    2、 将Map集合转换成Json字符串

    /**
     * <b>function:</b>将map转换成json字符串
     * @author hoojo
     * @createDate 2010-11-23 下午06:05:26
     */
    @Test
    public void writeMapJSON() {
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("name", bean.getName());
            map.put("account", bean);
            bean = new AccountBean();
            bean.setAddress("china-Beijin");
            bean.setEmail("hoojo@qq.com");
            map.put("account2", bean);
            
            System.out.println("jsonGenerator");
            jsonGenerator.writeObject(map);
            System.out.println("");
            
            System.out.println("objectMapper");
            objectMapper.writeValue(System.out, map);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    转换后结果如下:

    jsonGenerator
    {"account2":{"address":"china-Beijin","name":null,"id":0,"birthday":null,"email":"hoojo@qq.com"},"name":"hoojo",
    "account":{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}}
    objectMapper
    {"account2":{"address":"china-Beijin","name":null,"id":0,"birthday":null,"email":"hoojo@qq.com"},"name":"hoojo",
    "account":{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}}

    3、 将List集合转换成json

    /**
     * <b>function:</b>将list集合转换成json字符串
     * @author hoojo
     * @createDate 2010-11-23 下午06:05:59
     */
    @Test
    public void writeListJSON() {
        try {
            List<AccountBean> list = new ArrayList<AccountBean>();
            list.add(bean);
            
            bean = new AccountBean();
            bean.setId(2);
            bean.setAddress("address2");
            bean.setEmail("email2");
            bean.setName("haha2");
            list.add(bean);
            
            System.out.println("jsonGenerator");
            //list转换成JSON字符串
            jsonGenerator.writeObject(list);
            System.out.println();
            System.out.println("ObjectMapper");
            //用objectMapper直接返回list转换成的JSON字符串
            System.out.println("1###" + objectMapper.writeValueAsString(list));
            System.out.print("2###");
            //objectMapper list转换成JSON字符串
            objectMapper.writeValue(System.out, list);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    结果如下:

    jsonGenerator
    [{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
    {"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]
    ObjectMapper
    1###[{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
    {"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]
    2###[{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
    {"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]

    外面就是多了个[]中括号;同样Array也可以转换,转换的JSON和上面的结果是一样的,这里就不再转换了。~.~

    4、下面来看看jackson提供的一些类型,用这些类型完成json转换;如果你使用这些类型转换JSON的话,那么你即使没有JavaBean(Entity)也可以完成复杂的Java类型的JSON转换。下面用到这些类型构建一个复杂的Java对象,并完成JSON转换。

    @Test
    public void writeOthersJSON() {
        try {
            String[] arr = { "a", "b", "c" };
            System.out.println("jsonGenerator");
            String str = "hello world jackson!";
            //byte
            jsonGenerator.writeBinary(str.getBytes());
            //boolean
            jsonGenerator.writeBoolean(true);
            //null
            jsonGenerator.writeNull();
            //float
            jsonGenerator.writeNumber(2.2f);
            //char
            jsonGenerator.writeRaw("c");
            //String
            jsonGenerator.writeRaw(str, 5, 10);
            //String
            jsonGenerator.writeRawValue(str, 5, 5);
            //String
            jsonGenerator.writeString(str);
            jsonGenerator.writeTree(JsonNodeFactory.instance.POJONode(str));
            System.out.println();
            
            //Object
            jsonGenerator.writeStartObject();//{
            jsonGenerator.writeObjectFieldStart("user");//user:{
            jsonGenerator.writeStringField("name", "jackson");//name:jackson
            jsonGenerator.writeBooleanField("sex", true);//sex:true
            jsonGenerator.writeNumberField("age", 22);//age:22
            jsonGenerator.writeEndObject();//}
            
            jsonGenerator.writeArrayFieldStart("infos");//infos:[
            jsonGenerator.writeNumber(22);//22
            jsonGenerator.writeString("this is array");//this is array
            jsonGenerator.writeEndArray();//]
            
            jsonGenerator.writeEndObject();//}
            
            
            AccountBean bean = new AccountBean();
            bean.setAddress("address");
            bean.setEmail("email");
            bean.setId(1);
            bean.setName("haha");
            //complex Object
            jsonGenerator.writeStartObject();//{
            jsonGenerator.writeObjectField("user", bean);//user:{bean}
            jsonGenerator.writeObjectField("infos", arr);//infos:[array]
            jsonGenerator.writeEndObject();//}
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    运行后,结果如下:

    jsonGenerator
    "aGVsbG8gd29ybGQgamFja3NvbiE=" true null 2.2c world jac  worl "hello world jackson!" "hello world jackson!"
     {"user":{"name":"jackson","sex":true,"age":22},"infos":[22,"this is array"]} 
    {"user":{"address":"address","name":"haha","id":1,"birthday":null,"email":"email"},"infos":["a","b","c"]}

    怎么样?构造的json字符串和输出的结果是一致的吧。关键看懂用JSONGenerator提供的方法,完成一个Object的构建。

    三、JSON转换成Java对象

    1、 将json字符串转换成JavaBean对象

    @Test
    public void readJson2Entity() {
        String json = "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}";
        try {
            AccountBean acc = objectMapper.readValue(json, AccountBean.class);
            System.out.println(acc.getName());
            System.out.println(acc);
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    很简单,用到了ObjectMapper这个对象的readValue这个方法,这个方法需要提供2个参数。第一个参数就是解析的JSON字符串,第二个参数是即将将这个JSON解析吃什么Java对象,Java对象的类型。当然,还有其他相同签名方法,如果你有兴趣可以一一尝试使用方法,当然使用的方法和当前使用的方法大同小异。运行后,结果如下:

    haha
    haha#1#address#null#email

    2、 将json字符串转换成List<Map>集合

    /**
     * <b>function:</b>json字符串转换成list<map>
     * @author hoojo
     * @createDate 2010-11-23 下午06:12:01
     */
    @Test
    public void readJson2List() {
        String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
                    "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
        try {
            List<LinkedHashMap<String, Object>> list = objectMapper.readValue(json, List.class);
            System.out.println(list.size());
            for (int i = 0; i < list.size(); i++) {
                Map<String, Object> map = list.get(i);
                Set<String> set = map.keySet();
                for (Iterator<String> it = set.iterator();it.hasNext();) {
                    String key = it.next();
                    System.out.println(key + ":" + map.get(key));
                }
            }
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    尝试过将上面的JSON转换成List,然后List中存放AccountBean,但结果失败了。但是支持Map集合。因为你转成List.class,但是不知道List存放何种类型。只好默然Map类型。因为所有的对象都可以转换成Map结合,运行后结果如下:

    2
    address:address2
    name:haha2
    id:2
    email:email2
    address:address
    name:haha
    id:1
    email:email

    3、 Json字符串转换成Array数组,由于上面的泛型转换不能识别到集合中的对象类型。所有这里用对象数组,可以解决这个问题。只不过它不再是集合,而是一个数组。当然这个不重要,你可以用Arrays.asList将其转换成List即可。

    /**
     * <b>function:</b>json字符串转换成Array
     * @author hoojo
     * @createDate 2010-11-23 下午06:14:01
     */
    @Test
    public void readJson2Array() {
        String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
                "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
        try {
            AccountBean[] arr = objectMapper.readValue(json, AccountBean[].class);
            System.out.println(arr.length);
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
            
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    运行后的结果:

    2
    haha2#2#address2#null#email2
    haha#1#address#null#email

    4、 Json字符串转换成Map集合

    /**
     * <b>function:</b>json字符串转换Map集合
     * @author hoojo
     * @createDate Nov 27, 2010 3:00:06 PM
     */
    @Test
    public void readJson2Map() {
        String json = "{\"success\":true,\"A\":{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
                    "\"B\":{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}}";
        try {
            Map<String, Map<String, Object>> maps = objectMapper.readValue(json, Map.class);
            System.out.println(maps.size());
            Set<String> key = maps.keySet();
            Iterator<String> iter = key.iterator();
            while (iter.hasNext()) {
                String field = iter.next();
                System.out.println(field + ":" + maps.get(field));
            }
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    运行后结果如下:

    3
    success:true
    A:{address=address2, name=haha2, id=2, email=email2}
    B:{address=address, name=haha, id=1, email=email}

    四、Jackson对XML的支持

    Jackson也可以完成java对象到xml的转换,转换后的结果要比json-lib更直观,不过它依赖于stax2-api.jar这个jar包。

    /**
     * <b>function:</b>java对象转换成xml文档
     * 需要额外的jar包 stax2-api.jar
     * @author hoojo
     * @createDate 2010-11-23 下午06:11:21
     */
    @Test
    public void writeObject2Xml() {
        //stax2-api-3.0.2.jar
        System.out.println("XmlMapper");
        XmlMapper xml = new XmlMapper();
        
        try {
            //javaBean转换成xml
            //xml.writeValue(System.out, bean);
            StringWriter sw = new StringWriter();
            xml.writeValue(sw, bean);
            System.out.println(sw.toString());
            //List转换成xml
            List<AccountBean> list = new ArrayList<AccountBean>();
            list.add(bean);
            list.add(bean);
            System.out.println(xml.writeValueAsString(list));
            
            //Map转换xml文档
            Map<String, AccountBean> map = new HashMap<String, AccountBean>();
            map.put("A", bean);
            map.put("B", bean);
            System.out.println(xml.writeValueAsString(map));
        } catch (JsonGenerationException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    运行上面的方法,结果如下:

    XmlMapper
    <unknown><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></unknown>
    <unknown><unknown><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></unknown>
    <email><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></email></unknown>
    <unknown><A><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></A>
    <B><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></B></unknown>

    看结果,根节点都是unknown 这个问题还没有解决,由于根节点没有转换出来,所有导致解析xml到Java对象,也无法完成。

    展开全文
  • jackson框架解析json

    2014-01-23 17:05:46
    jackson框架解析json,主要讲解了怎样解析Bean,List,Map,Bean>,List,Bean>>类型的json
  • Jackson框架使用教程

    2021-03-18 16:17:30
    参考:写的非常好的一篇文章 记录Jackson的用法
  • NULL 博文链接:https://xuxiheng.iteye.com/blog/2233774
  • NULL 博文链接:https://zhuchengzzcc.iteye.com/blog/1540485
  • Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将...而更早的时候,Java反序列化漏洞问题曾经一度让大家心惊肉跳,这次是Jackson框架 2.7.10 及2.8.9以下版本出现任意代码执行漏洞,攻击者利用该...
  • jackson-databind-2.0.5.jar
  • #关于球衣杰克逊的简单示例项目 ##要检查本示例中的api调用,请使用以下curl脚本 curl -X GET curl -X POST curl -X GET http://localhost:8090/simple-servlet/guru-api/v1/json/track/get ...
  • Jackson 框架 用例详解

    千次阅读 2013-07-08 16:11:57
    广州宏天软件公司论坛 首页 » 开发技术 » 其他 » Jackson ...Jackson 框架 用例详解  目录 一、 基本介绍.............................2 二、 准备工作............... .......
  • org.codehaus.jackson.map.JsonMappingException: Can not construct instance of java.util.Date from String value '2012-12-10 12:23:54': not a valid representation (error: Can not parse date "2012-12-10 ...
  • jackson所需所有jar包

    2018-11-05 17:14:52
    springmvc+json 前后台数据交互所需的jackson包及js文件
  • 但是@ResponseBody注解可以结合Jackson框架一起使用,并且spring默认支持Jackson框架,使用Jackson框架的同时可以一起解决中文乱码问题。 当使用了Jackson框架和@ResponseBody注解之后,Jackson框架自动将对象解析...
  • 本文记录将Spring Boot 默认的Jackson框架转换为Fastjson的实现方式及注意事项 使用场景 在用Feign Client 接口调用,由于Jackson对null等特殊值处理存在异常,故改用Fastjson解析数据 操作步骤 1.增加文件Feign...
  • springmvc 使用Jackson框架的配置

    千次阅读 2019-01-14 16:33:00
    --start:使用Jackson 1.x的配置,需要导入的jar包:jackson-core-lpgl-xxx.jar、jackson-mapper-lgpl-xxx.jar --> <bean class ="org.springframework.web.servlet.mvc.annotation....
  • JackSON框架转换JSON

    2014-03-05 15:02:50
    Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。 前面有介绍过json-lib这个框架...相比json-lib框架Jackson所依赖的jar包较少,简单易用并且性能也要相对高些。而且J
  • Jackson 框架,轻易转换JSONJackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。前面有介绍过json-lib这个框架,在线博文:JSON-lib框架介绍相比json-lib框架Jackson所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,993
精华内容 13,597
关键字:

jackson框架