public class JsonUtils {
public 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;
}
}
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;
}
}
}
public class JsonMapper {
private JsonMapper() {
throw new IllegalStateException("Utility class");
}
private static final Logger logger = LoggerFactory
.getLogger(JsonMapper.class);
private static ObjectMapper mapper = new ObjectMapper();
/**
* 将对象装成Json
*
* @param src
* @return
*/
public static Optional<String> convertToJson(Object src) {
try {
return Optional.ofNullable(mapper.writeValueAsString(src));
} catch (Exception e) {
logger.error("convert To Json error.", e);
return Optional.empty();
}
}
/**
* 将对象转为map 简单对象
*
* @param src
* @return
*/
public static Optional<Map<String, Object>> covertSingleToMap(Object src) {
try {
String values = mapper.writeValueAsString(src);
Map<String, Object> maps = mapper.readValue(values, Map.class);
return Optional.of(maps);
} catch (Exception e) {
logger.error("convert To map error.", e);
return Optional.empty();
}
}
/**
* 将 Json 转成指定对象
*
* @param json
* @param valueType
* @return
*/
public static <T> Optional<T> convert(String json, Class<T> valueType) {
try {
if (StringUtils.isBlank(json)) {
return Optional.empty();
}
return Optional.ofNullable(mapper.readValue(json, valueType));
} catch (Exception e) {
logger.error(
String.format("convert json [%s] To value type [%s] Error.",
json, valueType),
e);
return Optional.empty();
}
}
/**
* 将json串转换为List集合
*
* @param json
* @param type
* @param <T>
* @return
*/
public static <T> List<T> convertList(String json, Class<T> type) {
JavaType javaType = mapper.getTypeFactory()
.constructParametricType(ArrayList.class, type);
try {
if (StringUtils.isEmpty(json))
return Collections.emptyList();
return mapper.readValue(json, javaType);
} catch (Exception e) {
logger.error(
String.format("convert json [%s] To value type [%s] Error.",
json, type),
e);
throw new NumberFormatException(e.getMessage());
}
}
public static Optional<Map<String, String>> convertSingleMap(String json) {
try {
Map map = mapper.readValue(json, Map.class);
return Optional.ofNullable(map);
} catch (Exception e) {
logger.error(
String.format("convert json [%s] To value Error.", json),
e);
return Optional.empty();
}
}
public static <T> T convert(Map<String, String> value, Class<T> type) {
try {
String jsonValue = mapper.writeValueAsString(value);
Optional<T> optional = convert(jsonValue, type);
if (!optional.isPresent()) {
return null;
}
return optional.get();
} catch (Exception e) {
logger.error(
String.format("convert json [%s] To value type [%s] Error.",
value, type),
e);
return null;
}
}
}