jsonutil 学习使用

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. }  

package comm;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.sf.ezmorph.MorpherRegistry;
import net.sf.ezmorph.object.DateMorpher;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
import net.sf.json.util.JSONUtils;
import net.sf.json.xml.XMLSerializer;

public class JsonUtil {

	/**
	 * 设置日期转换格式
	 */
	static {
		//注册器
		MorpherRegistry mr = JSONUtils.getMorpherRegistry();

		//可转换的日期格式，即Json串中可以出现以下格式的日期与时间
		DateMorpher dm = new DateMorpher(new String[] { Util.YYYY_MM_DD,
				Util.YYYY_MM_DD_HH_MM_ss, Util.HH_MM_ss, Util.YYYYMMDD,
				Util.YYYYMMDDHHMMSS, Util.HHMMss });
		mr.registerMorpher(dm);
	}

	/**
	* 从json串转换成实体对象
	* @param jsonObjStr e.g. {'name':'get','dateAttr':'2009-11-12'}
	* @param clazz Person.class
	* @return
	*/
	public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {
		return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);
	}

	/**
	* 从json串转换成实体对象，并且实体集合属性存有另外实体Bean
	* @param jsonObjStr e.g. {'data':[{'name':'get'},{'name':'set'}]}
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return Object
	*/
	public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
		return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);
	}

	/**
	* 把一个json数组串转换成普通数组
	* @param jsonArrStr  e.g. ['get',1,true,null]
	* @return Object[]
	*/
	public static Object[] getArrFromJsonArrStr(String jsonArrStr) {
		return JSONArray.fromObject(jsonArrStr).toArray();
	}

	/**
	* 把一个json数组串转换成实体数组
	* @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
	* @param clazz e.g. Person.class
	* @return Object[]
	*/
	public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		Object[] objArr = new Object[jsonArr.size()];
		for (int i = 0; i < jsonArr.size(); i++) {
			objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);
		}
		return objArr;
	}

	/**
	* 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean
	* @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return Object[]
	*/
	public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,
			Map classMap) {
		JSONArray array = JSONArray.fromObject(jsonArrStr);
		Object[] obj = new Object[array.size()];
		for (int i = 0; i < array.size(); i++) {
			JSONObject jsonObject = array.getJSONObject(i);
			obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);
		}
		return obj;
	}

	/**
	* 把一个json数组串转换成存放普通类型元素的集合
	* @param jsonArrStr  e.g. ['get',1,true,null]
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(jsonArr.get(i));
		}
		return list;
	}

	/**
	* 把一个json数组串转换成集合，且集合里存放的为实例Bean
	* @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
	* @param clazz
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));
		}
		return list;
	}

	/**
	* 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean
	* @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));
		}
		return list;
	}

	/**
	* 把json对象串转换成map对象
	* @param jsonObjStr e.g. {'name':'get','int':1,'double',1.1,'null':null}
	* @return Map
	*/
	public static Map getMapFromJsonObjStr(String jsonObjStr) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, jsonObject.get(key));
		}
		return map;
	}

	/**
	* 把json对象串转换成map对象，且map对象里存放的为其他实体Bean
	* @param jsonObjStr e.g. {'data1':{'name':'get'},'data2':{'name':'set'}}
	* @param clazz e.g. Person.class
	* @return Map
	*/
	public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));
		}
		return map;
	}

	/**
	 * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean
	 * @param jsonObjStr e.g. {'mybean':{'data':[{'name':'get'}]}}
	 * @param clazz e.g. MyBean.class
	 * @param classMap	e.g. classMap.put("data", Person.class)
	 * @return Map
	 */
	public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, JSONObject
					.toBean(jsonObject.getJSONObject(key), clazz, classMap));
		}
		return map;
	}

	/**
	 * 把实体Bean、Map对象、数组、列表集合转换成Json串
	 * @param obj 
	 * @return
	 * @throws Exception String
	 */
	public static String getJsonStr(Object obj) {
		String jsonStr = null;
		//Json配置    
		JsonConfig jsonCfg = new JsonConfig();

		//注册日期处理器
		jsonCfg.registerJsonValueProcessor(java.util.Date.class,
				new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));
		if (obj == null) {
			return "{}";
		}

		if (obj instanceof Collection || obj instanceof Object[]) {
			jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();
		} else {
			jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();
		}

		return jsonStr;
	}

	/**
	 * 把json串、数组、集合(collection map)、实体Bean转换成XML
	 * XMLSerializer API：
	 * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html
	 * 具体实例请参考：
	 * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
	 * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
	 * @param obj 
	 * @return
	 * @throws Exception String
	 */
	public static String getXMLFromObj(Object obj) {
		XMLSerializer xmlSerial = new XMLSerializer();

		//Json配置    
		JsonConfig jsonCfg = new JsonConfig();

		//注册日期处理器
		jsonCfg.registerJsonValueProcessor(java.util.Date.class,
				new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));

		if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith("["))
				|| obj.getClass().isArray() || Collection.class.isInstance(obj)) {
			JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);
			return xmlSerial.write(jsonArr);
		} else {
			JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);
			return xmlSerial.write(jsonObj);
		}
	}

	/**
	 * 从XML转json串
	 * @param xml
	 * @return String
	 */
	public static String getJsonStrFromXML(String xml) {
		XMLSerializer xmlSerial = new XMLSerializer();
		return String.valueOf(xmlSerial.read(xml));
	}

}

/**
 * json日期值处理器实现  
 * (C) 2009-9-11, jzj
 */
class JsonDateValueProcessor implements JsonValueProcessor {

	private String format = Util.YYYY_MM_DD_HH_MM_ss;

	public JsonDateValueProcessor() {

	}

	public JsonDateValueProcessor(String format) {
		this.format = format;
	}

	public Object processArrayValue(Object value, JsonConfig jsonConfig) {
		return process(value, jsonConfig);
	}

	public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
		return process(value, jsonConfig);
	}

	private Object process(Object value, JsonConfig jsonConfig) {
		if (value instanceof Date) {
			String str = new SimpleDateFormat(format).format((Date) value);
			return str;
		}
		return value == null ? null : value.toString();
	}

	public String getFormat() {
		return format;
	}

	public void setFormat(String format) {
		this.format = format;
	}

}

• JsonUtilTest

Java代码  

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. }