json

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。这些特性使JSON成为理想的数据交换语言。

   欲实现JSON字符串和java对象之间的互相转换,方法有很多!本人层也因为项目上的需求,一度对这几种方法做过研究和试验!现将自己的一点小经验分享与大家,如有纰漏,请指正!

 


   1.通过json_lib来实现对json和java对象之间的转换,使用JSON-LIB可以极大的简化JAVA对象转换成JSON对象所需进行的操作,更可以避免人工操作生成JSON对象字符串时带来的麻烦和误操作:

   注:欲使用json_lib需要以下几个jar包的支持:

json-lib-1.1-jdk15.jar  下载地址:http://json-lib.sourceforge.net

       commons-collections-3.2.1.jar

       commons-lang-2.4.jar

       commons-logging-1.1.1.jar

       commons-beanutils-1.8.0.jar

       以上commons系列包在tomcat/comon/lib下可以找到;

       ezmorph-1.0.6.jar    下载地址http://ezmorph.sourceforge.net

       morph-1.0.1 下载地址:http://morph.sourceforge.net

   有了这些jar包的支持,平时关于json处理的方法都可以找到对应的类;贴上一段代码示例:

Java代码   收藏代码
  1. package util;  
  2. import java.util.ArrayList;  
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7. import net.sf.json.JSONArray;  
  8. import net.sf.json.JSONObject;  
  9. public class JSONHelper {  
  10.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
  11.      /** 
  12.       * 将JSONArray对象转换成Map-List集合 
  13.       * @param jsonArr 
  14.       * @return 
  15.       */  
  16.      public static Object JsonToList(JSONArray jsonArr){  
  17.          List<Object> jsonObjList = new ArrayList<Object> ();  
  18.          for(Object obj : jsonArr){  
  19.              if(obj instanceof JSONArray){  
  20.                  jsonObjList.add(JsonToList((JSONArray) obj));  
  21.              } else if(obj instanceof JSONObject){  
  22.                  jsonObjList.add(JsonToMap((JSONObject) obj));  
  23.              }else{  
  24.                  jsonObjList.add(obj);  
  25.              }  
  26.          }  
  27.          return jsonObjList;  
  28.      }  
  29.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
  30.     /** 
  31.      *  将JSONObjec对象转换成Map-List集合 
  32.      * @param json 
  33.      * @return 
  34.      */  
  35.      public static Map<String, Object> JsonToMap(JSONObject json){  
  36.          Map<String,Object> columnValMap = new HashMap<String,Object>();  
  37.          Set<Object> jsonKeys = json.keySet();  
  38.          for (Object key : jsonKeys) {  
  39.              Object JsonValObj = json.get(key);  
  40.              if(JsonValObj instanceof JSONArray){  
  41.                 columnValMap.put((String)key,  JsonToList((JSONArray) JsonValObj));  
  42.              }else if(key instanceof JSONObject){  
  43.                 columnValMap.put((String)key,  JsonToMap((JSONObject) JsonValObj));  
  44.              }else{  
  45.                  columnValMap.put((String)key,JsonValObj);  
  46.              }  
  47.         }  
  48.          return columnValMap;  
  49.      }  
  50.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
  51.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
  52.      /** 
  53.       * 将json对象转换为map集合,通过此方法获取存放map集合键的list集合 
  54.       * @param obj 
  55.       * @return 
  56.       */  
  57.      public static List<Object> mapKeys(Object obj){  
  58.          List<Object> keysList = new ArrayList<Object>();  
  59.          Map<String,Object> columnValMap = new HashMap<String,Object>();  
  60.          String columnStr = "column";  
  61.          if(obj instanceof JSONArray){  
  62.              List<Map<String, Object>> jsonObjList = new ArrayList<Map<String, Object>> ();  
  63.              jsonObjList = (List<Map<String, Object>>) JsonToList((JSONArray) obj);  
  64.              columnValMap =(Map<String, Object>) (jsonObjList.get(0));  
  65.              //以上三句可优化为如下一句  
  66.              //columnValMap =(Map<String, Object>)(((List<Object>)JsonToList((JSONArray) obj)).get(0));  
  67.          }else if(obj instanceof JSONObject){  
  68.              columnValMap =JsonToMap((JSONObject) obj);  
  69.          }else{  
  70.              keysList.add(obj);  
  71.          }  
  72.          for(int i=0;i<columnValMap.keySet().size();i++){  
  73.              keysList.add(columnStr+(i+1));  
  74.          }  
  75.          System.out.println(keysList.size());  
  76.          return keysList;  
  77.      }  
  78. }  

 2.通过使用谷歌的Gson来处理json字符串,谷歌的Gson针对封装的javaBean处理起来很方便,但对于未封装的json字符串需要找到技巧处理起来也才能顺手。

      使用谷歌的Gson当然也需要jar包的支持,这需要一个jar包:Gson.jar

      下载地址:http://code.google.com/p/google-gson/downloads/detail?name=google-gson-2.2.4-release.zip

       示例:将通过js获取的json字符串转换为Map、List集合,代码如下:

