JsonUtil工具类

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

JsonUtilTest

[java] view plain copy

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

JsonUtil工具类的相关文章

JsonUtil(工具类)

WebBuilder使用的操作json的jar包是org.json,下面是相关的文档及源码,搜索就可得 文档:http://www.json.org/javadoc/org/json/JSONObject.html 源码:https://github.com/douglascrockford/JSON-java 本文默认读者熟练使用JSON,了解JSON语法,开始正题: 从文档和源码看来org.json没有多少东西,的确他就是很简单,没有多少东西,在这几个仅有的类中,我们要经常使用也只有JSON

利用Jackson封装常用JsonUtil工具类

在日常的项目开发中,接口与接口之间.前后端之间的数据传输一般都是使用JSON格式,那必然会封装一些常用的Json数据转化的工具类,本文讲解下如何利用Jackson封装高复用性的Json转换工具类. 转换格式属性配置 首先,我们需要对Json对象转换自定义些常用配置属性,封装成适合项目接口规则的工具类.代码如下: @Slf4j public class JsonUtil { private static ObjectMapper objectMapper = new ObjectMapper();

Code片段 ： .properties属性文件操作工具类 &amp; JSON工具类

摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢! “贵专” — 泥瓦匠 一.java.util.Properties API & 案例 java.util.Properties 是一个属性集合.常见的api有如下: load(InputStream inStream)  从输入流中读取属性 getProperty(String key)  根据key,获取属性值 getOrDefault(Object key, V defaultValue)

web开发工具类

1.日期工具类 import java.text.SimpleDateFormat; import java.util.Date; public class DateUtil { public static String formatDate(Date date,String format){ String result=""; SimpleDateFormat sdf=new SimpleDateFormat(format); if(date!=null){ result=sdf.f

捕获异常、存sd卡、封装请求头体、加密map值、网络工具类、生成Json、Https协议、传log日志到服务器、app崩溃友好重启

点击打开链接,免积分下载 在集成了统计SDK(友盟统计,百度统计等)之后,有一个非常有利于测试的功能:错误分析!此功能能够将程序在运行中碰到的崩溃(runtimeException)问题反馈到服务器,帮助开发者改善产品,多适配机器.然而在公司android开发中不集成这些SDK,那应该怎么实现这样的功能呢?下面让我们来看下如何使用UncaughtExceptionHandler来捕获异常. 在Android开发中,常常会出现uncheched Exception 导致程序的crash,为了提供良

利用线程创建发送手机验证码的工具类

1.生成验证码类 package com.util; import java.util.Timer; import java.util.TimerTask; /** * @description 手机发送验证码工具类 */ public class MessageCode extends TimerTask{ private Timer timer; /** * @description 短信验证码的内容 */ private String messageCode; /** * @descrip

《项目架构那点儿事》——工具类，你喜欢你就拿去

[前言]众所周知,各式各样的Util类为我们提供了便利,也同时减少了我们对底层硬编码的时间,包括对字符串的操作,文件操作,反射的操作,泛型的操作,以及熟知 的分页类,Json解析类.日期工具类等,这里把我开发的项目中用到过的工具类分享出来,都是经过多个项目的开发积累而锤炼出来的,提供给大家交流和学 习. [目录]            1.文件操作类 FileUtil            2.反射工具类 ReflectionUtil            3.泛型工具类 GenericsUti

Android 常用工具类

1.DensityUtils /** * 常用单位转换的辅助类 */ public class DensityUtils { private DensityUtils() { /* cannot be instantiated */ throw new UnsupportedOperationException("cannot be instantiated"); } /** * dp转px * * @param context * @param dpVal * @return */

总结的一些json格式和对象/String/Map/List等的互转工具类

原文:总结的一些json格式和对象/String/Map/List等的互转工具类 源代码下载地址:http://www.zuidaima.com/share/1550463691508736.htm 总结的一些json格式和对象/String/Map/List等的互转工具类,有需要的可以看看,需要引入jackson-core-asl-1.7.1.jar.jackson-jaxrs-1.7.1.jar.jackson-mapper-asl-1.7.1.jar这三个jar包 package com.