使用Jackson实现json格式字符串与obj之间的转换

1. json字符串简介

JSON（JavaScript Object Notation）是一种轻量级数据交换格式，具有格式简单、易于读写、占用带宽少等有点，常被用于序列化和反序列化的中间格式。通俗的理解：json是一个有规则的字符串，它的表达（表现）形式是键值对，非常类似于Java语言中的Map，主要用于交互的一种数据格式。

2. 转换工具

json转换常用的类库有Jackson、GoogleGson、Json-lib、Flexjson、Json-io、Genson、JSONiJ等7种，其中Jackson使用较为流行，本文基于Jackson介绍。

3. json与obj相互转换

Jackson默认使用BeanSerializer序列化POJO，要求对应的字段为public类型或者有对应的getter()方法。

2.1 obj转json字符串

ObjectMapper mapper = new ObjectMapper();
mapper.configure(SerializationFeature.INDENT_OUTPUT, true); //输出格式化

//设置输出时间格式
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss);
mapper.setDateFormat(dateFormat);

//Map按序输出
mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);

Object obj;
String result = mapper.writeValueAsString(obj);

2.2 json字符串转obj

String str;
ObjectMapper mapper = new ObjectMapper();
Object result = mapper.readValue(str, Object.class);

2.3 转换为List类型

String str;
ObjectMapper mapper = new ObjectMapper();List<Object> result = mapper.readValue(str, new 
TypeReference<List<Object>>() {});

2.4 转化为Map类型

String str;
ObjectMapper mapper = new ObjectMapper();
Map map = mapper.readValue(str, Map.class);

2.5 特殊格式字段转换

字符串与变量名转换

@JsonProperty(value = "short_name")
public String shortName;

转换日期

@JsonFormat

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", locale = "zh", timezone = "GMT+8")
public Date date;

Jackson在序列化时间时是按照国际标准时间GMT格式化的，而国内默认时区是CST时区，及北京时区东八区，两者相差8小时。

4. json转换工具

最后，提供给大家两个完整的json转换工具，功能强大，可以直接使用。

4.1 常用版本

public class JsonUtils {

    private static final ObjectMapper MAPPER = new ObjectMapper();
    private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);

    public static String toString(Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj.getClass() == String.class) {
            return (String) obj;
        }
        try {
            return MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("json序列化出错：" + obj, e);
            return null;
        }
    }

    public static <T> T toBean(String json, Class<T> tClass) {
        try {
            return MAPPER.readValue(json, tClass);
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }

    public static <E> List<E> toList(String json, Class<E> eClass) {
        try {
            return MAPPER.readValue(json, MAPPER.getTypeFactory().constructCollectionType(List.class, eClass));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }

    public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return MAPPER.readValue(json, MAPPER.getTypeFactory().constructMapType(Map.class, kClass, vClass));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }

    /**
     * 把json字符串反序列化，当反序列化的结果比较复杂时，通过这个方法转换
     */
    public static <T> T nativeRead(String json, TypeReference<T> type) {
        try {
            return MAPPER.readValue(json, type);
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }
}

4.2 Optional 取代null的版本

利用Java8 Optional 取代null的json转换工具

/**
 * 可以避免空指针异常的json转换工具
 * Create by @author BG331145 杨威 on 2019/1/20 0020 - 16:58
 */
public class JsonUtilOptional {
    
    public static final ObjectMapper mapper = new ObjectMapper();
    
    private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);
    
    public static Optional<String> toString(Object obj) {
        if (obj == null) {
            return Optional.empty();
        }
        
        if (obj.getClass() == String.class) {
            return Optional.of(obj.toString());
        }
        
        try {
            return Optional.ofNullable(mapper.writeValueAsString(obj));
        } catch (JsonProcessingException e) {
            logger.error("json序列化出错：" + obj, e);
            return Optional.empty();
        }
    }
    
    public static <T> Optional<T> toBean(String json, Class<T> tClass) {
        try {
            return Optional.ofNullable(mapper.readValue(json, tClass));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return Optional.empty();
        }
    }
    
    public static <E> Optional<List<E>> toList(String json, Class<E> eClass) {
        try {
            return Optional.ofNullable(mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass)));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return Optional.empty();
        }
    }
    
    public static <K, V> Optional<Map<K, V>> toMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return Optional.ofNullable(mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass)));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return Optional.empty();
        }
    }
    
    /**
     * 把json字符串反序列化，当反序列化的结果比较复杂时，通过这个方法转换
     */
    public static <T> Optional<T> nativeRead(String json, TypeReference<T> type) {
        try {
            return Optional.ofNullable(mapper.readValue(json, type));
        } catch (IOException e) {
            logger.error("json解析出错：" + json, e);
            return Optional.empty();
        }
    }
    
}