java工具類-jackson

工作中，接口與接口交互時，常常會將json和bean/list相互轉化，來處理。本文基於jackson來封裝工具

更多內容可以關注：iworkh博客

1.說明

如果沒使用springboot的話，那麼需要添加依賴，並初始化對象

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

如何在springboot中使用的，不用添加依賴，也可以不用自己實例化，使用spring容器已實例化的objectMapper，只要將對象交給容器管理，並注入對應的實列即可。
(當然了不用ioc容器的，自己創建一個實列也無可厚非）

2.工具類

主要以下幾個方法

• json轉對象
• 對象轉json(json格式化)
• json轉化爲泛型類型對象（集合等泛型方式）

package com.iworkh.test.restassured.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

/**
 * json轉化工具類
 *
 * @author: iworkh-沐雨雲樓
 * @date: 2020-06-18
 */
public class JacksonTool {

    private static final Logger LOGGER = LoggerFactory.getLogger(JacksonTool.class);

    private final static ObjectMapper mapper;

    static {
        mapper = new ObjectMapper();
        // 忽略json中在對象不存在對應屬性
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 忽略空bean轉json錯誤
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
    }

    /**
     * json轉對象
     *
     * @param jsonStr   json串
     * @param classType 對象類型
     * @return 對象
     */
    public static <T> T toEntity(String jsonStr, Class<T> classType) {

        if (StringUtils.isEmpty(jsonStr)) {
            LOGGER.warn("Json string {} is empty!", classType);
            return null;
        }

        try {
            return mapper.readValue(jsonStr, classType);
        } catch (IOException e) {
            LOGGER.error("json to entity error.", e);
        }
        return null;
    }

    /**
     * json轉化爲帶泛型的對象
     *
     * @param jsonStr json字符串
     * @param typeReference 轉化類型
     * @return 對象
     */
    public static <T> T toEntity(String jsonStr, TypeReference<T> typeReference) {
        if (StringUtils.isBlank(jsonStr) || typeReference == null) {
            return null;
        }
        try {
            return (T) mapper.readValue(jsonStr, typeReference);
        } catch (JsonProcessingException e) {
            LOGGER.error("json to entity error.", e);
        }
        return null;
    }

    /**
     * 對象轉json
     *
     * @param obj 對象
     * @return json串
     */
    public static String toJson(Object obj) {
        if (obj instanceof String) {
            return (String) obj;
        }
        try {
            return mapper.writeValueAsString(obj);
        } catch (IOException e) {
            LOGGER.error("obj to json error.", e);
        }
        return null;
    }

    /**
     * 對象轉json(格式化的json)
     *
     * @param obj 對象
     * @return 格式化的json串
     */
    public static String toJsonWithFormat(Object obj) {
        if (obj == null) {
            return null;
        }

        if (obj instanceof String) {
            return (String) obj;
        }

        try {
            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (IOException e) {
            LOGGER.error("obj to json error.", e);
        }
        return null;
    }
}

3.調用

使用很簡單，主要注意下泛型對象的轉化使用 new TypeReference<List<UserVo>>() {})

public class JacksonToolTest {

    @Test
    public void testEntityToJson() {
        String[] hobbies = {"football", "sing"};
        UserVo user = new UserVo(1, "iworkh", System.currentTimeMillis(), false, Arrays.asList(hobbies));
        String json = JacksonTool.toJson(user);
        System.out.println(json);
    }

    @Test
    public void testJsonToEntity() {
        String json = "{\"id\":1,\"name\":\"iworkh\",\"birthday\":1592575139578,\"vip\":false,\"hobbies\":[\"football\",\"sing\"]}";
        UserVo userVo = JacksonTool.toEntity(json, UserVo.class);
        if (userVo != null) {
            System.out.println(userVo.getName());
        }
    }


    @Test
    public void testListEntityToJson() {
        String[] hobbies = {"football", "sing"};
        UserVo user1 = new UserVo(1, "iworkh1", System.currentTimeMillis(), false, Arrays.asList(hobbies));
        UserVo user2 = new UserVo(2, "iworkh2", System.currentTimeMillis(), false, Arrays.asList(hobbies));
        ArrayList<UserVo> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        String json = JacksonTool.toJson(list);
        System.out.println(json);
    }

    @Test
    public void testJsonToListEntity() {
        String json = "[{\"id\":1,\"name\":\"iworkh1\",\"birthday\":1592575376189,\"vip\":false,\"hobbies\":[\"football\",\"sing\"]}," + "{\"id\":2,\"name\":\"iworkh2\",\"birthday\":1592575376189,\"vip\":false,\"hobbies\":[\"football\",\"sing\"]}]";
        List<UserVo> userList = JacksonTool.toEntity(json, new TypeReference<List<UserVo>>() {
        });

        userList.forEach(item -> {
            System.out.println(item.getName());
        });
    }
}

更多內容可以關注：iworkh博客