Java代码   收藏代码
  1. package util;  
  2. import java.util.ArrayList;  
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import com.google.gson.Gson;  
  7. public class JSONHelper {  
  8.     private Gson gson = new Gson();  
  9.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  10.     /** 
  11.       * 将json对象转换为map集合,通过此方法获取存放map集合键的list集合 
  12.       * @param obj 
  13.       * @return 
  14.       */  
  15.     public static List<Object> mapKeys(Map<?,?> map){  
  16.          List<Object> keysList = new ArrayList<Object>();  
  17.          String columnStr="column";  
  18.          for(int i=0;i<map.keySet().size();i++){  
  19.              keysList.add(columnStr+(i+1));  
  20.          }  
  21.          System.out.println(keysList.size());  
  22.          return keysList;  
  23.     }  
  24.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  25.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  26.     /** 
  27.      * 将传入的json字符串转换为元素为map集合的List集合 
  28.      * @param jsonArrStr 
  29.      * @return 
  30.      */  
  31.     public static List<Map<String, Object>> jsonObjList(String jsonArrStr) {  
  32.         List<Map<String, Object>> jsonObjList = new ArrayList<Map<String, Object>>();  
  33.         List<?> jsonList = Test.jsonToList(jsonArrStr);  
  34.         Gson gson = new Gson();  
  35.         for (Object object : jsonList) {  
  36.             String jsonStr = gson.toJson(object);  
  37.             Map<?, ?> json = Test.jsonToMap(jsonStr);  
  38.             jsonObjList.add((Map<String, Object>) json);  
  39.         }  
  40.         return jsonObjList;  
  41.     }  
  42.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  43.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  44.     /** 
  45.      * 将传入的json字符串解析为List集合 
  46.      * @param jsonStr 
  47.      * @return 
  48.      */  
  49.     public static List<?> jsonToList(String jsonStr) {  
  50.         List<?> ObjectList = null;  
  51.         Gson gson = new Gson();  
  52.         java.lang.reflect.Type type = new com.google.gson.reflect.TypeToken<List<?>>() {}.getType();  
  53.         ObjectList = gson.fromJson(jsonStr, type);  
  54.         return ObjectList;  
  55.     }  
  56.                                                                                                                                                                                                                                                                                                                                                                                                                                                    
  57.     /** 
  58.      * 将传入的json字符串解析为Map集合 
  59.      * @param jsonStr 
  60.      * @return 
  61.      */  
  62.     public static Map<?, ?> jsonToMap(String jsonStr) {  
  63.         Map<?, ?> ObjectMap = null;  
  64.         Gson gson = new Gson();  
  65.         java.lang.reflect.Type type = new com.google.gson.reflect.TypeToken<Map<?,?>>() {}.getType();  
  66.         ObjectMap = gson.fromJson(jsonStr, type);  
  67.         return ObjectMap;  
  68.     }  
  69. }  

 3.使用最轻量级的org.json.jar实现json字符串和java对象之间的互转

       所需jar包:org.json.jar

       下载地址:www.json.org  或第三方:http://kiccp.sinaapp.com/store/info/111

       同样实现对json字符串转换为Map、List集合,代码如下:

