ANDROID轻量级JSON序列化和反序列化［转］

ANDROID JSON解析工具类，不需要第三方包，支持集合，直接贴代码。

[java] view plain copy

importjava.lang.reflect.Array;
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
importjava.lang.reflect.ParameterizedType;
importjava.lang.reflect.Type;
importjava.text.SimpleDateFormat;
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.Date;
importjava.util.HashMap;
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.List;
importjava.util.Locale;
importjava.util.Map;
importjava.util.Set;
importorg.json.JSONArray;
importorg.json.JSONException;
importorg.json.JSONObject;
importorg.json.JSONStringer;
importandroid.util.Log;
/**
*@authorkeane
*@version1.0
*
*/
publicclassJSONHelper{
privatestaticStringTAG="JSONHelper";
/**
*将对象转换成Json字符串
*@paramobj
*@return
*/
publicstaticStringtoJSON(Objectobj){
JSONStringerjs=newJSONStringer();
serialize(js,obj);
returnjs.toString();
}
/**
*序列化为JSON
*@paramjs
*@paramo
*/
privatestaticvoidserialize(JSONStringerjs,Objecto){
if(isNull(o)){
try{
js.value(null);
}catch(JSONExceptione){
e.printStackTrace();
}
return;
}
Class<?>clazz=o.getClass();
if(isObject(clazz)){//对象
serializeObject(js,o);
}elseif(isArray(clazz)){//数组
serializeArray(js,o);
}elseif(isCollection(clazz)){//集合
Collection<?>collection=(Collection<?>)o;
serializeCollect(js,collection);
}else{//单个值
try{
js.value(o);
}catch(JSONExceptione){
e.printStackTrace();
}
}
}
/**
*序列化数组
*@paramjs
*@paramarray
*/
privatestaticvoidserializeArray(JSONStringerjs,Objectarray){
try{
js.array();
for(inti=0;i<Array.getLength(array);++i){
Objecto=Array.get(array,i);
serialize(js,o);
}
js.endArray();
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*序列化集合
*@paramjs
*@paramcollection
*/
privatestaticvoidserializeCollect(JSONStringerjs,Collection<?>collection){
try{
js.array();
for(Objecto:collection){
serialize(js,o);
}
js.endArray();
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*序列化对象
*@paramjs
*@paramobj
*/
privatestaticvoidserializeObject(JSONStringerjs,Objectobj){
try{
js.object();
Class<?extendsObject>objClazz=obj.getClass();
Method[]methods=objClazz.getDeclaredMethods();
Field[]fields=objClazz.getDeclaredFields();
for(Fieldfield:fields){
try{
StringfieldType=field.getType().getSimpleName();
StringfieldGetName=parseMethodName(field.getName(),"get");
if(!haveMethod(methods,fieldGetName)){
continue;
}
MethodfieldGetMet=objClazz.getMethod(fieldGetName,newClass[]{});
ObjectfieldVal=fieldGetMet.invoke(obj,newObject[]{});
Stringresult=null;
if("Date".equals(fieldType)){
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss",
Locale.US);
result=sdf.format((Date)fieldVal);
}else{
if(null!=fieldVal){
result=String.valueOf(fieldVal);
}
}
js.key(field.getName());
serialize(js,result);
}catch(Exceptione){
continue;
}
}
js.endObject();
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*判断是否存在某属性的get方法
*
*@parammethods
*@paramfieldGetMet
*@returnboolean
*/
publicstaticbooleanhaveMethod(Method[]methods,StringfieldMethod){
for(Methodmet:methods){
if(fieldMethod.equals(met.getName())){
returntrue;
}
}
returnfalse;
}
/**
*拼接某属性的get或者set方法
*@paramfieldName
*@parammethodType
*@return
*/
publicstaticStringparseMethodName(StringfieldName,StringmethodType){
if(null==fieldName||"".equals(fieldName)){
returnnull;
}
returnmethodType+fieldName.substring(0,1).toUpperCase()
+fieldName.substring(1);
}
/**
*set属性的值到Bean
*@paramobj
*@paramvalMap
*/
publicstaticvoidsetFieldValue(Objectobj,Map<String,String>valMap){
Class<?>cls=obj.getClass();
//取出bean里的所有方法
Method[]methods=cls.getDeclaredMethods();
Field[]fields=cls.getDeclaredFields();
for(Fieldfield:fields){
try{
StringsetMetodName=parseMethodName(field.getName(),"set");
if(!haveMethod(methods,setMetodName)){
continue;
}
MethodfieldMethod=cls.getMethod(setMetodName,field
.getType());
Stringvalue=valMap.get(field.getName());
if(null!=value&&!"".equals(value)){
StringfieldType=field.getType().getSimpleName();
if("String".equals(fieldType)){
fieldMethod.invoke(obj,value);
}elseif("Date".equals(fieldType)){
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss",Locale.US);
Datetemp=sdf.parse(value);
fieldMethod.invoke(obj,temp);
}elseif("Integer".equals(fieldType)
||"int".equals(fieldType)){
Integerintval=Integer.parseInt(value);
fieldMethod.invoke(obj,intval);
}elseif("Long".equalsIgnoreCase(fieldType)){
Longtemp=Long.parseLong(value);
fieldMethod.invoke(obj,temp);
}elseif("Double".equalsIgnoreCase(fieldType)){
Doubletemp=Double.parseDouble(value);
fieldMethod.invoke(obj,temp);
}elseif("Boolean".equalsIgnoreCase(fieldType)){
Booleantemp=Boolean.parseBoolean(value);
fieldMethod.invoke(obj,temp);
}else{
System.out.println("setFieldValuenotsuppertype:"+fieldType);
}
}
}catch(Exceptione){
continue;
}
}
}
/**
*对象转Map
*@paramobj
*@return
*/
publicstaticMap<String,String>getFieldValueMap(Objectobj){
Class<?>cls=obj.getClass();
Map<String,String>valueMap=newHashMap<String,String>();
//取出bean里的所有方法
Method[]methods=cls.getDeclaredMethods();
Field[]fields=cls.getDeclaredFields();
for(Fieldfield:fields){
try{
StringfieldType=field.getType().getSimpleName();
StringfieldGetName=parseMethodName(field.getName(),"get");
if(!haveMethod(methods,fieldGetName)){
continue;
}
MethodfieldGetMet=cls.getMethod(fieldGetName,newClass[]{});
ObjectfieldVal=fieldGetMet.invoke(obj,newObject[]{});
Stringresult=null;
if("Date".equals(fieldType)){
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss",Locale.CHINA);
result=sdf.format((Date)fieldVal);
}else{
if(null!=fieldVal){
result=String.valueOf(fieldVal);
}
}
valueMap.put(field.getName(),result);
}catch(Exceptione){
continue;
}
}
returnvalueMap;
}
/**
*给对象的字段赋值
*@paramobj
*@paramfieldSetMethod
*@paramfieldType
*@paramvalue
*/
publicstaticvoidsetFiedlValue(Objectobj,MethodfieldSetMethod,StringfieldType,Objectvalue){
try{
if(null!=value&&!"".equals(value)){
if("String".equals(fieldType)){
fieldSetMethod.invoke(obj,value.toString());
}elseif("Date".equals(fieldType)){
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss",Locale.CHINA);
Datetemp=sdf.parse(value.toString());
fieldSetMethod.invoke(obj,temp);
}elseif("Integer".equals(fieldType)
||"int".equals(fieldType)){
Integerintval=Integer.parseInt(value.toString());
fieldSetMethod.invoke(obj,intval);
}elseif("Long".equalsIgnoreCase(fieldType)){
Longtemp=Long.parseLong(value.toString());
fieldSetMethod.invoke(obj,temp);
}elseif("Double".equalsIgnoreCase(fieldType)){
Doubletemp=Double.parseDouble(value.toString());
fieldSetMethod.invoke(obj,temp);
}elseif("Boolean".equalsIgnoreCase(fieldType)){
Booleantemp=Boolean.parseBoolean(value.toString());
fieldSetMethod.invoke(obj,temp);
}else{
fieldSetMethod.invoke(obj,value);
Log.e(TAG,TAG+">>>>setFiedlValue->notsuppertype"+fieldType);
}
}
}catch(Exceptione){
Log.e(TAG,TAG+">>>>>>>>>>setvalueerror.",e);
}
}
/**
*反序列化简单对象
*@paramjo
*@paramclazz
*@return
*@throwsJSONException
*/
publicstatic<T>TparseObject(JSONObjectjo,Class<T>clazz)throwsJSONException{
if(clazz==null||isNull(jo)){
returnnull;
}
Tobj=newInstance(clazz);
if(obj==null){
returnnull;
}
if(isMap(clazz)){
setField(obj,jo);
}else{
//取出bean里的所有方法
Method[]methods=clazz.getDeclaredMethods();
Field[]fields=clazz.getDeclaredFields();
for(Fieldf:fields){
StringsetMetodName=parseMethodName(f.getName(),"set");
if(!haveMethod(methods,setMetodName)){
continue;
}
try{
MethodfieldMethod=clazz.getMethod(setMetodName,f.getType());
setField(obj,fieldMethod,f,jo);
}catch(Exceptione){
e.printStackTrace();
}
}
}
returnobj;
}
/**
*反序列化简单对象
*@paramjsonString
*@paramclazz
*@return
*@throwsJSONException
*/
publicstatic<T>TparseObject(StringjsonString,Class<T>clazz)throwsJSONException{
if(clazz==null||jsonString==null||jsonString.length()==0){
returnnull;
}
JSONObjectjo=null;
jo=newJSONObject(jsonString);
if(isNull(jo)){
returnnull;
}
returnparseObject(jo,clazz);
}
/**
*反序列化数组对象
*@paramja
*@paramclazz
*@return
*/
publicstatic<T>T[]parseArray(JSONArrayja,Class<T>clazz){
if(clazz==null||isNull(ja)){
returnnull;
}
intlen=ja.length();
@SuppressWarnings("unchecked")
T[]array=(T[])Array.newInstance(clazz,len);
for(inti=0;i<len;++i){
try{
JSONObjectjo=ja.getJSONObject(i);
To=parseObject(jo,clazz);
array[i]=o;
}catch(JSONExceptione){
e.printStackTrace();
}
}
returnarray;
}
/**
*反序列化数组对象
*@paramjsonString
*@paramclazz
*@return
*/
publicstatic<T>T[]parseArray(StringjsonString,Class<T>clazz){
if(clazz==null||jsonString==null||jsonString.length()==0){
returnnull;
}
JSONArrayjo=null;
try{
jo=newJSONArray(jsonString);
}catch(JSONExceptione){
e.printStackTrace();
}
if(isNull(jo)){
returnnull;
}
returnparseArray(jo,clazz);
}
/**
*反序列化泛型集合
*@paramja
*@paramcollectionClazz
*@paramgenericType
*@return
*@throwsJSONException
*/
@SuppressWarnings("unchecked")
publicstatic<T>Collection<T>parseCollection(JSONArrayja,Class<?>collectionClazz,
Class<T>genericType)throwsJSONException{
if(collectionClazz==null||genericType==null||isNull(ja)){
returnnull;
}
Collection<T>collection=(Collection<T>)newInstance(collectionClazz);
for(inti=0;i<ja.length();++i){
try{
JSONObjectjo=ja.getJSONObject(i);
To=parseObject(jo,genericType);
collection.add(o);
}catch(JSONExceptione){
e.printStackTrace();
}
}
returncollection;
}
/**
*反序列化泛型集合
*@paramjsonString
*@paramcollectionClazz
*@paramgenericType
*@return
*@throwsJSONException
*/
publicstatic<T>Collection<T>parseCollection(StringjsonString,Class<?>collectionClazz,
Class<T>genericType)throwsJSONException{
if(collectionClazz==null||genericType==null||jsonString==null
||jsonString.length()==0){
returnnull;
}
JSONArrayjo=null;
try{
jo=newJSONArray(jsonString);
}catch(JSONExceptione){
e.printStackTrace();
}
if(isNull(jo)){
returnnull;
}
returnparseCollection(jo,collectionClazz,genericType);
}
/**
*根据类型创建对象
*@paramclazz
*@return
*@throwsJSONException
*/
privatestatic<T>TnewInstance(Class<T>clazz)throwsJSONException{
if(clazz==null)
returnnull;
Tobj=null;
if(clazz.isInterface()){
if(clazz.equals(Map.class)){
obj=(T)newHashMap();
}elseif(clazz.equals(List.class)){
obj=(T)newArrayList();
}elseif(clazz.equals(Set.class)){
obj=(T)newHashSet();
}else{
thrownewJSONException("unknowninterface:"+clazz);
}
}else{
try{
obj=clazz.newInstance();
}catch(Exceptione){
thrownewJSONException("unknownclasstype:"+clazz);
}
}
returnobj;
}
/**
*设定Map的值
*@paramobj
*@paramjo
*/
privatestaticvoidsetField(Objectobj,JSONObjectjo){
try{
@SuppressWarnings("unchecked")
Iterator<String>keyIter=jo.keys();
Stringkey;
Objectvalue;
@SuppressWarnings("unchecked")
Map<String,Object>valueMap=(Map<String,Object>)obj;
while(keyIter.hasNext()){
key=(String)keyIter.next();
value=jo.get(key);
valueMap.put(key,value);
}
}catch(JSONExceptione){
e.printStackTrace();
}
}
/**
*设定字段的值
*@paramobj
*@paramfieldSetMethod
*@paramf
*@paramjo
*/
privatestaticvoidsetField(Objectobj,MethodfieldSetMethod,Fieldf,JSONObjectjo){
Stringname=f.getName();
Class<?>clazz=f.getType();
try{
if(isArray(clazz)){//数组
Class<?>c=clazz.getComponentType();
JSONArrayja=jo.optJSONArray(name);
if(!isNull(ja)){
Objectarray=parseArray(ja,c);
setFiedlValue(obj,fieldSetMethod,clazz.getSimpleName(),array);
}
}elseif(isCollection(clazz)){//泛型集合
//获取定义的泛型类型
Class<?>c=null;
TypegType=f.getGenericType();
if(gTypeinstanceofParameterizedType){
ParameterizedTypeptype=(ParameterizedType)gType;
Type[]targs=ptype.getActualTypeArguments();
if(targs!=null&&targs.length>0){
Typet=targs[0];
c=(Class<?>)t;
}
}
JSONArrayja=jo.optJSONArray(name);
if(!isNull(ja)){
Objecto=parseCollection(ja,clazz,c);
setFiedlValue(obj,fieldSetMethod,clazz.getSimpleName(),o);
}
}elseif(isSingle(clazz)){//值类型
Objecto=jo.opt(name);
if(o!=null){
setFiedlValue(obj,fieldSetMethod,clazz.getSimpleName(),o);
}
}elseif(isObject(clazz)){//对象
JSONObjectj=jo.optJSONObject(name);
if(!isNull(j)){
Objecto=parseObject(j,clazz);
setFiedlValue(obj,fieldSetMethod,clazz.getSimpleName(),o);
}
}elseif(isList(clazz)){//列表
//JSONObjectj=jo.optJSONObject(name);
//if(!isNull(j)){
//Objecto=parseObject(j,clazz);
//f.set(obj,o);
//}
}else{
thrownewException("unknowtype!");
}
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*设定字段的值
*@paramobj
*@paramf
*@paramjo
*/
privatestaticvoidsetField(Objectobj,Fieldf,JSONObjectjo){
Stringname=f.getName();
Class<?>clazz=f.getType();
try{
if(isArray(clazz)){//数组
Class<?>c=clazz.getComponentType();
JSONArrayja=jo.optJSONArray(name);
if(!isNull(ja)){
Objectarray=parseArray(ja,c);
f.set(obj,array);
}
}elseif(isCollection(clazz)){//泛型集合
//获取定义的泛型类型
Class<?>c=null;
TypegType=f.getGenericType();
if(gTypeinstanceofParameterizedType){
ParameterizedTypeptype=(ParameterizedType)gType;
Type[]targs=ptype.getActualTypeArguments();
if(targs!=null&&targs.length>0){
Typet=targs[0];
c=(Class<?>)t;
}
}
JSONArrayja=jo.optJSONArray(name);
if(!isNull(ja)){
Objecto=parseCollection(ja,clazz,c);
f.set(obj,o);
}
}elseif(isSingle(clazz)){//值类型
Objecto=jo.opt(name);
if(o!=null){
f.set(obj,o);
}
}elseif(isObject(clazz)){//对象
JSONObjectj=jo.optJSONObject(name);
if(!isNull(j)){
Objecto=parseObject(j,clazz);
f.set(obj,o);
}
}elseif(isList(clazz)){//列表
JSONObjectj=jo.optJSONObject(name);
if(!isNull(j)){
Objecto=parseObject(j,clazz);
f.set(obj,o);
}
}else{
thrownewException("unknowtype!");
}
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*判断对象是否为空
*@paramobj
*@return
*/
privatestaticbooleanisNull(Objectobj){
if(objinstanceofJSONObject){
returnJSONObject.NULL.equals(obj);
}
returnobj==null;
}
/**
*判断是否是值类型
*@paramclazz
*@return
*/
privatestaticbooleanisSingle(Class<?>clazz){
returnisBoolean(clazz)||isNumber(clazz)||isString(clazz);
}
/**
*是否布尔值
*@paramclazz
*@return
*/
publicstaticbooleanisBoolean(Class<?>clazz){
return(clazz!=null)
&&((Boolean.TYPE.isAssignableFrom(clazz))||(Boolean.class
.isAssignableFrom(clazz)));
}
/**
*是否数值
*@paramclazz
*@return
*/
publicstaticbooleanisNumber(Class<?>clazz){
return(clazz!=null)
&&((Byte.TYPE.isAssignableFrom(clazz))||(Short.TYPE.isAssignableFrom(clazz))
||(Integer.TYPE.isAssignableFrom(clazz))
||(Long.TYPE.isAssignableFrom(clazz))
||(Float.TYPE.isAssignableFrom(clazz))
||(Double.TYPE.isAssignableFrom(clazz))||(Number.class
.isAssignableFrom(clazz)));
}
/**
*判断是否是字符串
*@paramclazz
*@return
*/
publicstaticbooleanisString(Class<?>clazz){
return(clazz!=null)
&&((String.class.isAssignableFrom(clazz))
||(Character.TYPE.isAssignableFrom(clazz))||(Character.class
.isAssignableFrom(clazz)));
}
/**
*判断是否是对象
*@paramclazz
*@return
*/
privatestaticbooleanisObject(Class<?>clazz){
returnclazz!=null&&!isSingle(clazz)&&!isArray(clazz)&&!isCollection(clazz);
}
/**
*判断是否是数组
*@paramclazz
*@return
*/
publicstaticbooleanisArray(Class<?>clazz){
returnclazz!=null&&clazz.isArray();
}
/**
*判断是否是集合
*@paramclazz
*@return
*/
publicstaticbooleanisCollection(Class<?>clazz){
returnclazz!=null&&Collection.class.isAssignableFrom(clazz);
}
/**
*判断是否是Map
*@paramclazz
*@return
*/
publicstaticbooleanisMap(Class<?>clazz){
returnclazz!=null&&Map.class.isAssignableFrom(clazz);
}
/**
*判断是否是列表
*@paramclazz
*@return
*/
publicstaticbooleanisList(Class<?>clazz){
returnclazz!=null&&List.class.isAssignableFrom(clazz);
}
}

调用测试代码：

[java] view plain copy

publicclassUser{
privateStringname;
privateStringpassword;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetPassword(){
returnpassword;
}
publicvoidsetPassword(Stringpassword){
this.password=password;
}
}
voidtestObj(){
try{
Useruser=newUser();
user.setName("abcd");
user.setPassword("123456");
Useruser1=newUser();
user.setName("abcdf");
user.setPassword("1234567");
StringjsonStrUser=JSONHelper.toJSON(user);//序列化
UserjsonUser=JSONHelper.parseObject(jsonStrUser,User.class);//反序列化
MapmapUser=JSONHelper.parseObject(jsonStrUser,HashMap.class);//反序列化
ListsourceList=newArrayList<User>();
sourceList.add(user);
sourceList.add(user1);
StringjsonStrUserList=JSONHelper.toJSON(sourceList);//序列化
ListlistUser=(List)JSONHelper.parseCollection(jsonStrUserList,List.class,User.class);//反序列化
}catch(JSONExceptione){
e.printStackTrace();
}
}

更多相关文章

随机推荐