json工具 fastJson和jackson的简单使用

最新推荐文章于 2023-02-11 15:02:29 发布

单手入天象

最新推荐文章于 2023-02-11 15:02:29 发布

阅读量502

点赞数

分类专栏： json转换文章标签： json转换 fastjson jackson

本文链接：https://blog.csdn.net/weixin_42132143/article/details/89182918

版权

json转换专栏收录该内容

1 篇文章 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，各位就按需取用吧

单手入天象

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
json工具 fastJson和jackson的简单使用

对json格式数据的操作与转换，是后端程序员的家常便饭，时代在进步，我们不可能还去用json-lib 这些已被淘汰的工具。掌握fastJson和jackson 就显得格外重要！本文只是利用 fastJson 和 jackson 工具对json进行转换，并不涉及它们更复杂的介绍。准备：先创建两个测试用的 pojopackage com.liqiye.springboo...
复制链接

扫一扫