基于JSON和java对象的互转方法

import java.beans.introspectionexception;
import java.beans.introspector;
import java.beans.propertydescriptor;
import java.util.arraylist;
import java.util.hashmap;
import java.util.iterator;
import java.util.list;
import java.util.map;
import java.util.set;

import org.json.jsonobject;

/**
* json工具类，实现了实体类和json数据格式之间的互转功能 使用实例：<br>
*/
public class jsonutils {
 /**
  * 将一个实体类对象转换成json数据格式
  * 
  * @param bean
  *   需要转换的实体类对象
  * @return 转换后的json格式字符串
  */
 private static string beantojson(object bean) {
  stringbuilder json = new stringbuilder();
  json.append("{");
  propertydescriptor[] props = null;
  try {
   props = introspector.getbeaninfo(bean.getclass(), object.class)
     .getpropertydescriptors();
  } catch (introspectionexception e) {
  }
  if (props != null) {
   for (int i = 0; i < props.length; i++) {
    try {
     string name = objtojson(props[i].getname());
     string value = objtojson(props[i].getreadmethod()
       .invoke(bean));
     json.append(name);
     json.append(":");
     json.append(value);
     json.append(",");
    } catch (exception e) {
    }
   }
   json.setcharat(json.length() - 1, '}');
  } else {
   json.append("}");
  }
  return json.tostring();
 }


