Jackson基本使用教程

目录

• 如何将一个Json序列化对象封装成为一个Pojo是实体类对象
• 如何进行序列化与反序列化
• 如何将数据进行绑定
• 如何进行泛型数据绑定
• 如何使用Jackson树模型(将复杂Json手动映射到类型)
• 使用Jackson进行流式处理

如何将一个Json序列化对象封装成为一个Pojo是实体类对象

public static void main(String[] args) {

        //创建ObjectMapper对象，这是一个可重复使用的对象
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";

        //map to json student
        try {
            //反序列化得到JSON对象，
            // 从JSON对象使用readValue方法来获取，通过JSON字符串对象类型作为参数JSON字符串(json字符串，字符串类型)
            Student student = mapper.readValue(jsonString, Student.class);
            System.out.println(student.toString());

            //设置JSON的格式[缩进、单\双引号....]
            mapper.enable(SerializationFeature.INDENT_OUTPUT);
            //使用writeValueAsString()方法来获取对象的JSON字符串表示。
            jsonString = mapper.writeValueAsString(student);
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

如何进行序列化与反序列化

 public static void main(String[] args) {
        JacksonSer jacksonSer = new JacksonSer();
        try {
            Student student = new Student();
            student.setAge(22);
            student.setName("RenZetong");

            //将Pojo对象序列化为Json
            jacksonSer.writeJSON(student);

            //将Json反序列化为Pojo对象
            Student student1 = jacksonSer.readJSON();
            System.out.println(student1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化
     *
     * @param student
     * @throws Exception
     */
    private void writeJSON(Student student) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        //使用writeValue来将Json文件写入(Json文件，映射类)
        mapper.writeValue(new File("./data/student.json"), student);
    }

    /**
     * 反序列化
     *
     * @return
     * @throws Exception
     */
    private Student readJSON() throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        //从JSON对象使用readValue方法来获取，通过JSON字符串对象类型作为参数JSON字符串(json字符串，字符串类型)
        Student student = mapper.readValue(new File("./data/student.json"), Student.class);
        return student;
    }

如何将数据进行绑定

 public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        Map<String, Object> studentMap = new HashMap<>();
        int[] marks = {1, 2, 3};

        Student student = new Student();
        student.setAge(10);
        student.setName("Mahesh");

        //Java Object 也就是实体类对象
        studentMap.put("student", student);
        //Java String 也就是键值对
        studentMap.put("name", "Mahesh Kumar");
        //Java Boolean
        studentMap.put("verified", Boolean.FALSE);
        //Array Type 数组类型
        studentMap.put("marks", marks);

        //将map数据序列化为Json
        //mapper.writeValue(new File("./data/students.json"), studentMap);

        //将复杂型Json通过readValue解析到Map集合中(Json文件，映射类型) 反序列化
        studentMap = mapper.readValue(new File("./data/students.json"), Map.class);

        //反序列化集合中的Json数据
        System.out.println(studentMap.get("student"));
        System.out.println(studentMap.get("name"));
        System.out.println(studentMap.get("verified"));
        System.out.println(studentMap.get("marks"));

        //反序列化数组对象
        List<Integer> list = (List<Integer>) studentMap.get("marks");
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

如何进行泛型数据绑定

public String method() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User();
        user.setId(1);
        Pager<User> pager = new Pager<User>();
        List<User> users = new ArrayList<User>();
        users.add(user);
        pager.setDatas(users);
        String json = mapper.writeValueAsString(pager);
        // 方式1
        Pager<User> userPager1 = mapper.readValue(json, new TypeReference<Pager<User>>() {
        });
        // 方式2
        Type[] types = new Type[1];
        types[0] = User.class;
        final ParameterizedTypeImpl type = ParameterizedTypeImpl.make(Pager.class, types, Pager.class.getDeclaringClass());
        TypeReference typeReference = new TypeReference<Pager>() {
            @Override
            public Type getType() {
                return type;
            }
        };
        Pager<User> userPager2 = mapper.readValue(json, typeReference);
        // 方式3
        JavaType javaType = mapper.getTypeFactory().constructParametrizedType(Pager.class, Pager.class, User.class);
        Pager<User> userPager3 = mapper.readValue(json, javaType);
        // 方式4
        JavaType javaType1 = mapper.getTypeFactory().constructParametricType(Pager.class, User.class);
        Pager<User> userPager4 = mapper.readValue(json, javaType1);
        // 方式5，新建另一个指定具体泛型T的参数的类
        PagerAppoint userPager5 = mapper.readValue(json, PagerAppoint.class);
        // 数组泛型的序列化和反序列化
        String json1 = mapper.writeValueAsString(users);
        JavaType javaType2 = mapper.getTypeFactory().constructParametricType(List.class, User.class);
        List<User> users1 = mapper.readValue(json1, javaType2);
        // HashMap
        Map<String, User> map = new HashMap<String, User>(16);
        map.put("test", user);
        String json2 = mapper.writeValueAsString(map);
        // 1
        Map<String, User> users2 = mapper.readValue(json2, new TypeReference<Map<String, User>>() {
        });
        // 2
        JavaType javaType3 = mapper.getTypeFactory().constructParametricType(HashMap.class, String.class, User.class);
        Map<String, User> users3 = mapper.readValue(json2, javaType3);

        return "hello world";
    }
}

如何使用Jackson树模型(将复杂Json手动映射到类型)

public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";

        //使用readTree来读取json数据
        JsonNode rootNode = mapper.readTree(jsonString);

        //使用path获取节点
        JsonNode nameNode = rootNode.path("name");
        System.out.println("Name: " + nameNode.textValue());

        JsonNode ageNode = rootNode.path("age");
        System.out.println("Age: " + ageNode.intValue());

        JsonNode verifiedNode = rootNode.path("verified");
        System.out.println("Verified: " + verifiedNode.booleanValue());

        JsonNode marksNode = rootNode.path("marks");
        Iterator<JsonNode> iterator = marksNode.elements();
        System.out.println("Marks:[");
        for (JsonNode node : marksNode) {
            System.out.println(node.intValue());
        }
        System.out.println("]");
    }

