利用Jackson封装常用JsonUtil工具类

在日常的项目开发中，接口与接口之间、前后端之间的数据传输一般都是使用JSON格式，那必然会封装一些常用的Json数据转化的工具类，本文讲解下如何利用Jackson封装高复用性的Json转换工具类。

转换格式属性配置

首先，我们需要对Json对象转换自定义些常用配置属性，封装成适合项目接口规则的工具类。代码如下：

@Slf4j
public class JsonUtil {
    private static ObjectMapper objectMapper = new ObjectMapper();
    // 日起格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    static {
        //对象的所有字段全部列入
       objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    }
}

对象与Json字符串之间的转换

一般对象与字符串之间的转换最为常用，代码实现如下：

    /**
     * 对象转Json格式字符串
     * @param obj 对象
     * @return Json格式字符串
     */
    public static  String obj2String(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 对象转Json格式字符串(格式化的Json字符串)
     * @param obj 对象
     * @return 美化的Json格式字符串
     */
    public static  String obj2StringPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 字符串转换为自定义对象
     * @param str 要转换的字符串
     * @param clazz 自定义对象的class对象
     * @return 自定义对象
     */
    public static  T string2Obj(String str, Class clazz){
        if(StringUtils.isEmpty(str) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (Exception e) {
            log.warn("Parse String to Object error : {}", e.getMessage());
            return null;
        }
    }

上述三个方法实现起来也比较简单，满足了绝大多数业务接口开发，不过聪明的你们也想到了，在字符串转换对象的时候会存在一个坑，不用我说，你们也知道，就是在字符串与集合对象转换时会存在问题，那应该如何解决呢？

集合对象与Json字符串之间的转换

    public static  T string2Obj(String str, TypeReference typeReference) {
        if (StringUtils.isEmpty(str) || typeReference == null) {
            return null;
        }
        try {
            return (T) (typeReference.getType().equals(String.class) ? str : objectMapper.readValue(str, typeReference));
        } catch (IOException e) {
            log.warn("Parse String to Object error", e);
            return null;
        }
    }

    public static  T string2Obj(String str, Class collectionClazz, Class... elementClazzes) {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
        try {
            return objectMapper.readValue(str, javaType);
        } catch (IOException e) {
            log.warn("Parse String to Object error : {}" + e.getMessage());
            return null;
        }
    }

测试用例

实体类

public class User {
    private Integer id;
    private String email;

    // 省略 set 和 get 方法
}

测试代码

@Slf4j
public class JsonUtilTest {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setId(1);
        user1.setEmail("[email protected]");
        String userJsonstr = JsonUtil.obj2String(user1);
        String userJsonPretty = JsonUtil.obj2StringPretty(user1);
        log.info("userJson: {}", userJsonPretty);

        User user2 = JsonUtil.string2Obj(userJsonstr, User.class);
        user2.setId(2);
        user2.setEmail("[email protected]");

        List userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        String userListJson = JsonUtil.obj2String(userList);
        List userListBean = JsonUtil.string2Obj(userListJson, new TypeReference>() {});
        if (userListBean != null) {
            userListBean.forEach(user -> {
                System.out.println(user.getId() + " : " + user.getEmail());
            });
        }
        List userListBean2 = JsonUtil.string2Obj(userListJson, List.class, User.class);
        if (userListBean2 != null) {
            userListBean2.forEach(user -> {
                System.out.println(user.getId() + " : " + user.getEmail());
            });
        }
    }
}

测试用例结果：

测试用例结果