四种Java常用Json库
JSONObject依赖包
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.28</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>net.sf.ezmorph</groupId>
<artifactId>ezmorph</artifactId>
<version>1.0.6</version>
</dependency>
<!-- JSONObject.fromObject()的依赖, JSONArray.fromObject() -->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency><!-- JSONObject依赖包 -->
要想实现JSON和java对象之间的互转，需要借助第三方jar包，这里使用json-lib这个jar包，下载地址为：https://sourceforge.net/projects/json-lib/，json-lib需要commons-beanutils-1.8.0.jar、commons-collections-3.2.1.jar、commons-lang-2.5.jar、commons-logging-1.1.1.jar、ezmorph-1.0.6.jar五个包的支持，可以自行从网上下载
json-lib提供了几个类可以完成此功能，例，JSONObject、JSONArray。从类的名字上可以看出JSONObject转化的应该是对象格式的，而JSONArray转化的则应该是数组对象（即，带[]形式）的。
阿里巴巴fastjson
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.28</version>
</dependency>工具类
/**
* FastJson 工具类（阿里巴巴）
* @author EraJieZhang
* @data 2018/12/11
*/
public class FastJsonUtil {
/***
* 解析为字符串
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static String fromString(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getString(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为布尔
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static Boolean formBoolean(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getBoolean(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为String
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static String formString(String jsonString, String key, String skey) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
JSONObject jsonObject1 = jsonObject.getJSONObject(key);
String jsonObject2 = jsonObject1.getString(skey);
return jsonObject2;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为Int
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static int formInt(String jsonString, String key, String skey) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
JSONObject jsonObject1 = jsonObject.getJSONObject(key);
int jsonObject2 = jsonObject1.getInteger(skey);
return jsonObject2;
} else {
return -1;
}
} catch (Exception e) {
e.printStackTrace();
return -1;
}
}
/***
* 解析为数字
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static Integer formInteger(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getInteger(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为长位十进制数
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static BigDecimal formBigDecimal(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getBigDecimal(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为双精度
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static Double formDouble(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getDouble(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为浮点数
*
* @param jsonString json字符串
* @param key 关键字
* @return 返回值
*/
public static Float formFloat(String jsonString, String key) {
try {
if (jsonString != null && jsonString.length() > 0) {
JSONObject jsonObject = JSONObject.parseObject(jsonString);
return jsonObject.getFloat(key);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 解析为对象
*
* @param jsonString json字符串
* @param key 需要解析的关键字
* @param t 泛型
* @param <T> 泛型
* @return 返回的对象
*/
public static <T> T fromBean(String jsonString, String key, Class<T> t) {
if (jsonString != null) {
try {
JSONObject jsonObj = JSONObject.parseObject(jsonString);
return JSONObject.toJavaObject(jsonObj.getJSONObject(key), t);
} catch (Exception e) {
return null;
}
} else {
return null;
}
}
/***
* 解析为列表
*
* @param jsonString json字符串
* @param key 需要解析的关键字
* @param t 泛型
* @param <T> 泛型
* @return 返回的列表
*/
public static <T> ArrayList<T> fromList(String jsonString, String key, Class<T> t) {
ArrayList<T> list = new ArrayList<T>();
if (jsonString != null && jsonString.length() > 0) {
try {
JSONObject jsonObj = JSONObject.parseObject(jsonString);
JSONArray inforArray = jsonObj.getJSONArray(key);
for (int index = 0; index < inforArray.size(); index++) {
list.add(JSONObject.toJavaObject(
inforArray.getJSONObject(index), t));
}
} catch (Exception e) {
}
}
return list;
}
/***
* 直接解析为bean
*
* @param jsonString json字符串
* @param t 泛型
* @param <T> 泛型
* @return 返回的bean
*/
public static <T> T fromBean(String jsonString, Class<T> t) {
try {
if (jsonString != null && jsonString.length() > 0) {
return JSON.parseObject(jsonString, t);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/***
* 直接解析为list
*
* @param jsonString json字符串
* @param t 泛型
* @param <T> 泛型
* @return 返回的泛型数组
*/
public static <T> ArrayList<T> fromList(String jsonString, Class<T> t) {
ArrayList<T> list = null;
try {
list = new ArrayList<>();
if (jsonString != null && jsonString.length() > 0) {
list.addAll(JSON.parseArray(jsonString, t));
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
/***
* 将列表转换为json
*
* @param listBean 泛型数组
* @return json字符串
*/
public static <T> String ArrayToJson(ArrayList<T> listBean) {
String jsonString = JSON.toJSONString(listBean);
return jsonString;
}
/***
* 将类转为json
*
* @param <T> 泛型
* @return json字符串
*/
public static <T> String BeanToJson(Object obj) {
String jsonsString = JSON.toJSONString(obj);
return jsonsString;
}
}谷歌GSON
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
<scope>compile</scope>
</dependency>工具类
import java.util.List;
import java.util.Map;
import com.google.gson.*;
import com.google.gson.reflect.TypeToken;
public class GsonUtil {
/**
* 不用创建对象,直接使用Gson.就可以调用方法
*/
private static Gson gson = null;
private static JsonParser jsonParser = null;
/**
* 判断gson对象是否存在了,不存在则创建对象
*/
static {
if (gson == null) {
//gson = new Gson();
// 当使用GsonBuilder方式时属性为空的时候输出来的json字符串是有键值key的,显示形式是"key":null，而直接new出来的就没有"key":null的
gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
}
if(jsonParser == null ){
jsonParser = new JsonParser();
}
}
private GsonUtil() {}
/**
* json 转对象
* @param strJson
* @return
*/
public static JsonObject string2Object(String strJson) {
return jsonParser.parse(strJson).getAsJsonObject();
}
/**
* 将对象转成json格式
* @param object
* @return String
*/
public static String object2String(Object object) {
String gsonString = null;
if (gson != null) {
gsonString = gson.toJson(object);
}
return gsonString;
}
/**
* 将json转成特定的cls的对象
* @param gsonString
* @param cls
* @return
*/
public static <T> T stringToBean(String gsonString, Class<T> cls) {
T t = null;
if (gson != null) {
//传入json对象和对象类型,将json转成对象
t = gson.fromJson(gsonString, cls);
}
return t;
}
/**
* json字符串转成list
* @param gsonString
* @param cls
* @return
*/
public static <T> List<T> stringToList(String gsonString, Class<T> cls) {
List<T> list = null;
if (gson != null) {
//根据泛型返回解析指定的类型,TypeToken<List<T>>{}.getType()获取返回类型
list = gson.fromJson(gsonString, new TypeToken<List<T>>() {
}.getType());
}
return list;
}
/**
* json字符串转成list中有map的
* @param gsonString
* @return
*/
public static <T> List<Map<String, T>> stringToListMaps(String gsonString) {
List<Map<String, T>> list = null;
if (gson != null) {
list = gson.fromJson(gsonString,
new TypeToken<List<Map<String, T>>>() {
}.getType());
}
return list;
}
/**
* json字符串转成map的
* @param gsonString
* @return
*/
public static <T> Map<String, T> stringToMaps(String gsonString) {
Map<String, T> map = null;
if (gson != null) {
map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
}.getType());
}
return map;
}
public static String jsonElementAsString(JsonElement jsonElement) {
return jsonElement == null ? null : jsonElement.getAsString();
}
public static Integer f jsonElementAsInt(JsonElement jsonElement) {
return jsonElement == null ? null : jsonElement.getAsInt();
}
public static void main(String[] args) {
String s = "{\"goods_id\":\"140861765\",\"cat_id\":\"210\",\"goods_sn\":\"171073501\",\"goods_sn_back\":\"171073501\",\"goods_upc\":null,\"goods_name\":\"Lace-Up Boxer Swimming Trunks\"}";
Map<String, Object> map = stringToMaps(s);
System.out.println(map);
}
}Jackson
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.1</version>
</dependency>工具类
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;
/**
* Jackson工具类
*/
@Slf4j
public final class JsonUtil {
private static ObjectMapper MAPPER = new ObjectMapper();
// 日起格式化
private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
static {
//对象的所有字段全部列入
MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
//取消默认转换timestamps形式
MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//忽略空Bean转json的错误
MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
//所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
MAPPER.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
//忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
private JsonUtil() {
}
/**
* 对象转Json格式字符串
*
* @param object 对象
* @return Json格式字符串
*/
public static String toJson(Object object) {
if (object == null) {
return null;
}
try {
return object instanceof String ? (String) object : MAPPER.writeValueAsString(object);
} catch (Exception e) {
log.error("method=toJson() is convert error, errorMsg:{}", e.getMessage(), e);
return null;
}
}
/**
* Object TO Json String 字符串输出(输出空字符)
*
* @param object 对象
* @return Json格式字符串
*/
public static String toJsonEmpty(Object object) {
if (object == null) {
return null;
}
try {
MAPPER.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
@Override
public void serialize(Object param, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
//设置返回null转为 空字符串""
jsonGenerator.writeString("");
}
});
return MAPPER.writeValueAsString(object);
} catch (Exception e) {
log.error("method=toJsonEmpty() is convert error, errorMsg:{}", e.getMessage(), e);
}
return null;
}
/**
* Json 转为 Jave Bean
*
* @param text json字符串
* @param clazz 对象类型class
* @param <T> 对象类型
* @return 对象类型
*/
public static <T> T fromJSON(String text, Class<T> clazz) {
if (StringUtils.isEmpty(text) || clazz == null) {
return null;
}
try {
return MAPPER.readValue(text, clazz);
} catch (Exception e) {
log.error("method=toBean() is convert error, errorMsg:{}", e.getMessage(), e);
}
return null;
}
/**
* Json 转为 Map
*
* @param text json
* @param <K> key
* @param <V> value
* @return map
*/
public static <K, V> Map<K, V> toMap(String text) {
try {
if (StringUtils.isEmpty(text)) {
return null;
}
return toObject(text, new TypeReference<Map<K, V>>() {
});
} catch (Exception e) {
log.error("method=toMap() is convert error, errorMsg:{}", e.getMessage(), e);
}
return null;
}
/**
* Json 转 List, Class 集合中泛型的类型，非集合本身
*
* @param text json
* @param <T> 对象类型
* @return List
*/
public static <T> List<T> toList(String text) {
if (StringUtils.isEmpty(text)) {
return null;
}
try {
return toObject(text, new TypeReference<List<T>>() {
});
} catch (Exception e) {
log.error("method=toList() is convert error, errorMsg:{}", e.getMessage(), e);
}
return null;
}
/**
* Json 转 Object
*/
/**
* @param text json
* @param typeReference TypeReference
* @param <T> 类型
* @return T
*/
public static <T> T toObject(String text, TypeReference<T> typeReference) {
try {
if (StringUtils.isEmpty(text) || typeReference == null) {
return null;
}
return (T) (typeReference.getType().equals(String.class) ? text : MAPPER.readValue(text, typeReference));
} catch (Exception e) {
log.error("method=toObject() is convert error, errorMsg:{}", e.getMessage(), e);
}
return null;
}
}
org.json
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20190722</version>
</dependency>工具类
import android.util.Log;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
public class JsonUtils {
private static final String TAG = JsonUtils.class.getSimpleName();
/**
* 解析json字符串到实例对象
*
* @param clazz 和JSON对应的类的Class，必须拥有setXxx()函数，其中xxx为属性
* @param json 被解析的JSON字符串
* @return 返回传入的Object对象实例
*/
public static <T> T parseJson2Object(String json, Class<T> clazz) {
JSONObject jsonObject = null;
try {
jsonObject = new JSONObject(json);
} catch (JSONException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
return null;
}
return parseJson2Object(clazz, jsonObject);
}
/**
* 解析JSONObject对象到具体类，递归算法
*
* @param clazz 和JSON对应的类的Class，必须拥有setXxx()函数，其中xxx为属性
* @param jsonObject 被解析的JSON对象
* @return 返回传入的Object对象实例
*/
private static <T> T parseJson2Object(Class<T> clazz, JSONObject jsonObject) {
T obj = null;
try {
//获取clazz的实例
obj = clazz.newInstance();
Class tempClass = clazz;
List<Field> fieldList = new ArrayList<>();
while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
}
// Collections.reverse(fieldList);
// 遍历每个属性，如果为基本类型和String则直接赋值，如果为List则得到每个Item添加后再赋值，如果是其它类则得到类的实例后赋值
for (Field field : fieldList) {
try {
// 设置属性可操作
field.setAccessible(true);
// if (field.getName().equals("serialVersionUID")) {
// continue;
// }
FSLogcat.e(TAG, " GenericType = " + field.getGenericType().toString());
// 获取字段类型
Class<?> typeClazz = field.getType();
// 是否基础变量 Boolean,Character,Byte,Short,Integer,Long,Float,Double,Void
if (typeClazz.isPrimitive()) {
if (field.getGenericType().toString().equals("float")) {
Object opt = jsonObject.opt(field.getName());
if (opt instanceof Double) {
setProperty(obj, field, ((Double) opt).floatValue());
} else {
setProperty(obj, field, jsonObject.opt(field.getName()));
}
} else {
setProperty(obj, field, jsonObject.opt(field.getName()));
}
} else {
// 得到类型实例
Object typeObj;
if (typeClazz.isInterface() && typeClazz.getSimpleName().contains("List")) {//Field如果声明为List<T>接口，由于接口的Class对象不能newInstance()，此时需要转化为ArrayList
typeObj = ArrayList.class.newInstance();
} else {
typeObj = typeClazz.newInstance();
}
if (field.getName().equals("testMap")) {
Log.e(TAG, " pause");
}
if (typeObj instanceof Map) {// 是否为Map
try {
// 得到Map的JSONObject
JSONObject object = jsonObject.getJSONObject(field.getName());
// 得到类型的结构，如:java.util.HashMap<com.xxx.xxx>
Type type = field.getGenericType();
ParameterizedType pt = (ParameterizedType) type;
// 获得Map元素键类型
// Class<?> keyClass = (Class<?>) pt.getActualTypeArguments()[0];
// 获得Map元素值类型
Class<?> valueClass = (Class<?>) pt.getActualTypeArguments()[1];
JSONArray names = object.names();
for (int i = 0; i < names.length(); i++) {
try {
// 默认按map值为String进行解析
String key = names.opt(i).toString();
Object value = parseJson2Object(valueClass, object.getJSONObject(key));
((Map<String, Object>) typeObj).put(key, value);
} catch (Exception e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
}
setProperty(obj, field, typeObj);
} catch (Exception e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
} else if (typeObj instanceof List) {// 是否为List
// 得到类型的结构，如:java.util.ArrayList<com.xxx.xxx>
Type type = field.getGenericType();
ParameterizedType pt = (ParameterizedType) type;
// 获得List元素类型
Class<?> dataClass = (Class<?>) pt.getActualTypeArguments()[0];
// 得到List的JSONArray数组
JSONArray jArray = jsonObject.getJSONArray(field.getName());
// 将每个元素的实例类加入到类型的实例中
for (int i = 0; i < jArray.length(); i++) {
//对于数组，递归调用解析子元素
try {
((List<Object>) typeObj).add(parseJson2Object(dataClass, jsonObject.getJSONArray(field.getName()).getJSONObject(i)));
} catch (JSONException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
}
setProperty(obj, field, typeObj);
} else if (typeObj instanceof String) {// 是否为String
setProperty(obj, field, jsonObject.opt(field.getName()));
} else {//是否为其它对象
//递归解析对象
try {
setProperty(obj, field, parseJson2Object(typeClazz, jsonObject.getJSONObject(field.getName())));
} catch (JSONException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
}
}
} catch (JSONException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
} catch (IllegalAccessException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
} catch (InstantiationException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
}
} catch (IllegalAccessException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
} catch (InstantiationException e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
return obj;
}
/**
* 给实例对象的成员变量赋值
*
* @param obj 实例对象
* @param field 要被赋值的成员变量
* @param valueObj 要被赋值的成员变量的值
*/
private static void setProperty(Object obj, Field field, Object valueObj) {
if (valueObj == null) {
return;
}
// // 兼容类继承情况的判断
Class<?> tempClass = obj.getClass();
while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
try {
Method method = tempClass.getDeclaredMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
//设置set方法可访问
method.setAccessible(true);
//调用set方法为实例对象的成员变量赋值
method.invoke(obj, valueObj);
break; // 退出循环
} catch (NoSuchMethodException e) {
FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] not found");
tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
} catch (IllegalArgumentException e) {
FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] illegal argument:" + valueObj + "," + e.getMessage());
break; // 退出循环
} catch (IllegalAccessException e) {
FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
break; // 退出循环
} catch (InvocationTargetException e) {
FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
break; // 退出循环
} catch (Exception e) {
FSLogcat.e(TAG, "Exception:" + e.getMessage());
break; // 退出循环
}
}
// 未兼容类继承后对父类私有方法的获取
// try {
// Class<?> clazz = obj.getClass();
// //获取类的setXxx方法，xxx为属性
// // getMethods(),该方法是获取本类以及父类或者父接口中所有的公共方法(public修饰符修饰的)
// Method method = clazz.getMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
// // getDeclaredMethods(),该方法是获取本类中的所有方法，包括私有的(private、protected、默认以及public)的方法。
Method method = clazz.getDeclaredMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
// //设置set方法可访问
// method.setAccessible(true);
// //调用set方法为实例对象的成员变量赋值
// method.invoke(obj, valueObj);
// } catch (NoSuchMethodException e) {
// FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] not found");
// } catch (IllegalArgumentException e) {
// FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] illegal argument:" + valueObj + "," + e.getMessage());
// } catch (IllegalAccessException e) {
// FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
// } catch (InvocationTargetException e) {
// FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
// }
}
/**
* 可以解析自定义的对象、map、List、数组、基本数据类型、String
*
* @param value
* @return
*/
public static String object2JsonString(Object value) {
if (value == null) {
return "null";
}
if (value instanceof Boolean) {
return value.toString();
}
if (value instanceof String) {
return "\"" + escape((String) value) + "\"";
}
if (value instanceof Double) {
if (((Double) value).isInfinite() || ((Double) value).isNaN()) {
// return "null";
return "0";
} else {
return value.toString();
}
}
if (value instanceof Float) {
if (((Float) value).isInfinite() || ((Float) value).isNaN()) {
// return "null";
return "0";
} else {
return value.toString();
}
}
if (value instanceof Number) {
return value.toString();
}
if (value instanceof Map) {
return map2Json((Map) value);
}
if (value instanceof Collection) {
return coll2Json((Collection) value);
}
if (value.getClass().isArray()) {
return array2Json(value);
}
return customObject2Json(value);
}
private static String array2Json(Object array) {
if (null == array) {
return "null";
}
StringBuffer sb = new StringBuffer();
sb.append('[');
// 此处减1是为了下面的 逗号 追加
int len = Array.getLength(array) - 1;
if (len > -1) {
int i;
for (i = 0; i < len; i++) {
sb.append(object2JsonString(Array.get(array, i))).append(",");
}
sb.append(object2JsonString(Array.get(array, i)));
}
sb.append(']');
return sb.toString();
}
private static String coll2Json(Collection coll) {
if (null == coll) {
return "null";
}
StringBuffer sb = new StringBuffer();
sb.append('[');
for (Iterator it = coll.iterator(); it.hasNext(); ) {
sb.append(object2JsonString(it.next()));
if (it.hasNext()) {
sb.append(",");
}
}
sb.append(']');
return sb.toString();
}
private static String customObject2Json(Object obj) {
Class tempClass = obj.getClass();
List<Field> fieldList = new ArrayList<>();
while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
}
Map map = new HashMap();
for (Field f : fieldList) {
if (Modifier.isStatic(f.getModifiers())) {
continue;
}
String name = f.getName();
f.setAccessible(true);
Object value = null;
try {
value = f.get(obj);
} catch (IllegalAccessException e) {
value = null;
FSLogcat.e(TAG, "Exception:" + e.getMessage());
}
map.put(name, value);
}
tempClass = null;
fieldList = null;
return map2Json(map);
// Class type = obj.getClass();
// Field[] fields = type.getDeclaredFields();
// Map map = new HashMap();
// for (Field f : fields) {
// if (Modifier.isStatic(f.getModifiers())) {
// continue;
// }
// String name = f.getName();
// f.setAccessible(true);
// Object value = null;
// try {
// value = f.get(obj);
// } catch (IllegalAccessException e) {
// value = null;
// FSLogcat.e(TAG, "Exception:" + e.getMessage());
// }
// map.put(name, value);
// }
// type = null;
// fields = null;
// return map2Json(map);
}
private static String map2Json(Map map) {
if (null == map) {
return "null";
}
StringBuffer sb = new StringBuffer();
sb.append('{');
for (Iterator it = map.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
if (null == key) {
continue;
}
sb.append('\"');
escape(key, sb);
sb.append('\"').append(':').append(object2JsonString(entry.getValue()));
if (it.hasNext()) {
sb.append(",");
}
}
sb.append('}');
return sb.toString();
}
/**
* Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).
*
* @param s
* @return
*/
private static String escape(String s) {
if (s == null) {
return null;
}
StringBuffer sb = new StringBuffer();
escape(s, sb);
return sb.toString();
}
private static void escape(String s, StringBuffer sb) {
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
switch (ch) {
case '"':
sb.append("\\\"");
break;
case '\\':
sb.append("\\\\");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
// case '/':
// sb.append("\\/");
// break;
case '/':
sb.append("/");
break;
default:
if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F') || (ch >= '\u2000' && ch <= '\u20FF')) {
String ss = Integer.toHexString(ch);
sb.append("\\u");
for (int k = 0; k < 4 - ss.length(); k++) {
sb.append('0');
}
sb.append(ss.toUpperCase());
} else {
sb.append(ch);
}
}
}
}
}
参考文章：（这些文章会有一些具体的工具类，以及使用方式）
https://www.cnblogs.com/one12138/p/11494256.html
https://blog.csdn.net/weixin_39859128/article/details/110613391
https://blog.csdn.net/qing_gee/article/details/104001021
https://cloud.tencent.com/developer/article/1675482
https://blog.csdn.net/qq912098812/article/details/110390557
