JAVA开发（byte和string转换类型的坑）

雨点打透心脏的1/2处 2024-03-26 14:45 35阅读 0赞

背景：

最近真实遇到的问题，所以在此做个总结。byte和string转换类型的坑。因为我要把数据缓存到redis，所以不得不将byte类型数据先转换成string。然后获取数据的时候，又将string类型数据转换成byte。

网上给我的参考：

![0e5f04f9f62a4d78970bc50b2c142ab2.png][]

这里的坑就在于编码的问题。

上面这个指定的是UTF-8的编码。但是转换却是有问题的，出来的结果不一致。

解决方案：

编码使用：ISO-8859-1

![6a8459d3955e4dc4840bbc2c3343c7da.png][]

// 为了保证性能，先从缓存中取，设置2小时有效期
 		String keyId = param.get("scene").toString();
 		Base64.Encoder encoder = Base64.getMimeEncoder();
 		if (!StringUtils.isEmpty(keyId)) {
 			String strCache = memberCacheService.wxacodeunCache(keyId);
 			if (!StringUtils.isEmpty(strCache)) {
 				byte[] bytes = strCache.getBytes(StandardCharsets.ISO_8859_1);
 				return bytes;
 			}
 		}
 
 		Map<String, Object> map = getQRToken();
 		// 后端服务获取的access_token
 		String accessToken = map.get("access_token").toString();
 		log.info("获取到的微信服务端：accessToken：" + accessToken);
 		log.info("获取微信二维码请求参数param：" + JSON.toJSONString(param));
 		byte[] resbyte = wxClient.getwxacodeunlimit(accessToken, param);
 	
 		encoder.encodeToString(resbyte);
 		//log.info("获取微信二维码 str：" + str);
 	 
 		try {
 			if (!StringUtils.isEmpty(keyId)) {
 				log.info("当前分享推荐码用户userId：" + keyId);
 				memberCacheService.wxacodeunCahe(keyId, new String(resbyte,StandardCharsets.ISO_8859_1));
 			}
 		} catch (Exception e) {
 			log.info("获取微信二维码字节码异常：" + e.getMessage() );
 		}
 		 
 		
 		return resbyte;

返回结果样例：

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

我们可以通过工具进行解码渲染成图片：

![fb11f6f25b56433f8b599cf3ff47e4b0.png][]

二、java中对象和JSON之间的转换

使用JSONUtil工具类：该类在cn.hutool.json下

