精华内容
下载资源
问答
  • 2019-02-03 17:58:23

    Parse JSON to Java using Streaming Jackson Parser

    Parse JSON to Java – Streaming Parser and Generator

    Jackson 提供了一个将JSON解析为Java的底层API。该API为每个JSON对象提供token。举栗来说,JSON的开头符号‘{’将是解释器提供的第一个对象;键值对是另一种单一的对象。客户端代码可以使用token并且获得JSON属性或者构建一个Java对象,如果需要的话。这个dicengAPI十分强大,但是需要更多的代码。在大多数情况下,应该研究Jackson的树遍历和数据绑定能力。我们提供两个栗子。第一个栗子展示了JSON解析,第二个栗子展示了JSON生成;

    解析JSON的示例

    public static void main(String[] args) throws MalformedURLException, IOException {
            // Get a list of albums from free music archive. limit the results to 5
            String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";//译者注:同样的url无法访问
            // get an instance of the json parser from the json factory
            JsonFactory factory = new JsonFactory();
            JsonParser parser = factory.createParser(new URL(url));
     
            // continue parsing the token till the end of input is reached
            while (!parser.isClosed()) {
                // get the token
                JsonToken token = parser.nextToken();
                // if its the last token then we are done
                if (token == null)
                    break;
                // we want to look for a field that says dataset
     
                if (JsonToken.FIELD_NAME.equals(token) && "dataset".equals(parser.getCurrentName())) {
                    // we are entering the datasets now. The first token should be
                    // start of array
                    token = parser.nextToken();
                    if (!JsonToken.START_ARRAY.equals(token)) {
                        // bail out
                        break;
                    }
                    // each element of the array is an album so the next token
                    // should be {
                    token = parser.nextToken();
                    if (!JsonToken.START_OBJECT.equals(token)) {
                        break;
                    }
                    // we are now looking for a field that says "album_title". We
                    // continue looking till we find all such fields. This is
                    // probably not a best way to parse this json, but this will
                    // suffice for this example.
                    while (true) {
                        token = parser.nextToken();
                        if (token == null)
                            break;
                        if (JsonToken.FIELD_NAME.equals(token) && "album_title".equals(parser.getCurrentName())) {
                            token = parser.nextToken();
                            System.out.println(parser.getText());
                        }
                    }
                }
            }
        }
    

    生成JSON的示例

    public static void main(String[] args) throws IOException {
            JsonFactory factory = new JsonFactory();
            JsonGenerator generator = factory.createGenerator(new FileWriter(new File("albums.json")));
     
            // start writing with {
            generator.writeStartObject();
            generator.writeFieldName("title");
            generator.writeString("Free Music Archive - Albums");
            generator.writeFieldName("dataset");
            // start an array
            generator.writeStartArray();
            generator.writeStartObject();
            generator.writeStringField("album_title", "A.B.A.Y.A.M");
            generator.writeEndObject();
            generator.writeEndArray();
            generator.writeEndObject();
     
            generator.close();
        }
    

    项目源码免费获取 个人博客,百度网盘地址+提取码,文件无密~

    更多相关内容
  • Java装Json: 使用jackson解析器的核心对象ObjectMapper,调用writeValu方法 package com.itcase.Jackson; import com.fasterxml.jackson.core.JsonProcessingException; import ...

    一、概念

    1. JavaScript Object Notation JavaScript对象表示法
    • json现在多用于存储和交换文本信息的语法
    • 进行数据的传输
    • JSON 比 XML 更小、更快,更易解析。
    1. 语法:
    2. 基本规则
    • 数据在名称/值对中:json数据是由键值对构成的
      • 键用引号(单双都行)引起来,也可以不使用引号
      • 值得取值类型:
        1. 数字(整数或浮点数)
        2. 字符串(在双引号中)
        3. 逻辑值(true 或 false)
        4. 数组(在方括号中) {“persons”:[{},{}]}
        5. 对象(在花括号中) {“address”:{“province”:“陕西”…}}
        6. null
    • 数据由逗号分隔:多个键值对由逗号分隔
    • 花括号保存对象:使用{}定义json 格式
    • 方括号保存数组:[]
    1. 获取数据:
    • json对象.键名
    • json对象[“键名”]
    • 数组对象[索引]
    • 遍历

    一、 JSON格式和数据的获取

    1. 定义基本格式
    • 获取name的值 有两种:(1) json对象.键 (2) json对象[“键”]
       var person = {"name": "张三", age: 23, 'gender': true};
    
       //获取name的值 有两种 1.json对象.键 2.json对象["键"]
       //var name = person.name;
       var name = person["name"];
    
    1. 嵌套格式 JSON—数组—JSON
        var persons = {
                "persons": [
                    {"name": "张三", "age": 23, "gender": true},
                    {"name": "李四", "age": 24, "gender": true},
                    {"name": "王五", "age": 25, "gender": false}
                    ]
            };
            //获取王五值
            var name1 = persons.persons[2].name;
    
    1. 数组----JSON
     var ps = [{"name": "张三", "age": 23, "gender": true},
                {"name": "李四", "age": 24, "gender": true},
                {"name": "王五", "age": 25, "gender": false}];
            //获取李四值,弹出
            alert(ps[1].name);
    

    二、 JSON的遍历获取键值

    1.使用for in循环遍历json,获取值不可以使用person.name 这种方法,因为它会自动个key加上引号。

      //1.定义基本格式
            var person = {"name": "张三", age: 23, 'gender': true};//获取name的值
            //遍历使用for  in 循环
            for (var key in person){
                // 在for in循环中获取值不可以使用person.name 这种,因为它会自动个key加上引号
                var value = person[key];
                alert(key+":"+value);
            }
    

    2.使用双重for循环 正常for循环和for in 循环遍历嵌套的json

          //2.嵌套格式   []———> {}
          var ps = [{"name": "张三", "age": 23, "gender": true},
              {"name": "李四", "age": 24, "gender": true},
              {"name": "王五", "age": 25, "gender": false}];
          for (var i = 0; i < ps.length; i++) {
              //每一个p就是一个json
              var p = ps[i];
              for (var key in p){
                  //然后遍历每一个json
                  var value = p[key];
                  alert(key+":"+value);
              }
          }
    

    二、Java对象和Json对象的相互转换

    String 类型 Json格式的 str如何通过key-value得到数据。

    		 String str = {"wendu":"100","shidu":"200"};
    	     JSONObject object = new JSONObject(str);
    	     int wendu = object.getInt("wendu");
    	     String shidu = object.getString("shidu");
    

    Java装Json:

    1. 使用jackson解析器的核心对象ObjectMapper,调用writeValu方法
    package com.itcase.Jackson;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.itcase.domain.Person;
    import org.junit.Test;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Writer;
    
    public class Jackson_test1 {
        @Test
        public void test1() throws IOException {
            //java对象转为json对象
            Person p = new Person();
            p.setName("张三");
            p.setAge(22);
            p.setGender("男");
            //创建jackson的核心对象ObjectMapper
            ObjectMapper mapper = new ObjectMapper();
            //1.mapper.writeValueAsString(Object) 将object转换为json对象
            String json = mapper.writeValueAsString(p);
            System.out.println(json);
            /*
            2.mapper.writeValue(参数1,Object)
              参数1:
              File:将obj对象转换为JSON字符串,并保存到指定的文件中
              Writer:将obj对象转换为JSON字符串,并保存到指定的字符输出流
              OutputStream:将obj对象转换为JSON字符串,并保存到指定的字节输出流
             */
            mapper.writeValue(new File("E:\\a.txt"),p);
            mapper.writeValue(new FileWriter("E:\\b.txt"),p);
        }
    }
    
    
    1. Json的注解

    在Person类中加入日期属性private Date birthday;

        public void test2() throws JsonProcessingException {
            //java对象转为json对象
            Person p = new Person();
            p.setName("张三");
            p.setAge(22);
            p.setGender("男");
            p.setBirthday(new Date());
            ObjectMapper mapper = new ObjectMapper();
            //1.mapper.writeValueAsString(Object) 将object转换为json对象
            String json = mapper.writeValueAsString(p);
            System.out.println(json);
        }
    

    结果:

    {“name”:“张三”,“age”:22,“gender”:“男”,“birthday”:1605156999652}

    在属性上加一个注解@JsonIgnore:

        @JsonIgnore
        private Date birthday;
    

    结果如下:可以忽略这个日期属性

    {“name”:“张三”,“age”:22,“gender”:“男”}

    另一个注解:@JsonFormat(pattern = “”)

    @JsonFormat(pattern = "yyyy年--MM月--dd日")
        private Date birthday;
    

    结果如下:可以定义日期格式

    {“name”:“三”,“age”:22,“gender”:“男”,“birthday”:“2020年–11月–12日”}

    1. List和Map的转换
      List.add(Person) :List装Person对象转成Json后成为数组:

    [{“name”:“张三”,“age”:“22”},{" “:” “,” “:” “},{” “:” “,” “:” "}]这种格式

    List.put(key,value):和装上面Person对象的输出格式一样

    Json转Java:
    mapper.readValue(json对象, java.class);
    /是转义字符

        @Test
        public void test3() throws IOException {
            String json = "{\"name\":\"张三\",\"age\":22,\"gender\":\"男\"}";
            ObjectMapper mapper = new ObjectMapper();
            //将json转换为java对象
            Person person = mapper.readValue(json, Person.class);
            System.out.println(person);
        }
    

    结果:

    person{name=‘张三’, age=22, gender=‘男’}

    三、案例

    需求:失去鼠标焦点时候通过ajax和json进行客户端和服务器的通信,判断用户名是否存在。类似百度搜索,输入后下拉框数据的变化。

    注意:服务器响应的数据,在客户端使用时,要想当做json数据格式使用。有两种解决方案:

    1. $.get(type):将最后一个参数type指定为"json"
    2. 在服务器端设置MIME类型
      response.setContentType(“application/json;charset=utf-8”);
      页面:
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
        <script src="js/jquery-3.3.1.min.js"></script>
        <script>
            //在页面加载完
            $(function () {
                //绑定一个blur 失去焦点的function
                $("#username").blur(function () {
                    //获取到用户输入的value
                    var username = $(this).val();
                    //发送一个ajax请求 url ,键值,返回数据,type类型接收
                    $.get("findUserServlet",{username:username},function (date) {
                        //期望服务器响应回的数据格式:{"userExsit":true,"msg":"此用户名太受欢迎,请更换一个"}
                        //                            {"userExsit":false,"msg":"用户名可用"}
                        //设置一个span用于显示接收到的msg
                        var s_username = $("#s_username");
                        if (date.userExsit){
                            //用户存在 显示msg信息
                            s_username.css("color","pink");
                            s_username.html(date.msg);
    
                        }else{
                            //用户不存在
                            s_username.css("color","green");
                            s_username.html(date.msg);
                        }
    
                    },"json");
                });
            });
        </script>
    </head>
    <body>
    <form>
        <input type="text" name="username" id="username" placeholder="请输入用户名">
        <span id="s_username"></span>
        <br>
        <input type="password" name="password" placeholder="请输入密码"><br>
        <input type="submit" value="登录">
    
    </form>
    
    </body>
    </html>
    

    服务器端:

    package com.itcase;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    @WebServlet("/findUserServlet")
    public class FindUserServlet extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            response.setContentType("text/html; charset = utf-8");
    //        response.setContentType("application/json;charset=utf-8");可以不用设置页面的$.get()的最后一个参数type
            //1.用于接收regist.html传来的ajax请求 传来的username参数
            String username = request.getParameter("username");
            //2.设置一个map 存放数据格式:{"userExsit":true,"msg":"此用户名太受欢迎,请更换一个"}{"userExsit":false,"msg":"用户名可用"}
            Map<String,Object> map = new HashMap<String,Object>();
            //3.此次判断应该由service层调用dao层数据库,现在简化判断
            if ("tom".equals(username)){
                map.put("userExsit",true);
                map.put("msg","此用户名太受欢迎,请更换一个");
            }else{
                map.put("userExsit",false);
                map.put("msg","用户名可用");
            }
            //4.ObjectMapper核心对象
            ObjectMapper mapper = new ObjectMapper();
            //5.将map用输出流直接输出到页面响应
            mapper.writeValue(response.getWriter(),map);
        }
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doPost(request, response);
        }
    }
    
    

    结果:
    在这里插入图片描述

    展开全文
  • Java 之所以牛逼,很大的功劳在于它的生态非常完备,JDK 没有 JSON 库,第三方类库有啊,还挺不错,比如说本篇的猪脚——Jackson,GitHub 上标星 6.1k,Spring Boot 的默认 JSON 解析器。 怎么证明这一点呢? 当...

    在当今的编程世界里,JSON 已经成为将信息从客户端传输到服务器端的首选协议,可以好不夸张的说,XML 就是那个被拍死在沙滩上的前浪。

    很不幸的是,JDK 没有 JSON 库,不知道为什么不搞一下。Log4j 的时候,为了竞争,还推出了 java.util.logging,虽然最后也没多少人用。

    Java 之所以牛逼,很大的功劳在于它的生态非常完备,JDK 没有 JSON 库,第三方类库有啊,还挺不错,比如说本篇的猪脚——Jackson,GitHub 上标星 6.1k,Spring Boot 的默认 JSON 解析器。

    怎么证明这一点呢?

    当我们通过 starter 新建一个 Spring Boot 的 Web 项目后,就可以在 Maven 的依赖项中看到 Jackson 的身影。

    v2-625152c936b163adcc83e5fdf9531ffa_b.jpg

    Jackson 有很多优点:

    • 解析大文件的速度比较快;
    • 运行时占用的内存比较少,性能更佳;
    • API 很灵活,容易进行扩展和定制。

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

    • jackson-core,核心包,提供基于“流模式”解析的相关 API,包括 JsonPaser 和 JsonGenerator。
    • jackson-annotations,注解包,提供标准的注解功能;
    • jackson-databind ,数据绑定包,提供基于“对象绑定”解析的相关 API ( ObjectMapper ) 和基于“树模型”解析的相关 API (JsonNode)。

    01、引入 Jackson 依赖

    要想使用 Jackson,需要在 pom.xml 文件中添加 Jackson 的依赖。

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

    jackson-databind 依赖于 jackson-core 和 jackson-annotations,所以添加完 jackson-databind 之后,Maven 会自动将 jackson-core 和 jackson-annotations 引入到项目当中。

    v2-003952bd0f6dcb59ec30ac8056046e8b_b.jpg

    Maven 之所以讨人喜欢的一点就在这,能偷偷摸摸地帮我们把该做的做了。

    02、使用 ObjectMapper

    Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper,它通过 writeValue 的系列方法将 Java 对象序列化为 JSON,并且可以存储成不同的格式。

    • writeValueAsString(Object value) 方法,将对象存储成字符串
    • writeValueAsBytes(Object value) 方法,将对象存储成字节数组
    • writeValue(File resultFile, Object value) 方法,将对象存储成文件

    来看一下存储成字符串的代码示例:

    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    /**
     * 
     *
     * @author 
     * @date 2020/11/26
     */
    public class Demo {
        public static void main(String[] args) throws JsonProcessingException {
            Writer wanger = new Writer("沉默王二", 18);
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writerWithDefaultPrettyPrinter()
                    .writeValueAsString(wanger);
            System.out.println(jsonString);
        }
    }
    
    class Writer {
        private String name;
        private int age;
    
        public Writer(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    }
    

    程序输出结果如下所示:

    {
      "name" : "沉默王二",
      "age" : 18
    }

    不是所有的字段都支持序列化和反序列化,需要符合以下规则:

    • 如果字段的修饰符是 public,则该字段可序列化和反序列化(不是标准写法)。
    • 如果字段的修饰符不是 public,但是它的 getter 方法和 setter 方法是 public,则该字段可序列化和反序列化。getter 方法用于序列化,setter 方法用于反序列化。
    • 如果字段只有 public 的 setter 方法,而无 public 的 getter 方 法,则该字段只能用于反序列化。

    如果想更改默认的序列化和反序列化规则,需要调用 ObjectMapper 的setVisibility() 方法。否则将会抛出 InvalidDefinitionException 异常。

    ObjectMapper 通过 readValue 的系列方法从不同的数据源将 JSON 反序列化为 Java 对象。

    • readValue(String content, Class<T> valueType) 方法,将字符串反序列化为 Java 对象
    • readValue(byte[] src, Class<T> valueType) 方法,将字节数组反序列化为 Java 对象
    • readValue(File src, Class<T> valueType) 方法,将文件反序列化为 Java 对象

    来看一下将字符串反序列化为 Java 对象的代码示例:

    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class Demo {
        public static void main(String[] args) throws JsonProcessingException {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = "{\n" +
                    "  \"name\" : \"沉默王二\",\n" +
                    "  \"age\" : 18\n" +
                    "}";
            Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);
            System.out.println(deserializedWriter);
        }
    }
    
    class Writer{
        private String name;
        private int age;
    
        // getter/setter
    
        @Override
        public String toString() {
            return "Writer{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    程序输出结果如下所示:

    Writer{name='沉默王二', age=18}

    PS:如果反序列化的对象有带参的构造方法,它必须有一个空的默认构造方法,否则将会抛出 InvalidDefinitionException 一行。

    Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.itwanger.jackson.Writer` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
     at [Source: (String)"{
      "name" : "沉默王二",
      "age" : 18
    }"; line: 2, column: 3]
     at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67)
     at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1589)
     at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1055)
     at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1297)
     at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:326)
     at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:159)
     at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4202)
     at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3205)
     at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3173)
     at com.itwanger.jackson.Demo.main(Demo.java:19)
    

    Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper,

    ObjectMapper 也可以将 JSON 解析为基于“树模型”的 JsonNode 对象,来看下面的示例。

    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class JsonNodeDemo {
        public static void main(String[] args) throws JsonProcessingException {
            ObjectMapper mapper = new ObjectMapper();
            String json = "{ \"name\" : \"沉默王二\", \"age\" : 18 }";
            JsonNode jsonNode = mapper.readTree(json);
            String name = jsonNode.get("name").asText();
            System.out.println(name); // 沉默王二
        }
    }

    借助 TypeReference 可以将 JSON 字符串数组转成泛型 List,来看下面的示例:

    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    import java.util.List;
    
    public class TypeReferenceDemo {
        public static void main(String[] args) throws JsonProcessingException {
            ObjectMapper mapper = new ObjectMapper();
            String json = "[{ \"name\" : \"沉默王三\", \"age\" : 18 }, { \"name\" : \"沉默王二\", \"age\" : 19 }]";
            List<Author> listAuthor = mapper.readValue(json, new TypeReference<List<Author>>(){});
            System.out.println(listAuthor);
        }
    }
    class Author{
        private String name;
        private int age;
    
        // getter/setter
    
        // toString
    }

    03、更高级的配置

    Jackson 之所以牛掰的一个很重要的因素是可以实现高度灵活的自定义配置。

    在实际的应用场景中,JSON 中常常会有一些 Java 对象中没有的字段,这时候,如果直接解析的话,会抛出 UnrecognizedPropertyException 异常。

    下面是一串 JSON 字符串:

    String jsonString = "{\n" +
                    "  \"name\" : \"沉默王二\",\n" +
                    "  \"age\" : 18\n" +
                    "  \"sex\" : \"男\",\n" +
                    "}";

    但 Java 对象 Writer 中没有定义 sex 字段:

    class Writer{
        private String name;
        private int age;
    
        // getter/setter
    }

    我们来尝试解析一下:

    ObjectMapper mapper = new ObjectMapper();
    Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);

    不出意外,抛出异常了,sex 无法识别。

    Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "sex" (class com.itwanger.jackson.Writer), not marked as ignorable (2 known properties: "name", "age"])
     at [Source: (String)"{
      "name" : "沉默王二",
      "age" : 18,
      "sex" : ""
    }"; line: 4, column: 12] (through reference chain: com.itwanger.jackson.Writer["sex"])

    怎么办呢?可以通过 configure() 方法忽略掉这些“无法识别”的字段。

    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    除此之外,还有其他一些有用的配置信息,来了解一下:

    // 在序列化时忽略值为 null 的属性
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    // 忽略值为默认值的属性
    mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);

    04、处理日期格式

    对于日期类型的字段,比如说 java.util.Date,如果不指定格式,序列化后将显示为 long 类型的数据,这种默认格式的可读性很差。

    {
      "age" : 18,
      "birthday" : 1606358621209
    }

    怎么办呢?

    第一种方案,在 getter 上使用 @JsonFormat 注解。

    private Date birthday;
    
    // GMT+8 是指格林尼治的标准时间,在加上八个小时表示你现在所在时区的时间
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    public Date getBirthday() {
        return birthday;
    }
    
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    再来看一下结果:

    {
      "age" : 18,
      "birthday" : "2020-11-26 03:02:30"
    }

    具体代码如下所示:

    ObjectMapper mapper = new ObjectMapper();
    Writer wanger = new Writer("沉默王二", 18);
    wanger.setBirthday(new Date());
    String jsonString = mapper.writerWithDefaultPrettyPrinter()
                    .writeValueAsString(wanger);
    System.out.println(jsonString);

    第二种方案,调用 ObjectMapper 的 setDateFormat() 方法。

    ObjectMapper mapper = new ObjectMapper();
    mapper.setDateFormat(StdDateFormat.getDateTimeInstance());
    Writer wanger = new Writer("沉默王二", 18);
    wanger.setBirthday(new Date());
    String jsonString = mapper.writerWithDefaultPrettyPrinter()
                    .writeValueAsString(wanger);
    System.out.println(jsonString);

    输出结果如下所示:

    {
      "name" : "沉默王二",
      "age" : 18,
      "birthday" : "2020年11月26日 上午11:09:51"
    }

    05、字段过滤

    在将 Java 对象序列化为 JSON 时,可能有些字段需要过滤,不显示在 JSON 中,Jackson 有一种比较简单的实现方式。

    @JsonIgnore 用于过滤单个字段。

    @JsonIgnore
    public String getName() {
        return name;
    }

    @JsonIgnoreProperties 用于过滤多个字段。

    @JsonIgnoreProperties(value = { "age","birthday" })
    class Writer{
        private String name;
        private int age;
        private Date birthday;
    }

    06、自定义序列化和反序列化

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

    自定义的序列化类需要继承 StdSerializer,同时重写 serialize() 方法,利用 JsonGenerator 生成 JSON,示例如下:

    public class CustomSerializer extends StdSerializer<Man> {
        protected CustomSerializer(Class<Man> t) {
            super(t);
        }
    
        public CustomSerializer() {
            this(null);
        }
    
        @Override
        public void serialize(Man value, JsonGenerator gen, SerializerProvider provider) throws IOException {
            gen.writeStartObject();
            gen.writeStringField("name", value.getName());
            gen.writeEndObject();
        }
    }
    
    class Man{
        private int age;
        private String name;
    
        public Man(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    定义好自定义序列化类后,要想在程序中调用它们,需要将其注册到 ObjectMapper 的 Module 中,示例如下所示:

    ObjectMapper mapper = new ObjectMapper();
    SimpleModule module =
            new SimpleModule("CustomSerializer", new Version(1, 0, 0, null, null, null));
    module.addSerializer(Man.class, new CustomSerializer());
    mapper.registerModule(module);
    Man man = new Man( 18,"沉默王二");
    String json = mapper.writeValueAsString(man);
    System.out.println(json);
    

    程序输出结果如下所示:

    {"name":"沉默王二"}

    自定义序列化类 CustomSerializer 中没有添加 age 字段,所以只输出了 name 字段。

    再来看一下自定义的反序列化类,继承 StdDeserializer,同时重写 deserialize() 方法,利用 JsonGenerator 读取 JSON,示例如下:

    public class CustomDeserializer extends StdDeserializer<Woman> {
        protected CustomDeserializer(Class<?> vc) {
            super(vc);
        }
    
        public CustomDeserializer() {
            this(null);
        }
    
        @Override
        public Woman deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
            JsonNode node = p.getCodec().readTree(p);
            Woman woman = new Woman();
            int age = (Integer) ((IntNode) node.get("age")).numberValue();
            String name = node.get("name").asText();
            woman.setAge(age);
            woman.setName(name);
            return woman;
        }
    }
    class Woman{
        private int age;
        private String name;
    
        public Woman() {
        }
    
        // getter/setter
    
        @Override
        public String toString() {
            return "Woman{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    

    通过 JsonNode 把 JSON 读取到一个树形结构中,然后通过 JsonNode 的 get 方法将对应字段读取出来,然后生成新的 Java 对象,并返回。

    定义好自定义反序列化类后,要想在程序中调用它们,同样需要将其注册到 ObjectMapper 的 Module 中,示例如下所示:

    ObjectMapper mapper = new ObjectMapper();
    SimpleModule module =
            new SimpleModule("CustomDeserializer", new Version(1, 0, 0, null, null, null));
    module.addDeserializer(Woman.class, new CustomDeserializer());
    mapper.registerModule(module);
    String json = "{ \"name\" : \"三妹\", \"age\" : 18 }";
    Woman woman = mapper.readValue(json, Woman.class);
    System.out.println(woman);
    

    程序输出结果如下所示:

    Woman{age=18, name='三妹'}

    07、结语

    哎呀,好像不错哦,Jackson 绝对配得上“最牛掰”这三个字。如果只想简单的序列化和反序列化,使用 ObjectMapper 的 write 和 read 方法即可。

    如果还想更进一步的话,就需要对 ObjectMapper 进行一些自定义配置,或者加一些注解,以及直接自定义序列化和反序列化类,更贴近一些 Java 对象。

    需要注意的是,对日期格式的字段要多加小心,尽量不要使用默认配置,可读性很差。

    好了,通过这篇文章的系统化介绍,相信读者朋友们已经完全摸透 Jackson 了,我们下篇文章见。


    原作者: 沉默王二
    原文链接: Jackson,最牛掰的 Java JSON 解析器
    原出处:公众号
    侵删

    v2-4d4cccb2b9aae3b11741e93b2f876ed0_b.gif

    展开全文
  • Java JSONJackson是Java的JSON库,它具有非常强大的数据绑定功能,并提供了一个框架,用于将自定义Java对象序列化为JSON并将JSON反序列化为Java对象。用Jackson编写的JSON可以包含嵌入式类信息,这些信息有助于在反...

    Jackson简介

    Java JSON  Jackson是Java的JSON库,它具有非常强大的数据绑定功能,并提供了一个框架,用于将自定义Java对象序列化为JSON并将JSON反序列化为Java对象。用Jackson编写的JSON可以包含嵌入式类信息,这些信息有助于在反序列化期间创建完整的对象树。


    一、导入Jackson相关jar包

    Jackson相关jar包下载地址:https://pan.baidu.com/s/1tHoswz87fgr9fhsdget1mA   提取码:jtb2

    在根目录新建 libs 文件夹 (文件夹随意)

    将jar包复制进来

    然后将jar包添加到构建路径即:右键 jar 包 ==> build path ==> add to build pat(eclipse)

     

    二、创建Java类

    创建Person类,并添加其set 和get 以及 toString方法

    Person.java

    package com.health.domain;
    
    public class Person {
    	private String name;
    	private int age;
    	private String gender;
    	
    	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 String getGender() {
    		return gender;
    	}
    	public void setGender(String gender) {
    		this.gender = gender;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
    	}
    }
    

     

    三、转换示例

    创建Java类,进行转换测试

    JacksonTest.java

    package com.health.test;
    
    import org.junit.Test;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.health.domain.Person;
    
    public class JacksonTest {
    	
    	//Java对象转为JSON字符串
    	@Test
    	public void test1() throws Exception {
    		//1.创建Person对象
    		Person p = new Person();
    		p.setName("张三");
    		p.setAge(22);
    		p.setGender("男");
    		
    		//2.创建Jackson核心对象 ObjectMapper
    		ObjectMapper mapper = new ObjectMapper();
    		//3.转换
    		/* 转换方法
    		 *     writeValue(参数1,obj)
    		 *         参数1:
    		 *             File:将Obj对象转换为JSON字符串,并保存到指定的文件中
    		 *             Writer:将Obj对象转换为JSON字符串,并将其填充到字符输出流中
    		 *             OutputStream:将Obj对象转换为JSON字符串,并将其填充到字节输出流中
    		 *     writeValueAsString(obj):将对象转换为json字符串
    		 */
    		String json = mapper.writeValueAsString(p);
    		
    		System.out.println(json);
    		//{"name":"张三","age":22,"gender":"男"}
    		
    		//将数据源写到e://a.txt中
    		//mapper.writeValue(new File("e://a.txt"),p);
    		
    		//将数据源关联到Writer中
    		//mapper.writeValue(new FileWriter("e://b.txt"),p);
    	}
    	
    	//JSON字符串转换为Java对象
    	@Test
    	public void test2() throws Exception{
    		//1.初始化JSON字符串
    		String json = "{\"name\":\"张三\",\"age\":22,\"gender\":\"男\"}";
    		//2.创建ObjectMapper对象
    		ObjectMapper mapper = new ObjectMapper();
    		//3.转换为Java对象,Person对象
    		Person person = mapper.readValue(json, Person.class);
    		
    		System.out.println(person);
    		//Person [name=张三, age=22, gender=男]
    	}
    }

    项目结构如下图:

    展开全文
  • 只需使用BsonFactory创建一个Jackson ObjectMapper ,如下所示: ObjectMapper mapper = new ObjectMapper ( new BsonFactory ()); 有关更多信息,您可以阅读我的或的完整。 下载 bson4jackson二进制文件可从。 ...
  • 参考 : https://blog.csdn.net/neweastsun/article/details/108814943 https://www.cnblogs.com/a757956132/p/5378400.html
  • Jackson 配置json解析器

    2017-12-28 20:22:50
    jackson-annotations-2.5.4.jar jackson-core-2.5.4.jar jackson-databind-2.5.4.jar
  • Json解析器(jackson)

    2021-01-06 16:23:58
    jackson-annotations-2.2.3.jar jackson-core-2.2.3.jar jackson-databind-2.2.3.jar 3,创建封装类对象 4,创建Jackson核心对象 ObjectMapper mapper = new ObjectMapper(); 5,调用转换方法 /* 转换方法: ...
  • BSON for Jackson此库将对BSON的支持添加到Jackson JSON处理器中。 BSON是JSON的二进制表示形式。 它通过用作Jackson的文档或BSON的主要交换和持久性格式而倍受关注,该库在Jackson JSON处理器中增加了对BSON的支持...
  • Json解析-Jackson使用教程日常求赞,感谢老板。一、JSON解析我这里指的解析是:JSON和JavaObject之间的序列化和反序列化。如果你的项目进行了前后端分离,那你一定使用过JSON进行数据交互,那在后端就一定会涉及到对...
  • jackson 解析复杂json问题

    千次阅读 2018-04-19 18:34:16
    jackson 解析复杂json问题 jackson常见的json生成和解析的工具包...jackson解析javaBean jackson解析泛型的List jackson解析复杂的json jackson简介 Jackson是一种JSON API,也是最流行,速度最快的JSON API...
  • Jackson解析JSON数据教程

    千次阅读 2020-04-02 16:34:51
    (Jason解析Jackson使用教程 日常求赞,感谢老板。 欢迎关注公众号:其实是白羊。干货持续更新中… 一、JSON解析 我这里指的解析是:JSON和JavaObject之间的序列化和反序列化。 如果你的项目进行了前后端分离...
  • JackSon解析器 Java对象与JSON相互转换 JSON解析器: 常见的解析器:Jsonlib,Gson,fastjson,jackson 1.Gson解析器(谷歌) 最好使用最新jar包(百度搜索Gson然后去GitHub上找,或者Maven上也有) 1. JSON转为...
  • Jackson学习笔记(二)Jackson解析xml

    千次阅读 2019-08-21 16:15:05
    Jackson解析xml Jackson解析xml并不常用,推荐使用Dom4j 导入jar文件: //基本 jackson-annotations-2.9.9.jar jackson-core-2.9.9.jar jackson-databind-2.9.9.jar //支持XML jackson-dataformat-xml-2.9.8.jar...
  • java – 用Jackson解析嵌套对象

    千次阅读 2020-12-21 20:04:45
    我正在使用Robospice Retrofit Jackson.我没有普通的类,它有另一个类对象作为字段.我需要解析json并使用field创建类.这是我的课@JsonIgnoreProperties(ignoreUnknown=true)public class User implements ...
  • Jackson 的 json数据解析

    2021-09-22 11:01:03
    常见解析器:Jsonlib,Gson,fastjson,jackson 0 环境准备 pom依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <...
  • JSON解析-Jackson

    2022-05-26 11:11:31
    简介:Jackson是一个简洁的方式去解析JSON开源包。Jackson可以解析JSON从String,Stream,或者file的方式去创建Java对象。Jackson不仅仅可以解析JSON到Java对象,也可以将Java对象解析为JSON字符串。 原理:Java反射...
  • jackson-----json解析器springMVC框架内置常见:jsonlib、gson、fastjson、jackson一、JSON和为Java对象的相互转换(1)Java转为Json 1、创建jackson核心对象 objectMapper 2、调用方法 1、readValue(参数,clazz)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,624
精华内容 10,649
关键字:

jackson解析器