读取json文件进行树遍历

public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        JsonNode rootNode;

        //读取Json文件到JsonNode;
        rootNode = mapper.readTree(new File("./data/students.json"));

        //使用树模型来读取Json文件并映射到Pojo对象
        UserInfo userInfo = mapper.treeToValue(rootNode, UserInfo.class);

        System.out.println("Name: " + userInfo.getName());
    }

使用Jackson进行流式处理

JacksonParse类用于读取Json，JacksonGenerator用于编写Json

public static void main(String[] args) throws Exception {
        //writeJSON();
        readJSON();
    }

    //使用JsonGenerator写入JSON
    public static JsonGenerator writeJSON() throws Exception {
        JsonFactory jsonFactory = new JsonFactory();
        //创建json输出路径以及字符编码
        JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File("./data/stu.json"), JsonEncoding.UTF8);
        //{
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("name", "RenZetong");
        jsonGenerator.writeNumberField("age", 22);
        jsonGenerator.writeBooleanField("verified", false);

        //marks:[
        jsonGenerator.writeFieldName("marks");
        jsonGenerator.writeStartArray();
        jsonGenerator.writeNumber(100);
        jsonGenerator.writeNumber(90);
        jsonGenerator.writeNumber(85);
        jsonGenerator.writeEndArray();
        //]
        jsonGenerator.writeEndObject();
        jsonGenerator.close();
        //}

        return jsonGenerator;
        //result student.json
        //{
        //   "name":"Mahesh Kumar",
        //   "age":21,
        //   "verified":false,
        //   "marks":[100,90,85]
        //}
    }

    //使用JsonParser解析JSON字符串
    public static void readJSON() throws Exception {
        JsonFactory jsonFactory = new JsonFactory();
        JsonParser jsonParser = jsonFactory.createParser(new File("./data/stu.json"));
        //如果没有迭代到Json对象结束节点则一直循环
        while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
            //获取当前节点名称
            String fieldName = jsonParser.getCurrentName();
            if ("name".equals(fieldName)) {
                //如果没有剩余标记则停止迭代
                jsonParser.nextToken();
                //获取当前节点值
                System.out.println(jsonParser.getText());
            }
            if ("age".equals(fieldName)) {
                jsonParser.nextToken();
                System.out.println(jsonParser.getNumberValue());
            }
            if ("verified".equals(fieldName)) {
                jsonParser.nextToken();
                System.out.println(jsonParser.getBooleanValue());
            }
            if ("marks".equals(fieldName)) {
                jsonParser.nextToken();
                //如果没有迭代到Json数组对象结束节点则一直循环
                while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                    System.out.println(jsonParser.getNumberValue());
                }
            }
        }
    }