json工具 fastJson和jackson的简单使用

我会带着你远行 2024-02-19 19:50 42阅读 0赞

对json格式数据的操作与转换，是后端程序员的家常便饭，时代在进步，我们不可能还去用 json-lib 这些已被淘汰的工具。

掌握 fastJson和jackson 就显得格外重要！

本文只是利用 fastJson 和 jackson 工具对json进行转换，并不涉及它们更复杂的介绍。

**准备：**

先创建两个测试用的 pojo

package com.liqiye.springbootdemo.entity;
    
    import com.liqiye.springbootdemo.utils.SetName;
    
    /**
     * @author liqiye
     * @description
     * @date 2019/4/6
     */
    public class User {
    
        public Integer id;
        public String name;
        public Integer age;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public User() {
        }
    
        public User(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

package com.liqiye.springbootdemo.entity;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author liqiye
     * @description 用户组
     * @date 2019/4/10
     */
    public class UserGroup {
        private String name;
        private List<User> users = new ArrayList<User>();
        public UserGroup(){}
        public UserGroup(String name, List<User> users){
            this.name = name;
            this.users = users;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public List<User> getUsers() {
            return users;
        }
        public void setUsers(List<User> users) {
            this.users = users;
        }
        @Override
        public String toString() {
            return "UserGroup [name=" + name + ", users=" + users + "]";
        }
    }

**1. fastJson**

引入maven

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.47</version>
    </dependency>

测试类，其实fastjson使用起来十分简单，无非就是一个 JSON 对象，几个方法 toJSONString 、 parseObject 、parseArray

复杂的json也就一层一层转换而已

package com.liqiye.springbootdemo.test;
    
    import com.alibaba.fastjson.JSON;
    import com.liqiye.springbootdemo.entity.User;
    import com.liqiye.springbootdemo.entity.UserGroup;
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author liqiye
     * @description 测试fastjson
     * @date 2019/4/10
     */
    public class FastJsonTest {
    
        // java对象转json字符串
        @Test
        public void objectTOJson(){
            // 简单java类转json字符串
            User user = new User("liqiye", 23);
            String UserJson = JSON.toJSONString(user);
            System.out.println("简单java类转json字符串:"+UserJson);
    
            // List<Object>转json字符串
            User user1 = new User("张三", 23);
            User user2 = new User("李四", 24);
            List<User> users = new ArrayList<User>();
            users.add(user1);
            users.add(user2);
            String ListUserJson = JSON.toJSONString(users);
            System.out.println("List<Object>转json字符串:"+ListUserJson);
    
            //复杂java类转json字符串
            UserGroup userGroup = new UserGroup("用户组", users);
            String userGroupJson = JSON.toJSONString(userGroup);
            System.out.println("复杂java类转json字符串:"+userGroupJson);
        }
    
        // json格式字符串转java对象
        @Test
        public void JsonTOObject(){
            // json字符串转简单java对象
            String jsonStr1 = "{'name':'王五','age': 23}";
            User user = JSON.parseObject(jsonStr1, User.class);
            System.out.println("json字符串转简单java对象:"+user.toString());
    
            // json字符串转List<Object>对象
            String jsonStr2 = "[{'name':'张三','age':23},{'name':'李四','age':24}]";
            List<User> users = JSON.parseArray(jsonStr2, User.class);
            System.out.println("json字符串转List<Object>对象:"+users.toString());
    
            // json字符串转复杂java对象
            String jsonStr3 = "{'name':'用户组','users':[{'name':'张三','age':23},{'name':'李四','age':24}]}";
            UserGroup userGroup = JSON.parseObject(jsonStr3, UserGroup.class);
            System.out.println("json字符串转复杂java对象:"+userGroup);
        }
    
        // map转json字符串
        @Test
        public void mapToJson(){
            Map<String, User> map = new HashMap<String, User>();
            map.put("男生",new User("张三",23));
            map.put("女生",new User("李四",24));
            String mapJson = JSON.toJSONString(map);
            System.out.println("map转json字符串:"+mapJson);
        }
    
        // json字符串转map(复杂map,其实就是一层一层拆分，同样用的都只是JSON的toJSONString方法和parseObject方法)
        @Test
        public void jsonToMap(){
            String str = "{\"男生\":{\"age\":23,\"name\":\"张三\"},\"女生\":{\"age\":24,\"name\":\"李四\"}}";
            Map map = JSON.parseObject(str);
            for (Object obj : map.keySet()){
                System.out.println("map的key为："+obj+"、值为："+map.get(obj));
                //  map的每一个都是一个JSONObject对象，先将它转成json字符串
                String s = JSON.toJSONString(map.get(obj));
                // 再将json字符串转自定义对象
                User user = JSON.parseObject(s, User.class);
                System.out.println(user);
            }
        }
    
    }

**2.jackson**

引入maven

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

测试类，jackson和fastjson一样很简单，new一个ObjectMapper，用方法 writeValueAsString 和 readValue 即可实现转换

package com.liqiye.springbootdemo.test;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.liqiye.springbootdemo.entity.User;
    import org.junit.Test;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author liqiye
     * @description 测试Jackson
     * @date 2019/4/10
     */
    public class JacksonTest {
    
        // json字符串和java对象、字节流、文件 之间的转换
        @Test
        public void test1() throws IOException {
            ObjectMapper mapper = new ObjectMapper(); // jackson的核心类
            User user = new User("张三", 23);
            // java对象转json字符串
            String text = mapper.writeValueAsString(user);
            System.out.println("java对象转json字符串:"+text);
            // json字符串转java对象
            String str = "{\"id\":null,\"name\":\"李四\",\"age\":24}";
            User user1 = mapper.readValue(text, User.class);
            System.out.println("json字符串转java对象:"+user1);
            // java对象转为json文件，（在根目录生成）
            mapper.writeValue(new File("user.json"), user);
            // java对象转为字节流
            byte[] bytes = mapper.writeValueAsBytes(user);
            // 字节流转java对象
            User user2 = new User();
            user2 = mapper.readValue(bytes, User.class);
            System.out.println("字节流转java对象"+user2);
            // json文件转java对象
            User user3 = new User();
            user3 = mapper.readValue(new File("user.json"), User.class);
            System.out.println("json文件转java对象"+user3);
        }
    
        // json字符串与map之间的相互转化
        @Test
        public void test2() throws IOException {
            ObjectMapper mapper = new ObjectMapper();
            // map转json字符串
            Map<String, User> map = new HashMap<>();
            map.put("男生", new User("张三",23));
            map.put("女生", new User("李四",24));
            String text = mapper.writeValueAsString(map);
            System.out.println("map转json字符串："+text);
            // json字符串转map
            String str = "{\"男生\":{\"id\":null,\"name\":\"王五\",\"age\":25},\"女生\":{\"id\":null,\"name\":\"李四\",\"age\":24}}";
            Map<String, User> map2 = mapper.readValue(str, new TypeReference<Map<String, User>>() {});
            System.out.println("json字符串转map："+map2);
            // 复杂map一层一层拆分转化即可
            for (Object obj : map2.keySet()){
                // 这里与fastJson不同，jackson转成map时已指定里面的类型
                User user = map2.get(obj);
                System.out.println("map里面的value："+user);
    
            }
        }
    
        // json字符串与list之间的相互转化
        @Test
        public void test3() throws IOException {
            ObjectMapper mapper = new ObjectMapper();
            // list转json字符串
            ArrayList<User> list = new ArrayList<>();
            list.add(new User("张三",23));
            list.add(new User("李四",24));
            String text = mapper.writeValueAsString(list);
            System.out.println("list转json字符串："+text);
            // json字符串转list
            String str = "[{\"id\":null,\"name\":\"王五\",\"age\":25},{\"id\":null,\"name\":\"李四\",\"age\":24}]";
            List<User> list2 = mapper.readValue(str,new TypeReference<List<User>>() {});
            System.out.println("json字符串转list："+list2);
        }
    
    }

jackson还有很多功能，我这里就只做了json转换的测试

**其实这两种工具各有利弊，有人说很多情况下，fastjson的效率高一点，也确实是，它是专注json转换的；不过jackson功能更强大些，各大框架也是采用的jackson，各位就按需取用吧**