Json操作工具类，使用jackson，可用作json字符串转Java类，字符串转Map，Java对象转json字符串等等

已于 2023-05-17 15:52:18 修改
阅读量706 收藏 2
点赞数
分类专栏： 【Java】 文章标签： java json servlet
于 2023-05-17 15:50:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxlhljh/article/details/127917286
版权
该文章提供了一个使用Jackson库的Json工具类，用于Java对象与Json字符串之间的转换，包括日期时间的处理。此外，还展示了如何测试这个工具类，包括对象转Json字符串、字符串转Map、以及通过点语法获取嵌套数据等操作。
摘要由CSDN通过智能技术生成

Json操作工具类，使用jackson，可用作json字符串转Java类，字符串转Map，Java对象转json字符串等等.md

一、Json工具类如下

package cn.lihua.system.utils;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

public class JsonUtil {

    private final static Logger logger = LoggerFactory.getLogger(JsonUtil.class);

    //日期格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private static ObjectMapper objectMapper;

    static{

        /**
         * ObjectobjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectobjectMapper中实现。
         * ObjectobjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
         * writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
         * writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
         * writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
         * writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。
         */
        objectMapper = new ObjectMapper();

        //对象的所有字段全部列入
        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);

        objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        objectMapper.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
        
        //解决Java8 LocalDate,LocalDateTime等序列化问是同
        JavaTimeModule module=new JavaTimeModule();
        module.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        module.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        module.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        module.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        objectMapper.registerModule(module);


    }

    /**
     * 对象转Json格式字符串
     * @param obj 对象
     * @return Json格式字符串
     */
    public static String toJSONString(Object o) {

        if (o == null) {
            return null;
        }

        if (o instanceof String)
            return (String) o;

        String jsonValue = null;
        try {
            jsonValue = objectMapper.writeValueAsString(o);
        } catch (JsonProcessingException e) {
            logger.error("Parse Object to String error",e);
        }

        return jsonValue;

    }

    @SuppressWarnings("unchecked")
    public static Map<String,Object> castToObject(String fromValue){
        if(fromValue == null || "".equals(fromValue) ){
            return null;
        }

        try {
            return objectMapper.readValue(fromValue, Map.class);
        } catch (Exception e) {
            logger.error("Parse String to Object error:", e);
            return null;
        }

    }

    /**
     * 字符串转换为自定义对象
     * @param str 要转换的字符串
     * @param clazz 自定义对象的class对象
     * @return 自定义对象
     */
    @SuppressWarnings("unchecked")
    public static <T> T castToObject(String fromValue, Class<T> clazz){
        if(fromValue == null || "".equals(fromValue) || clazz == null){
            return null;
        }

        try {
            return clazz.equals(String.class) ? (T) fromValue : objectMapper.readValue(fromValue, clazz);
        } catch (Exception e) {
            logger.error("Parse String to Object error:", e);
            return null;
        }

    }

    @SuppressWarnings("unchecked")
    public static <T> T castToObject(String fromValue, TypeReference<T> typeReference) {
        if (fromValue == null || "".equals(fromValue) || typeReference == null) {
            return null;
        }
        try {
            return (T) (typeReference.getType().equals(String.class) ? fromValue : objectMapper.readValue(fromValue, typeReference));
        } catch (IOException e) {
            logger.error("Parse String to Object error:", e);
            return null;
        }
    }
    
    public static <T> T castToObject(String fromValue, Class<?> collectionClazz, Class<?>... elementClazzes) {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
        try {
            return objectMapper.readValue(fromValue, javaType);
        } catch (IOException e) {
            logger.error("Parse String to Object error : ", e.getMessage());
            return null;
        }
    }
    
    public static <T> T getValue(String fromValue, Class<T> clazz){
    	return castToObject(fromValue,clazz);
    }
    
    public static <T> T getValue(String fromValue, TypeReference<T> toValueTypeRef){
    	return castToObject(fromValue, toValueTypeRef);
    }
    
    public static <T> T getValue(String fromValue, Class<?> collectionClazz, Class<?>... elementClazzes){
    	return castToObject(fromValue, collectionClazz, elementClazzes);
    }
    
    //可通过点语法获取数据，如getValue("data.list","xxxxxxxx",List.class);
    public static <T> T getValue(String key, String fromValue, Class<T> clazz){
    	Map<String,Object> infoMap = castToObject(fromValue);
    	if(infoMap == null) return null;
    	
    	return getValue(key, infoMap, clazz);
    }
    
    //可通过点语法获取数据，如getValue("data.list","xxxxxxxx",new TypeReference<List<User>>(){});
    public static <T> T getValue(String key, String fromValue, TypeReference<T> toValueTypeRef){
    	Map<String,Object> infoMap = castToObject(fromValue);
    	if(infoMap == null) return null;
    	
    	return getValue(key, infoMap, toValueTypeRef);
    }
    
    public static <T> T getValue(String key, String fromValue, Class<?> collectionClazz, Class<?>... elementClazzes){
    	Map<String,Object> infoMap = castToObject(fromValue);
    	if(infoMap == null) return null;
    	return getValue(key, infoMap, collectionClazz, elementClazzes);
    }
    
    //可通过点语法获取数据，如getValue("data.list",new TypeReference<List<User>>(){});
    @SuppressWarnings("rawtypes")
	public static <T> T getValue(String key, Map fromMap, Class<T> clazz){
    	
    	try {
    		
    		// 首先将key进行拆分
            String[] keys = key.split("[.]");
            
            for (int i = 0; i < keys.length; i++) {
            	
            	Object value = fromMap.get(keys[i]);
            	if(value == null) return null;
            	
            	if (i < keys.length - 1) {
            		fromMap = (Map) value;
                }else {
                    return objectMapper.convertValue(value, clazz);
                }
            }
            
        } catch (Exception e) {
            logger.error("getValue error : ", e.getMessage());
            return null;
        }
        
        return null;
        
    }
    
    @SuppressWarnings("rawtypes")
	public static <T> T getValue(String key, Map fromMap, Class<?> collectionClazz, Class<?>... elementClazzes){
    	try {
    		
        	// 首先将key进行拆分
            String[] keys = key.split("[.]");
            
            for (int i = 0; i < keys.length; i++) {
            	
            	Object value = fromMap.get(keys[i]);
            	if(value == null) return null;
            	
            	if (i < keys.length - 1) {
            		fromMap = (Map) value;
                }else {
                	JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
                    return objectMapper.convertValue(value, javaType);
                }
            	
            }
            
        } catch (Exception e) {
            logger.error("getValue error : ", e.getMessage());
            return null;
        }
    	
        return null;
    }
    
    @SuppressWarnings("rawtypes")
	public static <T> T getValue(String key, Map fromMap, TypeReference<T> toValueTypeRef){
    	
    	try {
    		
        	// 首先将key进行拆分
            String[] keys = key.split("[.]");
            
            for (int i = 0; i < keys.length; i++) {
            	
            	Object value = fromMap.get(keys[i]);
            	if(value == null) return null;
            	
            	if (i < keys.length - 1) {
            		fromMap = (Map) value;
                }else {
                    return objectMapper.convertValue(value, toValueTypeRef);
                }
            	
            }
            
        } catch (Exception e) {
            logger.error("getValue error : ", e.getMessage());
            return null;
        }
    	
        return null;
        
    }
    
    /**
     * 将对像转换成具体的其他Bean对像
     * @param fromValue
     * @param toValueTypeRef
     * @return
     */
    public static <T> T convertValue(Object fromValue, TypeReference<T> toValueTypeRef){
    	
    	try {
    		return objectMapper.convertValue(fromValue, toValueTypeRef);
        } catch (Exception e) {
            logger.error("convertValue error : ", e.getMessage());
            return null;
        }
    	
    }
    
    public static <T> T convertValue(Object fromValue, Class<T> toValueType){
    	
    	try {
    		return objectMapper.convertValue(fromValue, toValueType);
        } catch (Exception e) {
            logger.error("convertValue error : ", e.getMessage());
            return null;
        }
    	
    }

    public static String getString(Map<String,Object> fromMap, String fieldName){
        return fromMap.get(fieldName)==null ? null : fromMap.get(fieldName).toString();
    }
    
    //根据filedName的key查找map为空时，使用对应的defaultValue默认值替换返回
    public static String getString(Map<String,Object> jsonObject, String fieldName,String defaultValue){
        return jsonObject.get(fieldName)==null ? defaultValue : jsonObject.get(fieldName).toString();
    }

    public static Integer getInteger(Map<String,Object> jsonObject, String fieldName){
        return jsonObject.get(fieldName)==null ? null : (Integer)jsonObject.get(fieldName);
    }
    
    public static Double getDouble(Map<String,Object> jsonObject, String fieldName){
        return jsonObject.get(fieldName)==null ? null : (Double)jsonObject.get(fieldName);
    }
    
    public static Boolean getBoolean(Map<String,Object> jsonObject, String fieldName){
        return jsonObject.get(fieldName)==null ? false : (Boolean)jsonObject.get(fieldName);
    }
    
    public static Long getLong(Map<String,Object> jsonObject, String fieldName){
        return jsonObject.get(fieldName)==null ? null : (Long)jsonObject.get(fieldName);
    }
    
    @SuppressWarnings("unchecked")
    public static <T> List<T> getList(Map<String,Object> jsonObject, String fieldName,Class<T> clazz){
        return jsonObject.get(fieldName)==null ? null : (List<T>)jsonObject.get(fieldName);
    }

    @SuppressWarnings("unchecked")
    public static <T> T[] getArray(Map<String,Object> jsonObject, String fieldName,Class<T> clazz){
        return jsonObject.get(fieldName)==null ? null : (T[])jsonObject.get(fieldName);
    }
}