Java代码   收藏代码
  1. package util;  
  2. import java.util.ArrayList;  
  3. import java.util.HashMap;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7. import org.json.JSONArray;  
  8. import org.json.JSONException;  
  9. import org.json.JSONObject;  
  10. /** 
  11.  * 此类是处理json字符串的工具类 
  12.  * 
  13.  * @author xiaomeng 
  14.  * @since 2013-08-27 
  15.  * 
  16.  */  
  17. public class JSONHelper {  
  18.     /** 
  19.      * 将json字符串转换为List集合 
  20.      * 
  21.      * @param jsonArrStr 
  22.      * @return 
  23.      */  
  24.     public static List<Map<String, Object>> jsonObjList(String jsonArrStr) {  
  25.         List<Map<String, Object>> jsonList = new ArrayList<Map<String, Object>>();  
  26.         JSONArray jsonArr = null;  
  27.         try {  
  28.             jsonArr = new JSONArray(jsonArrStr);  
  29.             jsonList = (List<Map<String, Object>>)JSONHelper.jsonToList(jsonArr);  
  30.         } catch (JSONException e) {  
  31.             System.out.println("Json字符串转换异常!");  
  32.             e.printStackTrace();  
  33.         }  
  34.         return jsonList;  
  35.     }  
  36.     /** 
  37.      * 将json对象的键值存放在集合,映射table的column 
  38.      * 
  39.      * @param map 
  40.      * @return 
  41.      */  
  42.     public static List<String> jsonMapKeysList(Map<?, ?> map) {  
  43.         List<String> jsonjsonList = new ArrayList<String>();  
  44.         String columnStr = "column";  
  45.         for (int i = 0; i < map.keySet().size(); i++) {  
  46.             jsonjsonList.add(columnStr + (i + 1));  
  47.         }  
  48.         System.out.println(jsonjsonList.size());  
  49.         return jsonjsonList;  
  50.     }  
  51.     /** 
  52.      * 将传递近来的json数组转换为List集合 
  53.      * 
  54.      * @param jsonArr 
  55.      * @return 
  56.      * @throws JSONException 
  57.      */  
  58.     private static List<?> jsonToList(JSONArray jsonArr)  
  59.             throws JSONException {  
  60.         List<Object> jsonToMapList = new ArrayList<Object>();  
  61.         for (int i = 0; i < jsonArr.length(); i++) {  
  62.             Object object = jsonArr.get(i);  
  63.             if (object instanceof JSONArray) {  
  64.                 jsonToMapList.add(JSONHelper.jsonToList((JSONArray) object));  
  65.             } else if (object instanceof JSONObject) {  
  66.                 jsonToMapList.add(JSONHelper.jsonToMap((JSONObject) object));  
  67.             } else {  
  68.                 jsonToMapList.add(object);  
  69.             }  
  70.         }  
  71.         return jsonToMapList;  
  72.     }  
  73.     /** 
  74.      * 将传递近来的json对象转换为Map集合 
  75.      * 
  76.      * @param jsonObj 
  77.      * @return 
  78.      * @throws JSONException 
  79.      */  
  80.     @SuppressWarnings("unchecked")  
  81.     private static Map<String, Object> jsonToMap(JSONObject jsonObj)  
  82.             throws JSONException {  
  83.         Map<String, Object> jsonMap = new HashMap<String, Object>();  
  84.         Iterator<String> jsonKeys = jsonObj.keys();  
  85.         while (jsonKeys.hasNext()) {  
  86.             String jsonKey = jsonKeys.next();  
  87.             Object jsonValObj = jsonObj.get(jsonKey);  
  88.             if (jsonValObj instanceof JSONArray) {  
  89.                 jsonMap.put(jsonKey, JSONHelper.jsonToList((JSONArray) jsonValObj));  
  90.             } else if (jsonValObj instanceof JSONObject) {  
  91.                 jsonMap.put(jsonKey, JSONHelper.jsonToMap((JSONObject) jsonValObj));  
  92.             } else {  
  93.                 jsonMap.put(jsonKey, jsonValObj);  
  94.             }  
  95.         }  
  96.         return jsonMap;  
  97.     }  
  98. }  

 

以上三种常用的json和java对象之间的互相转换方法各有其特点,根据我的小经验,现将其优缺点总如下,供参考!

    1.json_lib json解析框架

       优点:各种复杂json格式和对json处理的一般需求都可以做到

       缺点:所需支持的jar文件较多,并且关于jar包版本或许会出现一些杂七杂八的问题

    2.谷歌Gson对json的解析:

       优点:(1)。可以谷歌的Gson就是为处理java对象和json之间转换开发的框架,其可以很简单、方便的对封装的java对象和json格式文本之间的转换,包括java工具类集合之间的转换也很方便;(2)。相对json_lib框架来说,只需要一个Gson.jar就可以,需要jar文件数量少;

       缺点:由于其相对来说偏向于处理java对象和json之间的转换,所以其只简单的处理json字符串和集合类之间的转换稍微需要一个过渡,就是使用反射确定转换的java对象类型。

     3.org.json框架

       优点:在这三者之中,其实最轻量级、同谷歌Gson一样所需jar文件也是最少的一种方法,并且其在处理json字符串到java集合的转黄相对简便

缺点:相对Gson处理java对象和json之间的转换比较费事

综述:这三种解析json的方法各有优缺点,具体可根据自己需求选择使用。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值