 /**
  * 将一个list对象转换成json数据格式返回
  * 
  * @param list
  *   需要进行转换的list对象
  * @return 转换后的json数据格式字符串
  */
 private static string listtojson(list<?> list) {
  stringbuilder json = new stringbuilder();
  json.append("[");
  if (list != null && list.size() > 0) {
   for (object obj : list) {
    json.append(objtojson(obj));
    json.append(",");
   }
   json.setcharat(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.tostring();
 }

 /**
  * 将一个对象数组转换成json数据格式返回
  * 
  * @param array
  *   需要进行转换的数组对象
  * @return 转换后的json数据格式字符串
  */
 private static string arraytojson(object[] array) {
  stringbuilder json = new stringbuilder();
  json.append("[");
  if (array != null && array.length > 0) {
   for (object obj : array) {
    json.append(objtojson(obj));
    json.append(",");
   }
   json.setcharat(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.tostring();
 }

 /**
  * 将一个map对象转换成json数据格式返回
  * 
  * @param map
  *   需要进行转换的map对象
  * @return 转换后的json数据格式字符串
  */
 private static string maptojson(map<?, ?> map) {
  stringbuilder json = new stringbuilder();
  json.append("{");
  if (map != null && map.size() > 0) {
   for (object key : map.keyset()) {
    json.append(objtojson(key));
    json.append(":");
    json.append(objtojson(map.get(key)));
    json.append(",");
   }
   json.setcharat(json.length() - 1, '}');
  } else {
   json.append("}");
  }
  return json.tostring();
 }

 /**
  * 将一个set对象转换成json数据格式返回
  * 
  * @param set
  *   需要进行转换的set对象
  * @return 转换后的json数据格式字符串
  */
 private static string settojson(set<?> set) {
  stringbuilder json = new stringbuilder();
  json.append("[");
  if (set != null && set.size() > 0) {
   for (object obj : set) {
    json.append(objtojson(obj));
    json.append(",");
   }
   json.setcharat(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.tostring();
 }

 private static string stringtojson(string s) {
  if (s == null) {
   return "";
  }
  stringbuilder sb = new stringbuilder();
  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;
   default:
    if (ch >= '\u0000' && ch <= '\u001f') {
     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);
    }
   }
  }
  return sb.tostring();
 }

 public static string objtojson(object obj) {
  stringbuilder json = new stringbuilder();
  if (obj == null) {
   json.append("\"\"");
  } else if (obj instanceof number) {
   number num = (number)obj;
   json.append(num.tostring());
  } else if (obj instanceof boolean) {
   boolean bl = (boolean)obj;
   json.append(bl.tostring());
  } else if (obj instanceof string) {
   json.append("\"").append(stringtojson(obj.tostring())).append("\"");
  } else if (obj instanceof object[]) {
   json.append(arraytojson((object[]) obj));
  } else if (obj instanceof list) {
   json.append(listtojson((list) obj));
  } else if (obj instanceof map) {
   json.append(maptojson((map) obj));
  } else if (obj instanceof set) {
   json.append(settojson((set) obj));
  } else {
   json.append(beantojson(obj));
  }
  return json.tostring();
 }
 
 /**
  * @title: json2map
  * @creater: chencc <br>
  * @date: 2011-3-28 <br>
  * @description: todo转化json2map
  * @param @param jsonstring
  * @param @return
  * @return map<string,object>
  * @throws
  */
 @suppresswarnings("unchecked")
 public static map<string, object> json2map(string jsonstring) {
  
  map<string, object> map = new hashmap<string, object>();
  try {
   if(null != jsonstring && !"".equals(jsonstring)){
    jsonobject jsonobject = new jsonobject(jsonstring);
   
    iterator keyiter = jsonobject.keys();
    string key = "";
    object value = null;
   
    while (keyiter.hasnext()) {
     key = (string) keyiter.next();
     value = jsonobject.get(key);
     map.put(key, value);
    }
   }
  } catch (exception e) {
   e.printstacktrace();
  }
  return map;
 }
 
 //测试方法
 public static void main(string[] args) {
  map<string,object> params = new hashmap<string,object>();
  params.put("callid123", integer.valueof(1000));
  map retmap = new hashmap();
  retmap.put("params", params);
  retmap.put("result", true);
  list ls = new arraylist();
  ls.add(new hashmap());
  ls.add("hello world!!");
  ls.add(new string[4]);
  retmap.put("list", ls);
  
  string[] strarray = new string[10];
  strarray[1]="first";
  strarray[2]="2";
  strarray[3]="3";
  system.out.println("boolean:"+jsonutils.objtojson(true));
  system.out.println("number:"+jsonutils.objtojson(23.3));
  system.out.println("string:"+jsonutils.objtojson("sdhfsjdgksdlkjfk\"sd,!#%$^&*#(*@&*%&*$fsdfsdfsdf"));
  system.out.println("map :"+jsonutils.objtojson(retmap));
  system.out.println("list:"+jsonutils.objtojson(ls));
  system.out.println("array:"+jsonutils.objtojson(strarray));
  
  string json = jsonutils.objtojson(retmap);
  map r = jsonutils.json2map(json);
  system.out.println(r.get("callid123"));
  
  
 }
}

import java.io.ioexception;
import java.text.simpledateformat;
import java.util.arraylist;
import java.util.hashmap;
import java.util.linkedhashmap;
import java.util.list;
import java.util.map;
import java.util.timezone;

import net.sf.json.jsonarray;
import net.sf.json.jsonobject;
import net.sf.json.jsonconfig;
import net.sf.json.util.cycledetectionstrategy;
import net.sf.json.util.propertyfilter;

import com.fasterxml.jackson.annotation.jsoninclude.include;
import com.fasterxml.jackson.databind.deserializationfeature;
import com.fasterxml.jackson.databind.objectmapper;

public class jsonutil {
 
 
 private static objectmapper objectmapper = null;
 /**
  * json初始化
  */
 static {
  objectmapper = new objectmapper(); 
  //设置为中国上海时区 
  objectmapper.settimezone(timezone.gettimezone("gmt+8")); 
  //空值不序列化 
  objectmapper.setserializationinclusion(include.non_null); 
  //反序列化时，属性不存在的兼容处理 
  objectmapper.getdeserializationconfig().withoutfeatures(deserializationfeature.fail_on_unknown_properties); 
  //序列化时，日期的统一格式 
  objectmapper.setdateformat(new simpledateformat("yyyy-mm-dd hh:mm:ss")); 

  objectmapper.configure(deserializationfeature.fail_on_unknown_properties, false); 
  
 } 
 
 
 /**
  * 把对象转换成为json字符串
  *
  * @param obj
  * @return
  */
 public static string convertobjecttojson(object obj) {
  if (obj == null) {
//    throw new illegalargumentexception("对象参数不能为空。");
   return null;
  }
  try {
   return objectmapper.writevalueasstring(obj);

  } catch (ioexception e) {
   e.printstacktrace();
  }
  return null;

 }
 /**
  * 把json字符串转成object对象
  * @param jsonstring
  * @return t
  */
 public static <t> t parsejsontoobject(string jsonstring, class<t> valuetype) {
  
  if(jsonstring == null || "".equals((jsonstring))){
   return null;
  }
  try {
   return objectmapper.readvalue(jsonstring, valuetype);
  } catch (exception e) {
   e.printstacktrace();
  }
  return null;
 }
 /**
  * 把json字符串转成list对象
  * @param jsonstring
  * @return list<t>
  */
 @suppresswarnings("unchecked")
 public static <t> list<t> parsejsontolist(string jsonstring,class<t> valuetype) {
  
  if(jsonstring == null || "".equals((jsonstring))){
   return null;
  }
  
  list<t> result = new arraylist<t>();
  try {
   list<linkedhashmap<object, object>> list = objectmapper.readvalue(jsonstring, list.class);
   
   for (linkedhashmap<object, object> map : list) {
    
    string jsonstr = convertobjecttojson(map);
    
    t t = parsejsontoobject(jsonstr, valuetype);
    
    result.add(t);
   }
  } catch (exception e) {
   e.printstacktrace();
  }
  return result;
 }
 /**
  * json处理含有嵌套关系对象，避免出现异常：net.sf.json.jsonexception: there is a cycle in the hierarchy的方法
  * 注意：这样获得到的字符串中，引起嵌套循环的属性会置为null
  *
  * @param obj
  * @return
  */
 public static jsonobject getjsonobject(object obj) {

  jsonconfig jsonconfig = new jsonconfig();
  jsonconfig.setcycledetectionstrategy(cycledetectionstrategy.lenient);
  jsonconfig.setjsonpropertyfilter(new propertyfilter() {
   
   @override
   public boolean apply(object source, string name, object value) {
    if(value==null){
     return true;
    }
    return false;
   }
  });
  return jsonobject.fromobject(obj, jsonconfig);
 }
 /**
  * json处理含有嵌套关系对象，避免出现异常：net.sf.json.jsonexception: there is a cycle in the hierarchy的方法

  * 注意：这样获得到的字符串中，引起嵌套循环的属性会置为null
  *
  * @param obj
  * @return
  */
 public static jsonarray getjsonarray(object obj) {

  jsonconfig jsonconfig = new jsonconfig();
  jsonconfig.setcycledetectionstrategy(cycledetectionstrategy.lenient);

  return jsonarray.fromobject(obj, jsonconfig);
 }
 /**
  * 解析json字符串成一个map
  *
  * @param jsonstr json字符串，格式如： {dicttable:"bm_xb",groupvalue:"分组值"}
  * @return
  */
 public static map<string, object> parsejsonstr(string jsonstr) {

  map<string, object> result = new hashmap<string, object>();

  jsonobject jsonobj = jsonutil.getjsonobject(jsonstr);

  for (object key : jsonobj.keyset()) {
   result.put((string) key, jsonobj.get(key));
  }
  return result;
 }

}