二、测试

		UserList info = new UserList();
    	info.setUuid(java.util.UUID.randomUUID().toString());
    	info.setAge(100);
    	
    	User user1 = new User();
    	user1.setUser("liu");
    	user1.setAge(40);
    	user1.setCurrentTime(LocalDateTime.now());
    	user1.setDateTime(new Date());
    	
    	User user2 = new User();
    	user2.setUser("he");
    	user2.setAge(35);
    	user2.setCurrentTime(LocalDateTime.now());
    	user2.setDateTime(new Date());
    	
    	List<User> list1 = new ArrayList<User>();
    	list1.add(user1);
    	list1.add(user2);
    	
    	Set<User> sets = new HashSet<User>();
    	sets.add(user1);
    	
    	info.setSubUsers(list1);
    	info.setSubSets(sets);
    	
    	Map<String,Object> result = new LinkedHashMap<String, Object>();
    	result.put("success", true);
    	result.put("code", 200);
    	result.put("data", info);
    	
    	//{"uuid":"3d74ba34-4042-4f2e-8c09-0d78e4cd51bd","subUsers":[{"user":"liu","age":40,"dateTime":"2022-10-15 21:22:28","currentTime":"2022-10-15 21:22:28"},{"user":"he","age":35,"dateTime":"2022-10-15 21:22:28","currentTime":"2022-10-15 21:22:28"}],"subSets":[{"user":"liu","age":40,"dateTime":"2022-10-15 21:22:28","currentTime":"2022-10-15 21:22:28"}]}
    	//对像转String
    	String jsonStr = JsonUtil.toJSONString(result);
    	System.out.println(jsonStr);
    	
    	//转换成map
    	Map<String,Object> mapInfo = JsonUtil.castToObject(jsonStr);
    	
    	//转换加UserList对像
    	UserList userList = JsonUtil.getValue("data", jsonStr, UserList.class);
    	System.out.println(userList);
    	System.out.println(JsonUtil.getValue("data", jsonStr, Map.class));
    	
    	//获取uuid
    	System.out.println(JsonUtil.getValue("data.uuid", jsonStr, String.class));
    	System.out.println(JsonUtil.getValue("data.uuid", mapInfo, String.class));
    	//获取Integer
    	System.out.println(JsonUtil.getValue("data.age", jsonStr, Integer.class));
    	System.out.println(JsonUtil.getValue("data.age", mapInfo, Integer.class));
    	
    	//获取List
    	List<User> list11 = JsonUtil.getValue("data.subUsers", jsonStr, List.class, User.class);
    	System.out.println("list11:" + list11);
    	System.out.println(JsonUtil.getValue("data.subUsers", jsonStr, new TypeReference<List<User>>(){} ).getClass());
    	System.out.println(JsonUtil.getValue("data.subUsers", mapInfo, new TypeReference<List<User>>(){} ).getClass());
    	System.out.println(JsonUtil.getValue("data.subUsers", mapInfo, List.class ).getClass());
    	
    	//获取set
    	Set<User> set11 = JsonUtil.getValue("data.subSets", jsonStr, Set.class, User.class);
    	System.out.println("set11:" + set11);
    	System.out.println(JsonUtil.getValue("data.subSets", jsonStr, new TypeReference<Set<User>>(){} ).getClass());
    	System.out.println(JsonUtil.getValue("data.subSets", mapInfo, new TypeReference<Set<User>>(){} ).getClass());
    	String setStr = JsonUtil.toJSONString(JsonUtil.getValue("data.subSets", jsonStr, List.class));
    	System.out.println("setStr: " + setStr);
    	System.out.println(JsonUtil.castToObject(setStr, new TypeReference<Set<User>>(){} ));
    	
    	//
    	System.out.println(JsonUtil.toJSONString(list1));
    	List<User> list = JsonUtil.castToObject(JsonUtil.toJSONString(list1),List.class, User.class);
    	System.out.println(list);
    	
    	System.out.println(JsonUtil.getValue("data", jsonStr, UserList.class));
