首页 > Web开发 > 详细

JsonUtil工具类

时间：2016-06-02 18:14:57      阅读：273      评论：0      收藏：0      [点我收藏+]
  1. package comm;     
  2.     
  3. import java.text.SimpleDateFormat;     
  4. import java.util.ArrayList;     
  5. import java.util.Collection;     
  6. import java.util.Date;     
  7. import java.util.HashMap;     
  8. import java.util.Iterator;     
  9. import java.util.List;     
  10. import java.util.Map;     
  11.     
  12. import net.sf.ezmorph.MorpherRegistry;     
  13. import net.sf.ezmorph.object.DateMorpher;     
  14. import net.sf.json.JSONArray;     
  15. import net.sf.json.JSONObject;     
  16. import net.sf.json.JsonConfig;     
  17. import net.sf.json.processors.JsonValueProcessor;     
  18. import net.sf.json.util.JSONUtils;     
  19. import net.sf.json.xml.XMLSerializer;     
  20.     
  21. public class JsonUtil {     
  22.     
  23.     /**   
  24.      * 设置日期转换格式   
  25.      */    
  26.     static {     
  27.         //注册器     
  28.         MorpherRegistry mr = JSONUtils.getMorpherRegistry();     
  29.     
  30.         //可转换的日期格式，即Json串中可以出现以下格式的日期与时间     
  31.         DateMorpher dm = new DateMorpher(new String[] { Util.YYYY_MM_DD,     
  32.                 Util.YYYY_MM_DD_HH_MM_ss, Util.HH_MM_ss, Util.YYYYMMDD,     
  33.                 Util.YYYYMMDDHHMMSS, Util.HHMMss });     
  34.         mr.registerMorpher(dm);     
  35.     }     
  36.     
  37.     /**   
  38.     * 从json串转换成实体对象   
  39.     * @param jsonObjStr e.g. {‘name‘:‘get‘,‘dateAttr‘:‘2009-11-12‘}   
  40.     * @param clazz Person.class   
  41.     * @return   
  42.     */    
  43.     public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {     
  44.         return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);     
  45.     }     
  46.     
  47.     /**   
  48.     * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean   
  49.     * @param jsonObjStr e.g. {‘data‘:[{‘name‘:‘get‘},{‘name‘:‘set‘}]}   
  50.     * @param clazz e.g. MyBean.class   
  51.     * @param classMap e.g. classMap.put("data", Person.class)   
  52.     * @return Object   
  53.     */    
  54.     public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {     
  55.         return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);     
  56.     }     
  57.     
  58.     /**   
  59.     * 把一个json数组串转换成普通数组   
  60.     * @param jsonArrStr  e.g. [‘get‘,1,true,null]   
  61.     * @return Object[]   
  62.     */    
  63.     public static Object[] getArrFromJsonArrStr(String jsonArrStr) {     
  64.         return JSONArray.fromObject(jsonArrStr).toArray();     
  65.     }     
  66.     
  67.     /**   
  68.     * 把一个json数组串转换成实体数组   
  69.     * @param jsonArrStr e.g. [{‘name‘:‘get‘},{‘name‘:‘set‘}]   
  70.     * @param clazz e.g. Person.class   
  71.     * @return Object[]   
  72.     */    
  73.     public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {     
  74.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);     
  75.         Object[] objArr = new Object[jsonArr.size()];     
  76.         for (int i = 0; i < jsonArr.size(); i++) {     
  77.             objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);     
  78.         }     
  79.         return objArr;     
  80.     }     
  81.     
  82.     /**   
  83.     * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean   
  84.     * @param jsonArrStr e.g. [{‘data‘:[{‘name‘:‘get‘}]},{‘data‘:[{‘name‘:‘set‘}]}]   
  85.     * @param clazz e.g. MyBean.class   
  86.     * @param classMap e.g. classMap.put("data", Person.class)   
  87.     * @return Object[]   
  88.     */    
  89.     public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,     
  90.             Map classMap) {     
  91.         JSONArray array = JSONArray.fromObject(jsonArrStr);     
  92.         Object[] obj = new Object[array.size()];     
  93.         for (int i = 0; i < array.size(); i++) {     
  94.             JSONObject jsonObject = array.getJSONObject(i);     
  95.             obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);     
  96.         }     
  97.         return obj;     
  98.     }     
  99.     
  100.     /**   
  101.     * 把一个json数组串转换成存放普通类型元素的集合   
  102.     * @param jsonArrStr  e.g. [‘get‘,1,true,null]   
  103.     * @return List   
  104.     */    
  105.     public static List getListFromJsonArrStr(String jsonArrStr) {     
  106.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);     
  107.         List list = new ArrayList();     
  108.         for (int i = 0; i < jsonArr.size(); i++) {     
  109.             list.add(jsonArr.get(i));     
  110.         }     
  111.         return list;     
  112.     }     
  113.     
  114.     /**   
  115.     * 把一个json数组串转换成集合，且集合里存放的为实例Bean   
  116.     * @param jsonArrStr e.g. [{‘name‘:‘get‘},{‘name‘:‘set‘}]   
  117.     * @param clazz   
  118.     * @return List   
  119.     */    
  120.     public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {     
  121.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);     
  122.         List list = new ArrayList();     
  123.         for (int i = 0; i < jsonArr.size(); i++) {     
  124.             list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));     
  125.         }     
  126.         return list;     
  127.     }     
  128.     
  129.     /**   
  130.     * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean   
  131.     * @param jsonArrStr e.g. [{‘data‘:[{‘name‘:‘get‘}]},{‘data‘:[{‘name‘:‘set‘}]}]   
  132.     * @param clazz e.g. MyBean.class   
  133.     * @param classMap e.g. classMap.put("data", Person.class)   
  134.     * @return List   
  135.     */    
  136.     public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {     
  137.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);     
  138.         List list = new ArrayList();     
  139.         for (int i = 0; i < jsonArr.size(); i++) {     
  140.             list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));     
  141.         }     
  142.         return list;     
  143.     }     
  144.     
  145.     /**   
  146.     * 把json对象串转换成map对象   
  147.     * @param jsonObjStr e.g. {‘name‘:‘get‘,‘int‘:1,‘double‘,1.1,‘null‘:null}   
  148.     * @return Map   
  149.     */    
  150.     public static Map getMapFromJsonObjStr(String jsonObjStr) {     
  151.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);     
  152.     
  153.         Map map = new HashMap();     
  154.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {     
  155.             String key = (String) iter.next();     
  156.             map.put(key, jsonObject.get(key));     
  157.         }     
  158.         return map;     
  159.     }     
  160.     
  161.     /**   
  162.     * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean   
  163.     * @param jsonObjStr e.g. {‘data1‘:{‘name‘:‘get‘},‘data2‘:{‘name‘:‘set‘}}   
  164.     * @param clazz e.g. Person.class   
  165.     * @return Map   
  166.     */    
  167.     public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {     
  168.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);     
  169.     
  170.         Map map = new HashMap();     
  171.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {     
  172.             String key = (String) iter.next();     
  173.             map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));     
  174.         }     
  175.         return map;     
  176.     }     
  177.     
  178.     /**   
  179.      * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean   
  180.      * @param jsonObjStr e.g. {‘mybean‘:{‘data‘:[{‘name‘:‘get‘}]}}   
  181.      * @param clazz e.g. MyBean.class   
  182.      * @param classMap  e.g. classMap.put("data", Person.class)   
  183.      * @return Map   
  184.      */    
  185.     public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {     
  186.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);     
  187.     
  188.         Map map = new HashMap();     
  189.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {     
  190.             String key = (String) iter.next();     
  191.             map.put(key, JSONObject     
  192.                     .toBean(jsonObject.getJSONObject(key), clazz, classMap));     
  193.         }     
  194.         return map;     
  195.     }     
  196.     
  197.     /**   
  198.      * 把实体Bean、Map对象、数组、列表集合转换成Json串   
  199.      * @param obj    
  200.      * @return   
  201.      * @throws Exception String   
  202.      */    
  203.     public static String getJsonStr(Object obj) {     
  204.         String jsonStr = null;     
  205.         //Json配置         
  206.         JsonConfig jsonCfg = new JsonConfig();     
  207.     
  208.         //注册日期处理器     
  209.         jsonCfg.registerJsonValueProcessor(java.util.Date.class,     
  210.                 new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));     
  211.         if (obj == null) {     
  212.             return "{}";     
  213.         }     
  214.     
  215.         if (obj instanceof Collection || obj instanceof Object[]) {     
  216.             jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();     
  217.         } else {     
  218.             jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();     
  219.         }     
  220.     
  221.         return jsonStr;     
  222.     }     
  223.     
  224.     /**   
  225.      * 把json串、数组、集合(collection map)、实体Bean转换成XML   
  226.      * XMLSerializer API：   
  227.      * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html   
  228.      * 具体实例请参考：   
  229.      * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html   
  230.      * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html   
  231.      * @param obj    
  232.      * @return   
  233.      * @throws Exception String   
  234.      */    
  235.     public static String getXMLFromObj(Object obj) {     
  236.         XMLSerializer xmlSerial = new XMLSerializer();     
  237.     
  238.         //Json配置         
  239.         JsonConfig jsonCfg = new JsonConfig();     
  240.     
  241.         //注册日期处理器     
  242.         jsonCfg.registerJsonValueProcessor(java.util.Date.class,     
  243.                 new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));     
  244.     
  245.         if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith("["))     
  246.                 || obj.getClass().isArray() || Collection.class.isInstance(obj)) {     
  247.             JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);     
  248.             return xmlSerial.write(jsonArr);     
  249.         } else {     
  250.             JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);     
  251.             return xmlSerial.write(jsonObj);     
  252.         }     
  253.     }     
  254.     
  255.     /**   
  256.      * 从XML转json串   
  257.      * @param xml   
  258.      * @return String   
  259.      */    
  260.     public static String getJsonStrFromXML(String xml) {     
  261.         XMLSerializer xmlSerial = new XMLSerializer();     
  262.         return String.valueOf(xmlSerial.read(xml));     
  263.     }     
  264.     
  265. }     
  266.     
  267. /**   
  268.  * json日期值处理器实现     
  269.  * (C) 2009-9-11, jzj   
  270.  */    
  271. class JsonDateValueProcessor implements JsonValueProcessor {     
  272.     
  273.     private String format = Util.YYYY_MM_DD_HH_MM_ss;     
  274.     
  275.     public JsonDateValueProcessor() {     
  276.     
  277.     }     
  278.     
  279.     public JsonDateValueProcessor(String format) {     
  280.         this.format = format;     
  281.     }     
  282.     
  283.     public Object processArrayValue(Object value, JsonConfig jsonConfig) {     
  284.         return process(value, jsonConfig);     
  285.     }     
  286.     
  287.     public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {     
  288.         return process(value, jsonConfig);     
  289.     }     
  290.     
  291.     private Object process(Object value, JsonConfig jsonConfig) {     
  292.         if (value instanceof Date) {     
  293.             String str = new SimpleDateFormat(format).format((Date) value);     
  294.             return str;     
  295.         }     
  296.         return value == null ? null : value.toString();     
  297.     }     
  298.     
  299.     public String getFormat() {     
  300.         return format;     
  301.     }     
  302.     
  303.     public void setFormat(String format) {     
  304.         this.format = format;     
  305.     }     
  306.     
  307. }    

 