package cn.hutool.json;
 
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.file.FileReader;
 import cn.hutool.core.lang.TypeReference;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.ClassUtil;
 import cn.hutool.core.util.HexUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.core.util.TypeUtil;
 import cn.hutool.json.serialize.GlobalSerializeMapping;
 import cn.hutool.json.serialize.JSONArraySerializer;
 import cn.hutool.json.serialize.JSONDeserializer;
 import cn.hutool.json.serialize.JSONObjectSerializer;
 import cn.hutool.json.serialize.JSONSerializer;
 
 import java.io.File;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.lang.reflect.Type;
 import java.nio.charset.Charset;
 import java.sql.SQLException;
 import java.time.temporal.TemporalAccessor;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 /**
 * JSON工具类
 *
 * @author Looly
 */
 public class JSONUtil {
 
 	// -------------------------------------------------------------------- Pause start
 
 	/**
 	 * 创建JSONObject
 	 *
 	 * @return JSONObject
 	 */
 	public static JSONObject createObj() {
 		return new JSONObject();
 	}
 
 	/**
 	 * 创建JSONObject
 	 *
 	 * @param config JSON配置
 	 * @return JSONObject
 	 * @since 5.2.5
 	 */
 	public static JSONObject createObj(JSONConfig config) {
 		return new JSONObject(config);
 	}
 
 	/**
 	 * 创建 JSONArray
 	 *
 	 * @return JSONArray
 	 */
 	public static JSONArray createArray() {
 		return new JSONArray();
 	}
 
 	/**
 	 * 创建 JSONArray
 	 *
 	 * @param config JSON配置
 	 * @return JSONArray
 	 * @since 5.2.5
 	 */
 	public static JSONArray createArray(JSONConfig config) {
 		return new JSONArray(config);
 	}
 
 	/**
 	 * JSON字符串转JSONObject对象
 	 *
 	 * @param jsonStr JSON字符串
 	 * @return JSONObject
 	 */
 	public static JSONObject parseObj(String jsonStr) {
 		return new JSONObject(jsonStr);
 	}
 
 	/**
 	 * JSON字符串转JSONObject对象 
 	 * 此方法会忽略空值，但是对JSON字符串不影响
 	 *
 	 * @param obj Bean对象或者Map
 	 * @return JSONObject
 	 */
 	public static JSONObject parseObj(Object obj) {
 		return new JSONObject(obj);
 	}
 
 	/**
 	 * JSON字符串转JSONObject对象 
 	 * 此方法会忽略空值，但是对JSON字符串不影响
 	 *
 	 * @param obj Bean对象或者Map
 	 * @param config JSON配置
 	 * @return JSONObject
 	 * @since 5.3.1
 	 */
 	public static JSONObject parseObj(Object obj, JSONConfig config) {
 		return new JSONObject(obj, config);
 	}
 
 	/**
 	 * JSON字符串转JSONObject对象
 	 *
 	 * @param obj Bean对象或者Map
 	 * @param ignoreNullValue 是否忽略空值，如果source为JSON字符串，不忽略空值
 	 * @return JSONObject
 	 * @since 3.0.9
 	 */
 	public static JSONObject parseObj(Object obj, boolean ignoreNullValue) {
 		return new JSONObject(obj, ignoreNullValue);
 	}
 
 	/**
 	 * JSON字符串转JSONObject对象
 	 *
 	 * @param obj Bean对象或者Map
 	 * @param ignoreNullValue 是否忽略空值，如果source为JSON字符串，不忽略空值
 	 * @param isOrder 是否有序
 	 * @return JSONObject
 	 * @since 4.2.2
 	 */
 	public static JSONObject parseObj(Object obj, boolean ignoreNullValue, boolean isOrder) {
 		return new JSONObject(obj, ignoreNullValue, isOrder);
 	}
 
 	/**
 	 * JSON字符串转JSONArray
 	 *
 	 * @param jsonStr JSON字符串
 	 * @return JSONArray
 	 */
 	public static JSONArray parseArray(String jsonStr) {
 		return new JSONArray(jsonStr);
 	}
 
 	/**
 	 * JSON字符串转JSONArray
 	 *
 	 * @param arrayOrCollection 数组或集合对象
 	 * @return JSONArray
 	 * @since 3.0.8
 	 */
 	public static JSONArray parseArray(Object arrayOrCollection) {
 		return new JSONArray(arrayOrCollection);
 	}
 
 	/**
 	 * JSON字符串转JSONArray
 	 *
 	 * @param arrayOrCollection 数组或集合对象
 	 * @param config JSON配置
 	 * @return JSONArray
 	 * @since 5.3.1
 	 */
 	public static JSONArray parseArray(Object arrayOrCollection, JSONConfig config) {
 		return new JSONArray(arrayOrCollection, config);
 	}
 
 	/**
 	 * JSON字符串转JSONArray
 	 *
 	 * @param arrayOrCollection 数组或集合对象
 	 * @param ignoreNullValue 是否忽略空值
 	 * @return JSONArray
 	 * @since 3.2.3
 	 */
 	public static JSONArray parseArray(Object arrayOrCollection, boolean ignoreNullValue) {
 		return new JSONArray(arrayOrCollection, ignoreNullValue);
 	}
 
 	/**
 	 * 转换对象为JSON 
 	 * 支持的对象： 
 	 * String: 转换为相应的对象 
 	 * Array Collection：转换为JSONArray 
 	 * Bean对象：转为JSONObject
 	 *
 	 * @param obj 对象
 	 * @return JSON
 	 */
 	public static JSON parse(Object obj) {
 		if(obj instanceof JSON){
 			return (JSON) obj;
 		}
 
 		final JSONConfig config = JSONConfig.create();
 		if(InternalJSONUtil.isOrder(obj)){
 			config.setOrder(true);
 		}
 		return parse(obj, config);
 	}
 
 	/**
 	 * 转换对象为JSON 
 	 * 支持的对象： 
 	 * String: 转换为相应的对象 
 	 * Array、Iterable、Iterator：转换为JSONArray 
 	 * Bean对象：转为JSONObject
 	 *
 	 * @param obj 对象
 	 * @param config JSON配置
 	 * @return JSON
 	 * @since 5.3.1
 	 */
 	public static JSON parse(Object obj, JSONConfig config) {
 		if (null == obj) {
 			return null;
 		}
 
 		JSON json;
 		if (obj instanceof JSON) {
 			json = (JSON) obj;
 		} else if (obj instanceof CharSequence) {
 			final String jsonStr = StrUtil.trim((CharSequence) obj);
 			json = isJsonArray(jsonStr) ? parseArray(jsonStr, config) : parseObj(jsonStr, config);
 		} else if (obj instanceof Iterable || obj instanceof Iterator || ArrayUtil.isArray(obj)) {// 列表
 			json = new JSONArray(obj, config);
 		} else {// 对象
 			json = new JSONObject(obj, config);
 		}
 
 		return json;
 	}
 
 	/**
 	 * XML字符串转为JSONObject
 	 *
 	 * @param xmlStr XML字符串
 	 * @return JSONObject
 	 */
 	public static JSONObject parseFromXml(String xmlStr) {
 		return XML.toJSONObject(xmlStr);
 	}
 
 	// -------------------------------------------------------------------- Pause end
 
 	// -------------------------------------------------------------------- Read start
 
 	/**
 	 * 读取JSON
 	 *
 	 * @param file JSON文件
 	 * @param charset 编码
 	 * @return JSON（包括JSONObject和JSONArray）
 	 * @throws IORuntimeException IO异常
 	 */
 	public static JSON readJSON(File file, Charset charset) throws IORuntimeException {
 		return parse(FileReader.create(file, charset).readString());
 	}
 
 	/**
 	 * 读取JSONObject
 	 *
 	 * @param file JSON文件
 	 * @param charset 编码
 	 * @return JSONObject
 	 * @throws IORuntimeException IO异常
 	 */
 	public static JSONObject readJSONObject(File file, Charset charset) throws IORuntimeException {
 		return parseObj(FileReader.create(file, charset).readString());
 	}
 
 	/**
 	 * 读取JSONArray
 	 *
 	 * @param file JSON文件
 	 * @param charset 编码
 	 * @return JSONArray
 	 * @throws IORuntimeException IO异常
 	 */
 	public static JSONArray readJSONArray(File file, Charset charset) throws IORuntimeException {
 		return parseArray(FileReader.create(file, charset).readString());
 	}
 	// -------------------------------------------------------------------- Read end
 
 	// -------------------------------------------------------------------- toString start
 
 	/**
 	 * 转为JSON字符串
 	 *
 	 * @param json JSON
 	 * @param indentFactor 每一级别的缩进
 	 * @return JSON字符串
 	 */
 	public static String toJsonStr(JSON json, int indentFactor) {
 		if (null == json) {
 			return null;
 		}
 		return json.toJSONString(indentFactor);
 	}
 
 	/**
 	 * 转为JSON字符串
 	 *
 	 * @param json JSON
 	 * @return JSON字符串
 	 */
 	public static String toJsonStr(JSON json) {
 		if (null == json) {
 			return null;
 		}
 		return json.toJSONString(0);
 	}
 
 	/**
 	 * 转为JSON字符串，并写出到write
 	 *
 	 * @param json JSON
 	 * @param writer Writer
 	 * @since 5.3.3
 	 */
 	public static void toJsonStr(JSON json, Writer writer) {
 		if (null != json) {
 			json.write(writer);
 		}
 	}
 
 	/**
 	 * 转为JSON字符串
 	 *
 	 * @param json JSON
 	 * @return JSON字符串
 	 */
 	public static String toJsonPrettyStr(JSON json) {
 		if (null == json) {
 			return null;
 		}
 		return json.toJSONString(4);
 	}
 
 	/**
 	 * 转换为JSON字符串
 	 *
 	 * @param obj 被转为JSON的对象
 	 * @return JSON字符串
 	 */
 	public static String toJsonStr(Object obj) {
 		if (null == obj) {
 			return null;
 		}
 		if (obj instanceof CharSequence) {
 			return StrUtil.str((CharSequence) obj);
 		}
 		return toJsonStr(parse(obj));
 	}
 
 	/**
 	 * 转换为JSON字符串并写出到writer
 	 *
 	 * @param obj 被转为JSON的对象
 	 * @param writer Writer
 	 * @since 5.3.3
 	 */
 	public static void toJsonStr(Object obj, Writer writer) {
 		if (null != obj) {
 			toJsonStr(parse(obj), writer);
 		}
 	}
 
 	/**
 	 * 转换为格式化后的JSON字符串
 	 *
 	 * @param obj Bean对象
 	 * @return JSON字符串
 	 */
 	public static String toJsonPrettyStr(Object obj) {
 		return toJsonPrettyStr(parse(obj));
 	}
 
 	/**
 	 * 转换为XML字符串
 	 *
 	 * @param json JSON
 	 * @return XML字符串
 	 */
 	public static String toXmlStr(JSON json) {
 		return XML.toXml(json);
 	}
 	// -------------------------------------------------------------------- toString end
 
 	// -------------------------------------------------------------------- toBean start
 
 	/**
 	 * JSON字符串转为实体类对象，转换异常将被抛出
 	 *
 	 * @param <T> Bean类型
 	 * @param jsonString JSON字符串
 	 * @param beanClass 实体类对象
 	 * @return 实体类对象
 	 * @since 3.1.2
 	 */
 	public static <T> T toBean(String jsonString, Class<T> beanClass) {
 		return toBean(parseObj(jsonString), beanClass);
 	}
 
 	/**
 	 * 转为实体类对象，转换异常将被抛出
 	 *
 	 * @param <T> Bean类型
 	 * @param json JSONObject
 	 * @param beanClass 实体类对象
 	 * @return 实体类对象
 	 */
 	public static <T> T toBean(JSONObject json, Class<T> beanClass) {
 		return null == json ? null : json.toBean(beanClass);
 	}
 
 	/**
 	 * JSON字符串转为实体类对象，转换异常将被抛出
 	 *
 	 * @param <T> Bean类型
 	 * @param jsonString JSON字符串
 	 * @param typeReference {@link TypeReference}类型参考子类，可以获取其泛型参数中的Type类型
 	 * @param ignoreError 是否忽略错误
 	 * @return 实体类对象
 	 * @since 4.3.2
 	 */
 	public static <T> T toBean(String jsonString, TypeReference<T> typeReference, boolean ignoreError) {
 		return toBean(jsonString, typeReference.getType(), ignoreError);
 	}
 
 	/**
 	 * JSON字符串转为实体类对象，转换异常将被抛出
 	 *
 	 * @param <T> Bean类型
 	 * @param jsonString JSON字符串
 	 * @param beanType 实体类对象类型
 	 * @param ignoreError 是否忽略错误
 	 * @return 实体类对象
 	 * @since 4.3.2
 	 */
 	public static <T> T toBean(String jsonString, Type beanType, boolean ignoreError) {
 		return toBean(parse(jsonString), beanType, ignoreError);
 	}
 
 	/**
 	 * 转为实体类对象
 	 *
 	 * @param <T> Bean类型
 	 * @param json JSONObject
 	 * @param typeReference {@link TypeReference}类型参考子类，可以获取其泛型参数中的Type类型
 	 * @param ignoreError 是否忽略转换错误
 	 * @return 实体类对象
 	 * @since 4.6.2
 	 */
 	public static <T> T toBean(JSON json, TypeReference<T> typeReference, boolean ignoreError) {
 		return toBean(json, typeReference.getType(), ignoreError);
 	}
 
 	/**
 	 * 转为实体类对象
 	 *
 	 * @param <T> Bean类型
 	 * @param json JSONObject
 	 * @param beanType 实体类对象类型
 	 * @param ignoreError 是否忽略转换错误
 	 * @return 实体类对象
 	 * @since 4.3.2
 	 */
 	public static <T> T toBean(JSON json, Type beanType, boolean ignoreError) {
 		if (null == json) {
 			return null;
 		}
 		return json.toBean(beanType, ignoreError);
 	}
 	// -------------------------------------------------------------------- toBean end
 
 	/**
 	 * 将JSONArray字符串转换为Bean的List，默认为ArrayList
 	 *
 	 * @param <T> Bean类型
 	 * @param jsonArray JSONArray字符串
 	 * @param elementType List中元素类型
 	 * @return List
 	 * @since 5.5.2
 	 */
 	public static <T> List<T> toList(String jsonArray, Class<T> elementType) {
 		return toList(parseArray(jsonArray), elementType);
 	}
 
 	/**
 	 * 将JSONArray转换为Bean的List，默认为ArrayList
 	 *
 	 * @param <T> Bean类型
 	 * @param jsonArray {@link JSONArray}
 	 * @param elementType List中元素类型
 	 * @return List
 	 * @since 4.0.7
 	 */
 	public static <T> List<T> toList(JSONArray jsonArray, Class<T> elementType) {
 		return null == jsonArray ? null : jsonArray.toList(elementType);
 	}
 
 	/**
 	 * 通过表达式获取JSON中嵌套的对象 
 	 * <ol>
 	 * <li>.表达式，可以获取Bean对象中的属性（字段）值或者Map中key对应的值</li>
 	 * <li>[]表达式，可以获取集合等对象中对应index的值</li>
 	 * </ol>
 	 * 
 	 * 表达式栗子：
 	 *
 	 * <pre>
 	 * persion
 	 * persion.name
 	 * persons[3]
 	 * person.friends[5].name
 	 * </pre>
 	 *
 	 * @param json {@link JSON}
 	 * @param expression 表达式
 	 * @return 对象
 	 * @see JSON#getByPath(String)
 	 */
 	public static Object getByPath(JSON json, String expression) {
 		return getByPath(json, expression, null);
 	}
 
 	/**
 	 * 通过表达式获取JSON中嵌套的对象 
 	 * <ol>
 	 * <li>.表达式，可以获取Bean对象中的属性（字段）值或者Map中key对应的值</li>
 	 * <li>[]表达式，可以获取集合等对象中对应index的值</li>
 	 * </ol>
 	 * 
 	 * 表达式栗子：
 	 *
 	 * <pre>
 	 * persion
 	 * persion.name
 	 * persons[3]
 	 * person.friends[5].name
 	 * </pre>
 	 *
 	 * @param <T> 值类型
 	 * @param json {@link JSON}
 	 * @param expression 表达式
 	 * @param defaultValue 默认值
 	 * @return 对象
 	 * @see JSON#getByPath(String)
 	 * @since 5.6.0
 	 */
 	@SuppressWarnings("unchecked")
 	public static <T> T getByPath(JSON json, String expression, T defaultValue) {
 		if((null == json || StrUtil.isBlank(expression))){
 			return defaultValue;
 		}
 
 		if(null != defaultValue){
 			final Class<T> type = (Class<T>) defaultValue.getClass();
 			return ObjectUtil.defaultIfNull(json.getByPath(expression, type), defaultValue);
 		}
 		return (T) json.getByPath(expression);
 	}
 
 	/**
 	 * 设置表达式指定位置（或filed对应）的值 
 	 * 若表达式指向一个JSONArray则设置其坐标对应位置的值，若指向JSONObject则put对应key的值 
 	 * 注意：如果为JSONArray，则设置值得下标不能大于已有JSONArray的长度 
 	 * <ol>
 	 * <li>.表达式，可以获取Bean对象中的属性（字段）值或者Map中key对应的值</li>
 	 * <li>[]表达式，可以获取集合等对象中对应index的值</li>
 	 * </ol>
 	 * 
 	 * 表达式栗子：
 	 *
 	 * <pre>
 	 * persion
 	 * persion.name
 	 * persons[3]
 	 * person.friends[5].name
 	 * </pre>
 	 *
 	 * @param json JSON，可以为JSONObject或JSONArray
 	 * @param expression 表达式
 	 * @param value 值
 	 */
 	public static void putByPath(JSON json, String expression, Object value) {
 		json.putByPath(expression, value);
 	}
 
 	/**
 	 * 对所有双引号做转义处理（使用双反斜杠做转义） 
 	 * 为了能在HTML中较好的显示，会将</转义为<\/ 
 	 * JSON字符串中不能包含控制字符和未经转义的引号和反斜杠
 	 *
 	 * @param string 字符串
 	 * @return 适合在JSON中显示的字符串
 	 */
 	public static String quote(String string) {
 		return quote(string, true);
 	}
 
 	/**
 	 * 对所有双引号做转义处理（使用双反斜杠做转义） 
 	 * 为了能在HTML中较好的显示，会将</转义为<\/ 
 	 * JSON字符串中不能包含控制字符和未经转义的引号和反斜杠
 	 *
 	 * @param string 字符串
 	 * @param isWrap 是否使用双引号包装字符串
 	 * @return 适合在JSON中显示的字符串
 	 * @since 3.3.1
 	 */
 	public static String quote(String string, boolean isWrap) {
 		StringWriter sw = new StringWriter();
 		try {
 			return quote(string, sw, isWrap).toString();
 		} catch (IOException ignored) {
 			// will never happen - we are writing to a string writer
 			return StrUtil.EMPTY;
 		}
 	}
 
 	/**
 	 * 对所有双引号做转义处理（使用双反斜杠做转义） 
 	 * 为了能在HTML中较好的显示，会将</转义为<\/ 
 	 * JSON字符串中不能包含控制字符和未经转义的引号和反斜杠
 	 *
 	 * @param str 字符串
 	 * @param writer Writer
 	 * @return Writer
 	 * @throws IOException IO异常
 	 */
 	public static Writer quote(String str, Writer writer) throws IOException {
 		return quote(str, writer, true);
 	}
 
 	/**
 	 * 对所有双引号做转义处理（使用双反斜杠做转义） 
 	 * 为了能在HTML中较好的显示，会将</转义为<\/ 
 	 * JSON字符串中不能包含控制字符和未经转义的引号和反斜杠
 	 *
 	 * @param str 字符串
 	 * @param writer Writer
 	 * @param isWrap 是否使用双引号包装字符串
 	 * @return Writer
 	 * @throws IOException IO异常
 	 * @since 3.3.1
 	 */
 	public static Writer quote(String str, Writer writer, boolean isWrap) throws IOException {
 		if (StrUtil.isEmpty(str)) {
 			if (isWrap) {
 				writer.write("\"\"");
 			}
 			return writer;
 		}
 
 		char c; // 当前字符
 		int len = str.length();
 		if (isWrap) {
 			writer.write('"');
 		}
 		for (int i = 0; i < len; i++) {
 			c = str.charAt(i);
 			switch (c) {
 				case '\\':
 				case '"':
 					writer.write("\\");
 					writer.write(c);
 					break;
 				default:
 					writer.write(escape(c));
 			}
 		}
 		if (isWrap) {
 			writer.write('"');
 		}
 		return writer;
 	}
 
 	/**
 	 * 转义显示不可见字符
 	 *
 	 * @param str 字符串
 	 * @return 转义后的字符串
 	 */
 	public static String escape(String str) {
 		if (StrUtil.isEmpty(str)) {
 			return str;
 		}
 
 		final int len = str.length();
 		final StringBuilder builder = new StringBuilder(len);
 		char c;
 		for (int i = 0; i < len; i++) {
 			c = str.charAt(i);
 			builder.append(escape(c));
 		}
 		return builder.toString();
 	}
 
 	/**
 	 * 在需要的时候包装对象 
 	 * 包装包括：
 	 * <ul>
 	 * <li>{@code null} =》 {@code JSONNull.NULL}</li>
 	 * <li>array or collection =》 JSONArray</li>
 	 * <li>map =》 JSONObject</li>
 	 * <li>standard property (Double, String, et al) =》 原对象</li>
 	 * <li>来自于java包 =》 字符串</li>
 	 * <li>其它 =》 尝试包装为JSONObject，否则返回{@code null}</li>
 	 * </ul>
 	 *
 	 * @param object 被包装的对象
 	 * @param jsonConfig JSON选项
 	 * @return 包装后的值，null表示此值需被忽略
 	 */
 	@SuppressWarnings({"rawtypes", "unchecked"})
 	public static Object wrap(Object object, JSONConfig jsonConfig) {
 		if (object == null) {
 			return jsonConfig.isIgnoreNullValue() ? null : JSONNull.NULL;
 		}
 		if (object instanceof JSON //
 				|| JSONNull.NULL.equals(object) //
 				|| object instanceof JSONString //
 				|| object instanceof CharSequence //
 				|| object instanceof Number //
 				|| ObjectUtil.isBasicType(object) //
 		) {
 			return object;
 		}
 
 		// 自定义序列化
 		final JSONSerializer serializer = GlobalSerializeMapping.getSerializer(object.getClass());
 		if (null != serializer) {
 			final Type jsonType = TypeUtil.getTypeArgument(serializer.getClass());
 			if (null != jsonType) {
 				if (serializer instanceof JSONObjectSerializer) {
 					serializer.serialize(new JSONObject(jsonConfig), object);
 				} else if (serializer instanceof JSONArraySerializer) {
 					serializer.serialize(new JSONArray(jsonConfig), object);
 				}
 			}
 		}
 
 		try {
 			// fix issue#1399@Github
 			if(object instanceof SQLException){
 				return object.toString();
 			}
 
 			// JSONArray
 			if (object instanceof Iterable || ArrayUtil.isArray(object)) {
 				return new JSONArray(object, jsonConfig);
 			}
 			// JSONObject
 			if (object instanceof Map) {
 				return new JSONObject(object, jsonConfig);
 			}
 
 			// 日期类型原样保存，便于格式化
 			if (object instanceof Date
 					|| object instanceof Calendar
 					|| object instanceof TemporalAccessor
 			) {
 				return object;
 			}
 			// 枚举类保存其字符串形式（4.0.2新增）
 			if (object instanceof Enum) {
 				return object.toString();
 			}
 
 			// Java内部类不做转换
 			if (ClassUtil.isJdkClass(object.getClass())) {
 				return object.toString();
 			}
 
 			// 默认按照JSONObject对待
 			return new JSONObject(object, jsonConfig);
 		} catch (Exception exception) {
 			return null;
 		}
 	}
 
 	/**
 	 * 格式化JSON字符串，此方法并不严格检查JSON的格式正确与否
 	 *
 	 * @param jsonStr JSON字符串
 	 * @return 格式化后的字符串
 	 * @since 3.1.2
 	 */
 	public static String formatJsonStr(String jsonStr) {
 		return JSONStrFormatter.format(jsonStr);
 	}
 
 	/**
 	 * 是否为JSON字符串，首尾都为大括号或中括号判定为JSON字符串
 	 *
 	 * @param str 字符串
 	 * @return 是否为JSON字符串
 	 * @since 3.3.0
 	 */
 	public static boolean isJson(String str) {
 		return isJsonObj(str) || isJsonArray(str);
 	}
 
 	/**
 	 * 是否为JSONObject字符串，首尾都为大括号判定为JSONObject字符串
 	 *
 	 * @param str 字符串
 	 * @return 是否为JSON字符串
 	 * @since 3.3.0
 	 */
 	public static boolean isJsonObj(String str) {
 		if (StrUtil.isBlank(str)) {
 			return false;
 		}
 		return StrUtil.isWrap(StrUtil.trim(str), '{', '}');
 	}
 
 	/**
 	 * 是否为JSONArray字符串，首尾都为中括号判定为JSONArray字符串
 	 *
 	 * @param str 字符串
 	 * @return 是否为JSON字符串
 	 * @since 3.3.0
 	 */
 	public static boolean isJsonArray(String str) {
 		if (StrUtil.isBlank(str)) {
 			return false;
 		}
 		return StrUtil.isWrap(StrUtil.trim(str), '[', ']');
 	}
 
 	/**
 	 * 是否为null对象，null的情况包括：
 	 *
 	 * <pre>
 	 * 1. {@code null}
 	 * 2. {@link JSONNull}
 	 * </pre>
 	 *
 	 * @param obj 对象
 	 * @return 是否为null
 	 * @since 4.5.7
 	 */
 	public static boolean isNull(Object obj) {
 		return null == obj || obj instanceof JSONNull;
 	}
 
 	/**
 	 * XML转JSONObject 
 	 * 转换过程中一些信息可能会丢失，JSON中无法区分节点和属性，相同的节点将被处理为JSONArray。
 	 *
 	 * @param xml XML字符串
 	 * @return JSONObject
 	 * @since 4.0.8
 	 */
 	public static JSONObject xmlToJson(String xml) {
 		return XML.toJSONObject(xml);
 	}
 
 	/**
 	 * 加入自定义的序列化器
 	 *
 	 * @param type 对象类型
 	 * @param serializer 序列化器实现
 	 * @see GlobalSerializeMapping#put(Type, JSONArraySerializer)
 	 * @since 4.6.5
 	 */
 	public static void putSerializer(Type type, JSONArraySerializer<?> serializer) {
 		GlobalSerializeMapping.put(type, serializer);
 	}
 
 	/**
 	 * 加入自定义的序列化器
 	 *
 	 * @param type 对象类型
 	 * @param serializer 序列化器实现
 	 * @see GlobalSerializeMapping#put(Type, JSONObjectSerializer)
 	 * @since 4.6.5
 	 */
 	public static void putSerializer(Type type, JSONObjectSerializer<?> serializer) {
 		GlobalSerializeMapping.put(type, serializer);
 	}
 
 	/**
 	 * 加入自定义的反序列化器
 	 *
 	 * @param type 对象类型
 	 * @param deserializer 反序列化器实现
 	 * @see GlobalSerializeMapping#put(Type, JSONDeserializer)
 	 * @since 4.6.5
 	 */
 	public static void putDeserializer(Type type, JSONDeserializer<?> deserializer) {
 		GlobalSerializeMapping.put(type, deserializer);
 	}
 
 	// --------------------------------------------------------------------------------------------- Private method start
 
 	/**
 	 * 转义不可见字符 
 	 * 见：https://en.wikibooks.org/wiki/Unicode/Character_reference/0000-0FFF
 	 *
 	 * @param c 字符
 	 * @return 转义后的字符串
 	 */
 	private static String escape(char c) {
 		switch (c) {
 			case '\b':
 				return "\\b";
 			case '\t':
 				return "\\t";
 			case '\n':
 				return "\\n";
 			case '\f':
 				return "\\f";
 			case '\r':
 				return "\\r";
 			default:
 				if (c < StrUtil.C_SPACE || //
 						(c >= '\u0080' && c <= '\u00a0') || //
 						(c >= '\u2000' && c <= '\u2010') || //
 						(c >= '\u2028' && c <= '\u202F') || //
 						(c >= '\u2066' && c <= '\u206F')//
 				) {
 					return HexUtil.toUnicodeHex(c);
 				} else {
 					return Character.toString(c);
 				}
 		}
 	}
 	// --------------------------------------------------------------------------------------------- Private method end
 }

JSON字符串转换为JSON对象：

JSONObject jsonObject = JSONUtil.parseObj(str);

JSON对象转换为javabean对象：

responseData = JSONUtil.toBean(jsonObject, ResponseData.class);

[0e5f04f9f62a4d78970bc50b2c142ab2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/cdf0e92657aa41b4a4194eb2a375afc4.png
[6a8459d3955e4dc4840bbc2c3343c7da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/343d2307cb894fd7aaf049b5393e87e1.png
[fb11f6f25b56433f8b599cf3ff47e4b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3daaac5cc0ad423c8a2dc676786b1d23.png