冰之杍
关注
专栏目录
Json字符串与Object、List、Map的互转工具类
10-17
《Json字符串与Object、List、Map的互转工具类详解》 在Java开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，广泛用于数据传输和存储。为了方便地在Java对象和JSON字符串之间进行转换，...
利用jackson库将对象转换为json字符串示例
听海边涛声
09-10 201
利用jackson库将对象转换为json字符串示例
使用Jackson将JSON字符串转换为MAP对象
大金的专栏
07-03 1万+
当我们想将一串JSON格式的字符串转为MAP对象时，可能很多时候会先将字符串转换为JSON对象，然后使用一个for循环语句遍历keyset，将对象元素逐个添加到MAP对象中。其实我们可以用一种更简便的方法，是用Jackson库的ObjectMapper来完成这件事情。import org.codehaus.jackson.map.ObjectMapper;ObjectMapper mapper =
java-JSON 处理工具类（JsonUtils）
最新发布
Flying_Fish_roe的博客
10-03 1118
JsonUtils 是一个处理 JSON 的工具类，提供了一系列静态方法来处理 JSON 数据。该工具类的主要功能有：将 Java 对象转换为 JSON 字符串：提供了一个方法 toJson，可以将一个 Java 对象转换为 JSON 字符串。将 JSON 字符串转换为 Java 对象：提供了一个方法 fromJson，可以将一个 JSON 字符串转换为指定的 Java 对象。
利用Jackson封装常用的JsonUtil工具类
yuhuofei的草屋
08-19 5531
jackson的使用，封装json工具类
JackJson基本使用&工具类
北漂回西安的JAVA老司机，热爱代码，技术卓绝。
01-13 573
【代码】JackJson基本使用&工具类。
JSON string to Map
Matea's Record
12-13 580
JSON string to Map package com.mkyong; import com.fasterxml.jackson.databind.ObjectMapper; import java.io.IOException; import java.util.Map; public class JacksonMapExample1 { public static voi...
03-JSON-JSON数据和Java对象的相互转换（jackson解析器、注解、list、map）
记录java学习日常~
05-25 7848
/ getter 和 setter 方法省略上述代码中，使用 @JsonInclude 注解指定了在序列化过程中只包含非空的属性。})// getter 和 setter 方法省略// 省略属性和方法// 省略属性和方法上述代码中，使用 @JsonTypeInfo 和 @JsonSubTypes 注解定义了一个抽象的 Animal 类，其中 @JsonTypeInfo 注解指定了类型信息的序列化和反序列化规则，而 @JsonSubTypes 注解则用于指定可能的子类类型。
java解析任意层数json字符串的方法
10-26
在处理JSON字符串时，经常会遇到需要解析任意层数的JSON数据结构的情况。这要求解析方法具有足够的灵活性和适应性，能够应对各种复杂的JSON字符串格式。在Java中，常用的JSON解析库是org.json库，它提供了JSONObject...
利用java反射将json字符串转成对象.zip
10-14
在给定的“利用java反射将json字符串转成对象”的主题中，我们将深入探讨如何借助反射机制将JSON字符串转换为Java对象。 首先，我们需要了解JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人...
json字符串转成 Map/List
04-16
在Java中，将JSON字符串转换为Map或List是常见的操作，这在处理服务器返回的数据或者进行数据序列化时非常有用。 JSON字符串的结构主要包括对象（键值对的集合，用花括号{}包围）和数组（有序元素的集合，用方括号...
java中实体类转Json的2种方法
10-20
Jackson是一个开源的Java库，可以将Java对象转换为Json，也可以将Json字符串解析成Java对象。使用Jackson的步骤如下： 1. 需要添加Jackson相关的依赖到项目中。根据内容提供的jar包信息，可以知道本示例使用的是...
Java中JSON字符串和Java对象的互转
热门推荐
weixin_62520626的博客
02-08 3万+
1.JSON数据和Java对象的相互转换 JSON数据和Java对象的相互转换 * JSON解析器： * 常见的解析器：Jsonlib，Gson，fastjson，jackson 1. Java对象转换JSON 1. 使用步骤： 1. 导入jackson的相关jar包 2. 创建Jackson核心对象 ObjectMapper 3. 调用ObjectMapper的相关方法进行转换 ...
Jackson的使用技巧，实现一个JSON字符串转Map的工具
十三月的博客
05-17 540
Jackson是Java编程语言中使用非常广泛的一个用于处理JSON格式数据的库。它提供了快速、灵活、功能丰富的方式来解析和生成JSON数据。
JSON转化的几种的方法
weixin_44229645的博客
09-09 1170
1将字符串转化为 json对象 2将字符串转化为 Map 3将java对象转json字符串
JSON和Java对象的相互转换方法
weixin_68861457的博客
12-11 1732
JSON与Java对象相互转换方法
Json字符串转换为Java对象和应用(使用fastjson工具类)
zhangbeizhen18的博客
07-16 1万+
记录：468 场景：把Json字符串转换为Java对象。Java对象属性包括String、List、Map等类型。
最流行的JSON库---Jackson，详细使用教程，手把手写代码
Tangzx_的博客
03-17 6774
最流行的JSON库---Jackson，详细使用教程，手把手写代码
Jackson - JSON 与 Java 对象的相互转换
你今天真好看呀
05-09 1463
文章目录1. 简述2. 下载 jackson3. POJO对象4. Java 对象转 JSON5. JSON 到 Java 对象 1. 简述 Jackson 提供了将 Java 对象与JSON 相互转换的方法：writeValue()与readValue() mapper.writeValue– Java 对象到 JSON ObjectMapper mapper = new ObjectMapper(); // Java object to JSON file mapper.writeValue(new
json字符串转map集合工具类
05-25
可以使用Java中的Jackson库将JSON字符串转换为Map对象。Jackson是一个高效的、功能强大的JSON处理库，它提供了多种转换JSON和Java对象的方法。 以下是一个使用Jackson库将JSON字符串转换为Map对象的示例代码： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值