json工具类JsonUtils

我就是我 2022-05-10 13:44 255阅读 0赞

package com.ziyun.pop.common.utils;
    
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.utility.DoubleSerializer;
    import com.utility.IntArrayDeserializer;
    import com.ziyun.pop.common.e.BaseEnum;
    import org.apache.commons.beanutils.BeanUtils;
    import org.codehaus.jackson.Version;
    import org.codehaus.jackson.map.DeserializationConfig;
    import org.codehaus.jackson.map.ObjectMapper;
    import org.codehaus.jackson.map.SerializationConfig;
    import org.codehaus.jackson.map.annotate.JsonSerialize;
    import org.codehaus.jackson.map.module.SimpleModule;
    import org.codehaus.jackson.map.type.ArrayType;
    import org.codehaus.jackson.map.type.TypeFactory;
    import org.codehaus.jackson.type.JavaType;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.slf4j.helpers.FormattingTuple;
    import org.slf4j.helpers.MessageFormatter;
    
    import java.beans.BeanInfo;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.io.StringWriter;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.*;
    
    /**
     * json 工具类
     * 
     * @author jiangli
     * @date 2017年11月7日 上午11:28:32
     */
    public class JsonUtils {
    	private JsonUtils() {
    		throw new IllegalAccessError("该类不允许实例化");
    	}
    
    	private static final Logger log = LoggerFactory.getLogger(com.utility.JsonUtils.class);
    
    	private static final ObjectMapper mapper;
    
    	private static final ObjectMapper ignoreNullMapper;
    
    	static {
    		mapper = new ObjectMapper();
    		mapper.enable(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
    		SimpleModule module = new SimpleModule("Custom", new Version(1, 0, 0, null));
    		module.addDeserializer(int[].class, new IntArrayDeserializer());
    		module.addSerializer(Double.class, DoubleSerializer.INSTANCE);
    		module.addSerializer(Double.TYPE, DoubleSerializer.INSTANCE);
    		mapper.registerModule(module);
    
    		ignoreNullMapper = new ObjectMapper();
    		ignoreNullMapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);
    		ignoreNullMapper.configure(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES, false);
    
    		ignoreNullMapper.enable(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
    		SimpleModule moduleNull = new SimpleModule("Custom", new Version(1, 0, 0, null));
    		moduleNull.addDeserializer(int[].class, new IntArrayDeserializer());
    		moduleNull.addSerializer(Double.class, DoubleSerializer.INSTANCE);
    		moduleNull.addSerializer(Double.TYPE, DoubleSerializer.INSTANCE);
    		ignoreNullMapper.registerModule(moduleNull);
    
    	}
    
    	/**
    	 * 将对象转换为 JSON 的字符串格式
    	 *
    	 * @param object
    	 * @return
    	 */
    	public static String object2String(Object object) {
    		return object2String(object, false);
    	}
    
    	public static String object2String(Object object, boolean prettyFormat) {
    		StringWriter writer = new StringWriter();
    		try {
    			if (prettyFormat) {
    				mapper.writerWithDefaultPrettyPrinter().writeValue(writer, object);
    			} else {
    				mapper.writeValue(writer, object);
    			}
    		} catch (Exception e) {
    			log.error("将 object 转换为 json 字符串时发生异常:{}", e);
    			return null;
    		}
    		return writer.toString();
    	}
    
    	public static String object2StringIgnoreNullField(Object object) {
    		return object2StringIgnoreNullField(object, false);
    	}
    
    	public static String object2StringIgnoreNullField(Object object, boolean prettyFormat) {
    		StringWriter writer = new StringWriter();
    		try {
    			if (prettyFormat) {
    				ignoreNullMapper.writerWithDefaultPrettyPrinter().writeValue(writer, object);
    			} else {
    				ignoreNullMapper.writeValue(writer, object);
    			}
    		} catch (Exception e) {
    			log.error("将 object 转换为 json 字符串时发生异常:{}", e);
    			return null;
    		}
    		return writer.toString();
    	}
    
    	/**
    	 * 将 map 转换为 JSON 的字符串格式
    	 *
    	 * @param map
    	 * @return
    	 */
    	public static String map2String(Map<?, ?> map) {
    		StringWriter writer = new StringWriter();
    		try {
    			mapper.writeValue(writer, map);
    		} catch (Exception e) {
    			log.error("将 map 转换为 json 字符串时发生异常:{}", e);
    			return null;
    		}
    		return writer.toString();
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为 map
    	 *
    	 * @param content
    	 * @return
    	 */
    	public static Map<String, Object> string2Map(String content) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, String.class, Object.class);
    		// JavaType type = TypeFactory.mapType(HashMap.class, String.class,
    		// Object.class);
    		try {
    			return mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为 map
    	 *
    	 * @param content
    	 * @return
    	 */
    	public static Map<String, Integer[]> string2MapInts(String content) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, String.class, Integer[].class);
    		// JavaType type = TypeFactory.mapType(HashMap.class, String.class,
    		// Object.class);
    		try {
    			return mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为 map
    	 *
    	 * @param content
    	 * @return
    	 */
    	public static Map<String, String> string2MapString(String content) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, String.class, String.class);
    		// JavaType type = TypeFactory.mapType(HashMap.class, String.class,
    		// Object.class);
    		try {
    			return mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为数组
    	 *
    	 * @param <T>
    	 * @param content
    	 *            字符串
    	 * @param clz
    	 *            数组类型
    	 * @return
    	 */
    	@SuppressWarnings("unchecked")
    	public static <T> T[] string2Array(String content, Class<T> clz) {
    		JavaType type = ArrayType.construct(TypeFactory.defaultInstance().constructType(clz), null, null);
    		try {
    			return (T[]) mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为数组时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为对象
    	 *
    	 * @param <T>
    	 * @param content
    	 *            字符串
    	 * @param clz
    	 *            对象类型
    	 * @return
    	 */
    	public static <T> T string2Object(String content, Class<T> clz) {
    		JavaType type = TypeFactory.defaultInstance().constructType(clz);
    		return string2Object(content, type);
    	}
    
    	@SuppressWarnings("unchecked")
    	public static <T> T string2Object(String content, JavaType type) {
    		try {
    			return (T) mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为对象[{}]时出现异常",
    					new Object[] { content, type, e });
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 将 JSON 格式的字符串转换为集合
    	 *
    	 * @param <T>
    	 * @param content
    	 *            字符串
    	 * @param collectionType
    	 *            集合类型
    	 * @param elementType
    	 *            元素类型
    	 * @return
    	 */
    	public static <C extends Collection<E>, E> C string2Collection(String content, Class<C> collectionType,
    																   Class<E> elementType) {
    		try {
    			JavaType type = TypeFactory.defaultInstance().constructCollectionType(collectionType, elementType);
    			// JavaType type = TypeFactory.collectionType(collectionType,
    			// elementType);
    			return mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为集合[{}]时出现异常",
    					new Object[] { content, collectionType.getSimpleName(), e });
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	@SuppressWarnings("unchecked")
    	public static <K, V> Map<K, V> string2Map(String content, Class<K> keyType, Class<V> valueType) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, keyType, valueType);
    		try {
    			return (Map<K, V>) mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	@SuppressWarnings("unchecked")
    	public static <K, V> Map<K, V> string2LinkedHashMap(String content, Class<K> keyType, Class<V> valueType) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(LinkedHashMap.class, keyType, valueType);
    		try {
    			return (Map<K, V>) mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    	public static Map<?, ?> string2Map(String content, JavaType keyType, JavaType valueType) {
    		JavaType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, keyType, valueType);
    		try {
    			return (Map<?, ?>) mapper.readValue(content, type);
    		} catch (Exception e) {
    			FormattingTuple message = MessageFormatter.format("将字符串[{}]转换为Map时出现异常", content);
    			log.error(message.getMessage(), e);
    			throw new RuntimeException(message.getMessage(), e);
    		}
    	}
    
    
    
    
    
    
    
    
    	/**
    	 * 将一个JSON数据转换为对应的JAVA对象<br/>
    	 * JSON数据中键的名称必须和对应JAVA对象中bean字段的名称一致<br/>
    	 * 
    	 * @param <T>
    	 *            java对象值
    	 * @param jsonString
    	 *            JSON 对象字符
    	 * @param cls
    	 *            对象class *
    	 * @return 返回java对象
    	 */
    	public static <T> T getJsonToObject(String jsonString, Class<T> cls) {
    		return JSONObject.parseObject(jsonString, cls);
    	}
    
    	/**
    	 * 从json HASH表达式中获取一个map，改map支持嵌套功能
    	 * 
    	 * @param jsonString
    	 *            json HASH表达式
    	 * @return 返回map数组
    	 */
    	public static Map<String, Object> jsonToMap(String jsonString) {
    		JSONObject jsonObject = JSONObject.parseObject(jsonString);
    		Iterator<String> keyIter = jsonObject.keySet().iterator();
    		String key;
    		Object value;
    		Map<String, Object> valueMap = new HashMap<String, Object>();
    
    		while (keyIter.hasNext()) {
    			key = (String) keyIter.next();
    			value = jsonObject.get(key);
    			valueMap.put(key, value);
    		}
    
    		return valueMap;
    	}
    
    	/**
    	 * 从json HASH表达式中获取一个map，改map支持嵌套功能
    	 * @param jsonString json HASH表达式
    	 * @return 返回map数组 Map<String, Object>
    	 */
    	public static Map<String, String> getMapJsonToStr(String jsonString) {
    		JSONObject jsonObject = JSONObject.parseObject(jsonString);
    		Iterator<String> keyIter = jsonObject.keySet().iterator();
    		String key;
    		String value;
    		Map<String, String> valueMap = new HashMap<String, String>();
    
    		while (keyIter.hasNext()) {
    			key = (String) keyIter.next();
    			value = jsonObject.get(key).toString();
    			valueMap.put(key, value);
    		}
    
    		return valueMap;
    	}
    	
    	/**
    	 * 从json HASH表达式中获取一个map，改map支持嵌套功能
    	 * @param jsonString json HASH表达式
    	 * @return 返回map数组  Map<String, Object>
    	 */
    	public static Map<String, Object> getMapJsonWishStr(String jsonString) {
    		JSONObject jsonObject = JSONObject.parseObject(jsonString);
    		Iterator<String> keyIter = jsonObject.keySet().iterator();
    		String key;
    		String value;
    		Map<String, Object> valueMap = new HashMap<String, Object>();
    
    		while (keyIter.hasNext()) {
    			key = (String) keyIter.next();
    			value = jsonObject.get(key).toString();
    			valueMap.put(key, value);
    		}
    
    		return valueMap;
    	}
    
    	/**
    	 * 从json对象集合表达式中得到一个java对象集合<br/>
    	 * JSON数据中键的名称必须和对应JAVA对象中bean字段的名称一致<br/>
    	 * @param jsonString json字符串
    	 * @param cls	JAVA Bean对象
    	 * @return JAVA bean对象集合list
    	 */
    	public static List<?> queryJsonToList(String jsonString, Class<?> cls) {
    		List<?> list = JSONArray.parseArray(jsonString, cls);
    		return list;
    	}
    	
    
    	/**
    	 * 枚举转list
    	 * 
    	 * @param cls
    	 *            实现了BaseEnum的子类
    	 * @return 转换失败返回null
    	 */
    	@SuppressWarnings("rawtypes")
    	public static List<Map<String, Object>> enumToList(Class cls) {
    		List<Map<String, Object>> list = null;
    		if (cls != null) {
    			list = new ArrayList<Map<String, Object>>();
    			try {
    				Method method = cls.getDeclaredMethod("values");
    				BaseEnum[] be = (BaseEnum[]) method.invoke(cls);
    
    				for (BaseEnum e : be) {
    					Map<String, Object> map = new HashMap<String, Object>();
    					map.put("id", e.toInt());
    					map.put("value", e.toCode());
    					map.put("describe", e.toDescribe());
    					list.add(map);
    				}
    			} catch (Exception e) {
    				return null;
    			}
    		}
    		return list;
    
    	}
    
    	// Bean --> Map 1: 利用Introspector和PropertyDescriptor 将Bean --> Map
    	public static Map<String, Object> transBean2Map(Object obj) {
    
    		if(obj == null){
    			return null;
    		}
    		Map<String, Object> map = new HashMap<String, Object>();
    		try {
    			BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
    			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    			for (PropertyDescriptor property : propertyDescriptors) {
    				String key = property.getName();
    				// 过滤class属性
    				if (!key.equals("class")) {
    					// 得到property对应的getter方法
    					Method getter = property.getReadMethod();
    					Object value = getter.invoke(obj);
    					if (value !=null){
    						map.put(key, value);
    					}
    				}
    
    			}
    		} catch (Exception e) {
    			System.out.println("transBean2Map Error " + e);
    		}
    
    		return map;
    
    	}
    
    	/**
    	 *
    	 *
    	 * Map转换层Bean，使用泛型免去了类型转换的麻烦。
    	 * @param <T>
    	 * @param map
    	 * @param class1
    	 * @return
    	 */
    	public static <T> T map2Bean(Map<String, String> map, Class<T> class1) {
    		T bean = null;
    		try {
    			bean = class1.newInstance();
    			BeanUtils.populate(bean, map);
    		} catch (InstantiationException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		} catch (InvocationTargetException e) {
    			e.printStackTrace();
    		}
    		return bean;
    	}
    
    	/* 将Map转换为对象
    	* @param paramMap
    	* @param cls
    	* @return
    	*/
    	public static <T> T parseMap2Object(Map<String, Object> paramMap, Class<T> cls) {
    		return JSONObject.parseObject(JSONObject.toJSONString(paramMap), cls);
    	}
    }