在开发 SDK 时为了避免兼容性问题,不依赖三方解析库fastjson或者gson;这时我们需要使用android原生的json来自定义处理工具类;
使用方法
// Json字符串转为JavaBean
String jsonString = "{"this":"jsonObjectString"}";
JavaBean bean = JsonUtils.jsonToObject(jsonString, JavaBean.class);
// Json字符串转为Java数组
String jsonString = "[{"this":"jsonObjectString"},{"this":"jsonObjectString"}]";
List eventList = JsonUtils.jsonToObject(jsonString, new TypeReference>() {});
// JavaBean list 数组转为Json字符串
List mEventLists= new ArrayList<>();
String eventStr = JsonUtils.toJSONString(mEventLists);
// JavaBean对象转为Json字符串
JavaBean bean=new JavaBean();
String dataStr = JsonUtils.toJSONString(bean);
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* android 自带原生org.json 自定义JSON处理工具类
*/
public class JsonUtils {
/**
* 对象/数组列表转JSON字符串
*/
public static String toJSONString(Object obj)
throws JSONException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchMethodException, SecurityException {
if (obj == null) {
return null;
}
return toJSONObject(obj).toString();
}
/**
* 对list转为JSONArray,对对象转为JSONObject
*/
@SuppressWarnings("rawtypes")
private static Object toJSONObject(Object object)
throws JSONException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchMethodException, SecurityException {
if (object == null) {
return null;
}
if (object instanceof JSONObject || object instanceof JSONArray) {
return object;
}
// 基本数据类型非数组
if (isBaseType(object.getClass()) && !object.getClass().isArray()) {
return object;
} else if (object instanceof Map) { //如果为Map
Map map = (Map) object;
JSONObject jsonObject = new JSONObject();
for (Object key : map.keySet()) {
Object value = map.get(key);
jsonObject.put(String.valueOf(key), toJSONObject(value));
}
return jsonObject;
} else if (object instanceof List) {// 为List
List list = (List) object;
JSONArray jsonArray = new JSONArray();
for (Object obj : list) {
jsonArray.put(toJSONObject(obj));
}
return jsonArray;
} else if (object.getClass().isArray()) { // 为数组
int length = Array.getLength(object);
JSONArray jsonArray = new JSONArray();
for (int i = 0; i < length; i++) {
jsonArray.put(toJSONObject(Array.get(object, i)));
}
return jsonArray;
} else {
JSONObject jsonObject = new JSONObject();
Class> clazz = object.getClass();
parseObject(clazz, jsonObject, object);
return jsonObject;
}
}
private static void parseObject(Class> clazz, JSONObject jsonObject, Object object)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchMethodException, SecurityException, JSONException {
if (clazz == null) {
return;
}
// 通过反射获取到对象的所有属性
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 判断如果给定field.getModifiers()参数包含transient修饰符
if (Modifier.isTransient(field.getModifiers())) {
continue;
}
// 获取属性的属性名
String fieldName = field.getName();
// getDeclaredMethod 获得类声明的命名的方法,但无法获取父类的字段,从类中获取了一个方法后,可以用 invoke() 方法来调用这个方法
Method method = clazz.getDeclaredMethod("get" + captureName(fieldName));
if (method != null) {
jsonObject.put(fieldName, toJSONObject(method.invoke(object)));
}
}
//clazz 的父类解析,继承关系时获取父类信息
parseObject(clazz.getSuperclass(), jsonObject, object);
}
/**
* 用get方法获取数据,首字母大写,如getName()
*/
public static String captureName(String name) {
char[] cs = name.toCharArray();
//ascii 码表 ,如 n=110,N=78
cs[0] -= 32;
return String.valueOf(cs);
}
/**
* 判断是否为基本类型并且不为数组
*/
private static boolean isBaseType(Class> clazz) {
// isPrimitive 原始类型,isAssignableFrom 判断是否为某个类的类型
if (clazz.isPrimitive()
|| String.class.isAssignableFrom(clazz)// clazz 是否能强转为 String 类型
|| Integer.class.isAssignableFrom(clazz)
|| Double.class.isAssignableFrom(clazz)
|| Float.class.isAssignableFrom(clazz)
|| Long.class.isAssignableFrom(clazz)
|| Boolean.class.isAssignableFrom(clazz)
|| Byte.class.isAssignableFrom(clazz)
|| Short.class.isAssignableFrom(clazz)
|| Character.class.isAssignableFrom(clazz)) {
return true;
} else {
return false;
}
}
/**
* 将json字符串转化为对象列表
*
* @param json json字符串
* 使用:
* List eventList = JsonUtils.jsonToObject(jsonStr, new TypeReference>() {});
* new TypeReference>() {} 创建了一个继承TypeReference>的匿名子类,在其构造函数中拿到了泛型对应Type
*/
@SuppressWarnings("unchecked")
public static T jsonToObject(String json, TypeReference typeReference) throws Exception {
if (json == null || "".equals(json) || "".equals(json.trim())) {
throw new Exception("入参json数据为空,请检查");
}
// 获取真实的泛型类型
Type type = typeReference.genericParamType();
Class tClazz = (Class) getTclazz(type);
// 基本数据类型包括字符串 且不为 基本数据类型包括字符串数组
if (isBaseType(tClazz) && !tClazz.isArray()) {
throw new Exception("入参tClazz为基本类型,无法反序列化");
}
// 进行json串基本检查,判断是json对象还是JSONArray
JSONObject jsonObject = null;
JSONArray jsonArray = null;
if (json.startsWith("{")) {
jsonObject = new JSONObject(json);
} else if (json.startsWith("[")) {
jsonArray = new JSONArray(json);
} else {
throw new Exception("json数据非标准格式,请检查");
}
// 如果是JSONObject 直接返回
if (JSONObject.class.isAssignableFrom(tClazz)) {
return (T) jsonObject;
}
if (JSONArray.class.isAssignableFrom(tClazz)) {
return (T) jsonArray;
}
if (tClazz.isArray()) {
return createArr(jsonArray, tClazz);
} else if (List.class.isAssignableFrom(tClazz)) {
return (T) createList(type, jsonArray);
} else if (Set.class.isAssignableFrom(tClazz)) {
return (T) createSet(type, jsonArray);
} else if (Map.class.isAssignableFrom(tClazz)) {
return (T) createMap(type, jsonObject);
} else {
if (jsonObject == null) {
throw new Exception("json数据格式无法转换到" + tClazz);
}
T t = createObject(jsonObject, tClazz);
return t;
}
}
/**
* Json字符串转成对象
*
* @param json json字符串
* @param tClazz 列表中的数据类型
* @return 转化后的数据对象
*/
@SuppressWarnings("unchecked")
public static T jsonToObject(String json, Class tClazz) throws Exception {
if (json == null || "".equals(json) || "".equals(json.trim())) {
throw new Exception("入参json数据为空,请检查");
}
// 基本数据类型包括字符串 且不为 基本数据类型包括字符串数组
if (isBaseType(tClazz) && !tClazz.isArray()) {
throw new Exception("入参tClazz为基本类型,无法反序列化");
}
// 进行json串基本检查,判断是json对象还是JSONArray
JSONObject jsonObject = null;
JSONArray jsonArray = null;
if (json.startsWith("{")) {
// json是对象
jsonObject = new JSONObject(json);
} else if (json.startsWith("[")) {
// json是JSONArray
jsonArray = new JSONArray(json);
} else {
throw new Exception("json数据非标准格式,请检查");
}
// 如果是JSONObject 直接返回
if (JSONObject.class.isAssignableFrom(tClazz)) {
return (T) jsonObject;
}
if (JSONArray.class.isAssignableFrom(tClazz)) {
return (T) jsonArray;
}
if (tClazz.isArray()) {// tClazz 表示数组类
return createArr(jsonArray, tClazz);
} else if (List.class.isAssignableFrom(tClazz)) {
List
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* 指定反序列化的类型
* TypeReference的存在是因为java中子类可以获取到父类泛型的真实类型
*/
public abstract class TypeReference {
public Type genericParamType() {
//获取父类类型
//由于是抽象类,其实现类必然是继承当前类,所以父类类型即是TypeMarker
// getClass().getGenericSuperclass() 获取父类中的参数化类型(ParameterizedType)
// getGenericSuperclass返回一个Type类型的对象,代表实体(class, interface, primitive type or void)的直接父类,
// 如果父类是参数化类型,则返回的Type对象可准确反映源代码中使用的实际type参数。
Type superType = getClass().getGenericSuperclass();
//如果没有指定泛型参数,则返回的Type实际类型为Class
//未指定泛型参数时,默认将泛型视为Object类
if (superType instanceof Class) {
return Object.class;
}
//如果有泛型参数,则返回的Type实际类型为ParameterizedType
//强转并获取泛型参数,即XXX的实际类型
// ParameterizedType是一个记录类型泛型的接口, 继承自Type, 一共三方法:
// Type[] getActualTypeArguments(); //返回泛型类型数组
// Type getRawType(); //返回原始类型Type
// Type getOwnerType(); //返回 Type 对象,表示此类型是其成员之一的类型。
ParameterizedType parameterizedType = (ParameterizedType) superType;
// getActualTypeArguments:获取父类真实的泛型类型,返回泛型类型数组
Type argumentType = parameterizedType.getActualTypeArguments()[0];
return argumentType;
}
}