JsonUtilTest

[java] view plain copy
  1. package comm.test;     
  2.     
  3. import java.text.SimpleDateFormat;     
  4. import java.util.ArrayList;     
  5. import java.util.Date;     
  6. import java.util.HashMap;     
  7. import java.util.Iterator;     
  8. import java.util.LinkedHashMap;     
  9. import java.util.LinkedHashSet;     
  10. import java.util.List;     
  11. import java.util.Map;     
  12. import java.util.Set;     
  13.     
  14. import junit.framework.TestCase;     
  15.     
  16. import comm.JsonUtil;     
  17.     
  18. /**   
  19.  * JsonUtil测试类   
  20.  * (C) 2009-9-11, jzj   
  21.  */    
  22. public class JsonUtilTest extends TestCase {     
  23.     
  24.     /**   
  25.      * 从json串转换成实体对象，且实体中Date属性能正确转换   
  26.      *  void   
  27.      */    
  28.     public void testGetDtoFromJsonObjStr1() {     
  29.         String json = "{‘name‘:‘get‘,‘dateAttr‘:‘2009-11-12‘}";     
  30.         Person ps = (Person) JsonUtil.getDtoFromJsonObjStr(json, Person.class);     
  31.         //print: get     
  32.         System.out.println(ps.getName());     
  33.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");     
  34.         //print: 2009-11-12     
  35.         System.out.println(sdf.format(ps.getDateAttr()));     
  36.     }     
  37.     
  38.     /**   
  39.      * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean   
  40.      *  void   
  41.      */    
  42.     public void testGetDtoFromJsonObjStr3() {     
  43.         String json = "{‘data‘:[{‘name‘:‘get‘},{‘name‘:‘set‘}]}";     
  44.         Map classMap = new HashMap();     
  45.         classMap.put("data", Person.class);     
  46.         MyBean myBean = (MyBean) JsonUtil.getDtoFromJsonObjStr(json, MyBean.class,     
  47.                 classMap);     
  48.         //print: class comm.test.Person name =get            
  49.         System.out.println(myBean.getData().get(0).getClass() + " name ="    
  50.                 + ((Person) myBean.getData().get(0)).getName());     
  51.         //print: class comm.test.Person name =set     
  52.         System.out.println(myBean.getData().get(1).getClass() + " name ="    
  53.                 + ((Person) myBean.getData().get(1)).getName());     
  54.     }     
  55.     
  56.     /**   
  57.      * 把一个json数组串转换成普通数组   
  58.      *  void   
  59.      */    
  60.     public void testGetArrFromJsonArrStr() {     
  61.         String json = "[‘get‘,1,true,null]";     
  62.         Object[] objArr = JsonUtil.getArrFromJsonArrStr(json);     
  63.         for (int i = 0; i < objArr.length; i++) {     
  64.             System.out.println(objArr[i].getClass() + " " + objArr[i]);     
  65.         }     
  66.         /*  print:   
  67.             class java.lang.String get   
  68.             class java.lang.Integer 1   
  69.             class java.lang.Boolean true   
  70.             class net.sf.json.JSONNull null   
  71.          */    
  72.     }     
  73.     
  74.     /**   
  75.      * 把一个json数组串转换成实体数组   
  76.      *  void   
  77.      */    
  78.     public void testGetDtoArrFromJsonArrStr1() {     
  79.         String json = "[{‘name‘:‘get‘},{‘name‘:‘set‘}]";     
  80.         Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, Person.class);     
  81.         for (int i = 0; i < objArr.length; i++) {     
  82.             System.out.println(objArr[i].getClass() + " name = "    
  83.                     + ((Person) objArr[i]).getName());     
  84.         }     
  85.         /*  print:   
  86.             class comm.test.Person name = get   
  87.             class comm.test.Person name = set   
  88.          */    
  89.     }     
  90.     
  91.     /**   
  92.      * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean   
  93.      *  void   
  94.      */    
  95.     public void testGetDtoArrFromJsonArrStr2() {     
  96.         String json = "[{‘data‘:[{‘name‘:‘get‘}]},{‘data‘:[{‘name‘:‘set‘}]}]";     
  97.         Map classMap = new HashMap();     
  98.         classMap.put("data", Person.class);     
  99.         Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, MyBean.class, classMap);     
  100.         for (int i = 0; i < objArr.length; i++) {     
  101.             System.out.println(((MyBean) objArr[i]).getData().get(0).getClass()     
  102.                     + " name = "    
  103.                     + ((Person) ((MyBean) objArr[i]).getData().get(0)).getName());     
  104.         }     
  105.         /*  print:   
  106.             class comm.test.Person name = get   
  107.             class comm.test.Person name = set   
  108.          */    
  109.     }     
  110.     
  111.     /**   
  112.      * 把一个json数组串转换成存放普通类型元素的集合   
  113.      *  void   
  114.      */    
  115.     public void testGetListFromJsonArrStr1() {     
  116.         String json = "[‘get‘,1,true,null]";     
  117.         List list = JsonUtil.getListFromJsonArrStr(json);     
  118.         for (int i = 0; i < list.size(); i++) {     
  119.             System.out.println(list.get(i).getClass() + " " + list.get(i));     
  120.         }     
  121.         /*  print:   
  122.             class java.lang.String get   
  123.             class java.lang.Integer 1   
  124.             class java.lang.Boolean true   
  125.             class net.sf.json.JSONNull null   
  126.          */    
  127.     }     
  128.     
  129.     /**   
  130.      * 把一个json数组串转换成集合，且集合里存放的为实例Bean   
  131.      *  void   
  132.      */    
  133.     public void testGetListFromJsonArrStr2() {     
  134.         String json = "[{‘name‘:‘get‘},{‘name‘:‘set‘}]";     
  135.         List list = JsonUtil.getListFromJsonArrStr(json, Person.class);     
  136.         for (int i = 0; i < list.size(); i++) {     
  137.             System.out.println(list.get(i).getClass() + " name = "    
  138.                     + ((Person) list.get(i)).getName());     
  139.         }     
  140.         /*  print:   
  141.             class comm.test.Person name = get   
  142.             class comm.test.Person name = set   
  143.          */    
  144.     }     
  145.     
  146.     /**   
  147.      * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean   
  148.      *  void   
  149.      */    
  150.     public void testGetListFromJsonArrStr3() {     
  151.         String json = "[{‘data‘:[{‘name‘:‘get‘}]},{‘data‘:[{‘name‘:‘set‘}]}]";     
  152.         Map classMap = new HashMap();     
  153.         classMap.put("data", Person.class);     
  154.         List list = JsonUtil.getListFromJsonArrStr(json, MyBean.class, classMap);     
  155.         for (int i = 0; i < list.size(); i++) {     
  156.             System.out.println(((MyBean) list.get(i)).getData().get(0).getClass()     
  157.                     + " name = "    
  158.                     + ((Person) ((MyBean) list.get(i)).getData().get(0)).getName());     
  159.         }     
  160.         /*  print:   
  161.             class comm.test.Person name = get   
  162.             class comm.test.Person name = set   
  163.          */    
  164.     }     
  165.     
  166.     /**   
  167.      * 把json对象串转换成map对象   
  168.      *  void   
  169.      */    
  170.     public void testGetMapFromJsonObjStr() {     
  171.         String json = "{‘name‘:‘get‘,‘int‘:1,‘double‘:1.1,‘null‘:null}";     
  172.         Map map = JsonUtil.getMapFromJsonObjStr(json);     
  173.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {     
  174.             System.out.println(map.get(iter.next()).getClass());     
  175.         }     
  176.         /*  print:   
  177.             class java.lang.Double   
  178.             class net.sf.json.JSONNull   
  179.             class java.lang.Integer   
  180.             class java.lang.String   
  181.          */    
  182.     }     
  183.     
  184.     /**   
  185.      * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean   
  186.      *  void   
  187.      */    
  188.     public void testGetMapFromJsonObjStr2() {     
  189.         String json = "{‘data1‘:{‘name‘:‘get‘},‘data2‘:{‘name‘:‘set‘}}";     
  190.         Map map = JsonUtil.getMapFromJsonObjStr(json, Person.class);     
  191.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {     
  192.             String key = (String) iter.next();     
  193.             System.out.println(map.get(key).getClass() + " name="    
  194.                     + ((Person) map.get(key)).getName());     
  195.         }     
  196.         /*  print:   
  197.             class comm.test.Person name=set   
  198.             class comm.test.Person name=get   
  199.          */    
  200.     }     
  201.     
  202.     /**   
  203.      * 把json对象串转换成map对象，且map对象里   
  204.      * 存放的其他实体Bean还含有另外实体Bean   
  205.      *  void   
  206.      */    
  207.     public void testGetMapFromJsonObjStr3() {     
  208.         String json = "{‘mybean‘:{‘data‘:[{‘name‘:‘get‘}]}}";     
  209.         Map classMap = new HashMap();     
  210.         classMap.put("data", Person.class);     
  211.         Map map = JsonUtil.getMapFromJsonObjStr(json, MyBean.class, classMap);     
  212.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {     
  213.             String key = (String) iter.next();     
  214.             Object o = ((MyBean) map.get(key)).getData().get(0);     
  215.             System.out.println(o.getClass() + " name=" + ((Person) o).getName());     
  216.         }     
  217.         /*  print:   
  218.             class comm.test.Person name=get   
  219.          */    
  220.     }     
  221.     
  222.     /**   
  223.      * 实体Bean转json串   
  224.      *  void   
  225.      */    
  226.     public void testgetJsonStr1() {     
  227.         Person ps = new Person();     
  228.         ps.setDateAttr(new Date());     
  229.         ps.setName("get");     
  230.         MyBean myBean = new MyBean();     
  231.         List list = new ArrayList();     
  232.         list.add(ps);     
  233.     
  234.         myBean.setData(list);     
  235.         //print: {"data":[{"dateAttr":"2009-09-12 07:24:54","name":"get"}]}     
  236.         System.out.println(JsonUtil.getJsonStr(myBean));     
  237.     }     
  238.     
  239.     /**   
  240.      * map转json串   
  241.      *  void   
  242.      */    
  243.     public void testgetJsonStr2() {     
  244.         Person ps = new Person();     
  245.         ps.setDateAttr(new Date());     
  246.         ps.setName("get");     
  247.         Map map = new LinkedHashMap();     
  248.         map.put("person1", ps);     
  249.     
  250.         //print: {"person1":{"dateAttr":"2009-09-12 07:24:27","name":"get"}}     
  251.         System.out.println(JsonUtil.getJsonStr(map));     
  252.     }     
  253.     
  254.     /**   
  255.      * 数组转json串   
  256.      *  void   
  257.      */    
  258.     public void testgetJsonStr3() {     
  259.         Person ps = new Person();     
  260.         ps.setDateAttr(new Date());     
  261.         ps.setName("get");     
  262.         Person[] personArr = new Person[1];     
  263.         personArr[0] = ps;     
  264.         //print: [{"dateAttr":"2009-09-12 07:23:54","name":"get"}]     
  265.         System.out.println(JsonUtil.getJsonStr(personArr));     
  266.     }     
  267.     
  268.     /**   
  269.      * list转json串   
  270.      *  void   
  271.      */    
  272.     public void testgetJsonStr4() {     
  273.         Person ps = new Person();     
  274.         ps.setDateAttr(new Date());     
  275.         ps.setName("get");     
  276.         List list = new ArrayList();     
  277.         list.add(ps);     
  278.     
  279.         //print: [{"dateAttr":"2009-09-12 07:22:49","name":"get"}]     
  280.         System.out.println(JsonUtil.getJsonStr(list));     
  281.     }     
  282.     
  283.     /**   
  284.      * set转json串   
  285.      *  void   
  286.      */    
  287.     public void testgetJsonStr5() {     
  288.         Person ps = new Person();     
  289.         ps.setDateAttr(new Date());     
  290.         ps.setName("get");     
  291.         Set set = new LinkedHashSet();     
  292.         set.add(ps);     
  293.     
  294.         //print: [{"dateAttr":"2009-09-12 07:22:16","name":"get"}]     
  295.         System.out.println(JsonUtil.getJsonStr(set));     
  296.     }     
  297.     
  298.     /**   
  299.      * json对象串转XML   
  300.      *  void   
  301.      */    
  302.     public void testGetXMLFromObj1() {     
  303.         System.out.println(JsonUtil     
  304.                 .getXMLFromObj("{/"name/":/"json/",/"bool/":true,/"int/":1}"));     
  305.         /*  print:   
  306.             <?xml version="1.0" encoding="UTF-8"?>   
  307.             <o>   
  308.                 <bool type="boolean">true</bool>   
  309.                 <int type="number">1</int>   
  310.                 <name type="string">json</name>   
  311.             </o>   
  312.          */    
  313.     }     
  314.     
  315.     /**   
  316.      * json数组串转XML   
  317.      *  void   
  318.      */    
  319.     public void testGetXMLFromObj2() {     
  320.         System.out.println(JsonUtil.getXMLFromObj("[1,2,3]"));     
  321.         /*  print:   
  322.             <?xml version="1.0" encoding="UTF-8"?>   
  323.             <a>   
  324.                 <e type="number">1</e>   
  325.                 <e type="number">2</e>   
  326.                 <e type="number">3</e>   
  327.             </a>   
  328.          */    
  329.     }     
  330.     
  331.     /**   
  332.      * java数组转XML   
  333.      *  void   
  334.      */    
  335.     public void testGetXMLFromObj3() {     
  336.         Person ps = new Person();     
  337.         ps.setDateAttr(new Date());     
  338.         ps.setName("get");     
  339.         Person[] personArr = new Person[2];     
  340.         personArr[0] = ps;     
  341.     
  342.         System.out.println(JsonUtil.getXMLFromObj(personArr));     
  343.         /*  print:   
  344.             <?xml version="1.0" encoding="UTF-8"?>   
  345.             <a>   
  346.                 <e class="object">   
  347.                     <dateAttr type="string">2009-09-12 06:58:55</dateAttr>   
  348.                     <name type="string">get</name>   
  349.                 </e>   
  350.             </a>   
  351.          */    
  352.     }     
  353.     
  354.     /**   
  355.      * list转XML   
  356.      *  void   
  357.      */    
  358.     public void testGetXMLFromObj4() {     
  359.         Person ps = new Person();     
  360.         ps.setDateAttr(new Date());     
  361.         ps.setName("get");     
  362.         List list = new ArrayList();     
  363.         list.add(ps);     
  364.     
  365.         System.out.println(JsonUtil.getXMLFromObj(list));     
  366.         /*  print:   
  367.             <?xml version="1.0" encoding="UTF-8"?>   
  368.             <a>   
  369.                 <e class="object">   
  370.                     <dateAttr type="string">2009-09-12 07:02:31</dateAttr>   
  371.                     <name type="string">get</name>   
  372.                 </e>   
  373.             </a>   
  374.          */    
  375.     }     
  376.     
  377.     /**   
  378.      * set转XML   
  379.      * void   
  380.      */    
  381.     public void testGetXMLFromObj5() {     
  382.         Person ps = new Person();     
  383.         ps.setDateAttr(new Date());     
  384.         ps.setName("get");     
  385.         Set set = new LinkedHashSet();     
  386.         set.add(ps);     
  387.     
  388.         System.out.println(JsonUtil.getXMLFromObj(set));     
  389.         /*  print:   
  390.             <?xml version="1.0" encoding="UTF-8"?>   
  391.             <a>   
  392.                 <e class="object">   
  393.                     <dateAttr type="string">2009-09-12 07:04:38</dateAttr>   
  394.                     <name type="string">get</name>   
  395.                 </e>   
  396.             </a>   
  397.          */    
  398.     }     
  399.     
  400.     /**   
  401.      * map转XML   
  402.      *  void   
  403.      */    
  404.     public void testGetXMLFromObj6() {     
  405.         Person ps = new Person();     
  406.         ps.setDateAttr(new Date());     
  407.         ps.setName("get");     
  408.         Map map = new HashMap();     
  409.         map.put("person1", ps);     
  410.     
  411.         System.out.println(JsonUtil.getXMLFromObj(map));     
  412.         /*  print:   
  413.             <?xml version="1.0" encoding="UTF-8"?>   
  414.             <o>   
  415.                 <person1 class="object">   
  416.                     <dateAttr type="string">2009-09-12 07:08:35</dateAttr>   
  417.                     <name type="string">get</name>   
  418.                 </person1>   
  419.             </o>   
  420.          */    
  421.     }     
  422.     
  423.     /**   
  424.      * 实体Bean转XML   
  425.      *  void   
  426.      */    
  427.     public void testGetXMLFromObj7() {     
  428.         Person ps = new Person();     
  429.         ps.setDateAttr(new Date());     
  430.         ps.setName("get");     
  431.         System.out.println(JsonUtil.getXMLFromObj(ps));     
  432.         /*  print:   
  433.             <?xml version="1.0" encoding="UTF-8"?>   
  434.             <o>   
  435.                 <dateAttr type="string">2009-09-12 07:13:02</dateAttr>   
  436.                 <name type="string">get</name>   
  437.             </o>   
  438.          */    
  439.     }     
  440.     
  441.     /**   
  442.      * 从XML对象串转json串   
  443.      *  void   
  444.      */    
  445.     public void testGetJsonStrFromXML1() {     
  446.         String xml = "<o><dateAttr type=‘string‘>2009-09-12 07:13:02</dateAttr>"    
  447.                 + "<name type=‘string‘>get</name></o>";     
  448.         //print: {"dateAttr":"2009-09-12 07:13:02","name":"get"}     
  449.         System.out.println(JsonUtil.getJsonStrFromXML(xml));     
  450.     }     
  451.     
  452.     /**   
  453.      * 从XML数组串转json串   
  454.      *  void   
  455.      */    
  456.     public void testGetJsonStrFromXML2() {     
  457.         String xml = "<a class=‘array‘><e class=‘object‘><dateAttr type=‘string‘>2009-09-12 07:04:38</dateAttr>"    
  458.                 + "<name type=‘string‘>get</name></e></a>";     
  459.         //print: [{"dateAttr":"2009-09-12 07:04:38","name":"get"}]     
  460.         System.out.println(JsonUtil.getJsonStrFromXML(xml));     
  461.     }     
  462. }  




JsonUtil工具类

原文：http://www.cnblogs.com/dengbz/p/5553831.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！