Android輕量級JSON序列化和反序列化

1. package com.callgetway.util;
3. import java.lang.reflect.Array;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.Method;
6. import java.lang.reflect.ParameterizedType;
7. import java.lang.reflect.Type;
8. import java.text.SimpleDateFormat;
9. import java.util.Collection;
10. import java.util.Date;
11. import java.util.HashMap;
12. import java.util.Iterator;
13. import java.util.List;
14. import java.util.Locale;
15. import java.util.Map;
17. import org.json.JSONArray;
18. import org.json.JSONException;
19. import org.json.JSONObject;
20. import org.json.JSONStringer;
22. import Android.util.Log;
25. /**
26. * @author keane
27. * @version 1.0
28. *
29. */
30. public class JSONHelper {
32. private static String TAG = "JSONHelper";
34. /**
35. * 將對象轉換成Json字符串
36. * @param obj
37. * @return
38. */
39. public static String toJSON(Object obj) {
40. JSONStringer js = new JSONStringer();
41. serialize(js, obj);
42. Log.d(TAG, "JSONHelper toJSON :" + js.toString());
43. return js.toString();
44. }
46. /**
47. * 序列化為JSON
48. * @param js
49. * @param o
50. */
51. private static void serialize(JSONStringer js, Object o) {
52. if (isNull(o)) {
53. try {
54. js.value(null);
55. } catch (JSONException e) {
56. e.printStackTrace();
57. }
58. return;
59. }
61. Class<?> clazz = o.getClass();
62. if (isObject(clazz)) { // 對象
63. serializeObject(js, o);
64. } else if (isArray(clazz)) { // 數組
65. serializeArray(js, o);
66. } else if (isCollection(clazz)) { // 集合
67. Collection<?> collection = (Collection<?>) o;
68. serializeCollect(js, collection);
69. } else { // 單個值
70. try {
71. js.value(o);
72. } catch (JSONException e) {
73. e.printStackTrace();
74. }
75. }
76. }
78. /**
79. * 序列化數組
80. * @param js
81. * @param array
82. */
83. private static void serializeArray(JSONStringer js, Object array) {
84. try {
85. js.array();
86. for (int i = 0; i < Array.getLength(array); ++i) {
87. Object o = Array.get(array, i);
88. serialize(js, o);
89. }
90. js.endArray();
91. } catch (Exception e) {
92. e.printStackTrace();
93. }
94. }
96. /**
97. * 序列化集合
98. * @param js
99. * @param collection
100. */
101. private static void serializeCollect(JSONStringer js, Collection<?> collection) {
102. try {
103. js.array();
104. for (Object o : collection) {
105. serialize(js, o);
106. }
107. js.endArray();
108. } catch (Exception e) {
109. e.printStackTrace();
110. }
111. }
113. /**
114. * 序列化對象
115. * @param js
116. * @param obj
117. */
118. private static void serializeObject(JSONStringer js, Object obj) {
119. try {
120. js.object();
121. Class<? extends Object> objClazz = obj.getClass();
122. Method[] methods = objClazz.getDeclaredMethods();
123. Field[] fields = objClazz.getDeclaredFields();
124. for (Field field : fields) {
125. try {
126. String fieldType = field.getType().getSimpleName();
127. String fieldGetName = parseMethodName(field.getName(),"get");
128. if (!haveMethod(methods, fieldGetName)) {
129. continue;
130. }
131. Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});
132. Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
133. String result = null;
134. if ("Date".equals(fieldType)) {
135. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",
136. Locale.US);
137. result = sdf.format((Date)fieldVal);
139. } else {
140. if (null != fieldVal) {
141. result = String.valueOf(fieldVal);
142. }
143. }
144. js.key(field.getName());
145. serialize(js, result);
146. } catch (Exception e) {
147. continue;
148. }
149. }
150. js.endObject();
151. } catch (Exception e) {
152. e.printStackTrace();
153. }
154. }
156. /**
157. * 判斷是否存在某屬性的 get方法
158. *
159. * @param methods
160. * @param fieldGetMet
161. * @return boolean
162. */
163. public static boolean haveMethod(Method[] methods, String fieldMethod) {
164. for (Method met : methods) {
165. if (fieldMethod.equals(met.getName())) {
166. return true;
167. }
168. }
169. return false;
170. }
172. /**
173. * 拼接某屬性的 get或者set方法
174. * @param fieldName
175. * @param methodType
176. * @return
177. */
178. public static String parseMethodName(String fieldName,String methodType) {
179. if (null == fieldName || "".equals(fieldName)) {
180. return null;
181. }
182. return methodType + fieldName.substring(0, 1).toUpperCase()
183. + fieldName.substring(1);
184. }
188. /**
189. * set屬性的值到Bean
190. * @param obj
191. * @param valMap
192. */
193. public static void setFieldValue(Object obj, Map<String, String> valMap) {
194. Class<?> cls = obj.getClass();
195. // 取出bean裡的所有方法
196. Method[] methods = cls.getDeclaredMethods();
197. Field[] fields = cls.getDeclaredFields();
199. for (Field field : fields) {
200. try {
201. String setMetodName = parseMethodName(field.getName(),"set");
202. if (!haveMethod(methods, setMetodName)) {
203. continue;
204. }
205. Method fieldMethod = cls.getMethod(setMetodName, field
206. .getType());
207. String value = valMap.get(field.getName());
208. if (null != value && !"".equals(value)) {
209. String fieldType = field.getType().getSimpleName();
210. if ("String".equals(fieldType)) {
211. fieldMethod.invoke(obj, value);
212. } else if ("Date".equals(fieldType)) {
213. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);
214. Date temp = sdf.parse(value);
215. fieldMethod.invoke(obj, temp);
216. } else if ("Integer".equals(fieldType)
217. || "int".equals(fieldType)) {
218. Integer intval = Integer.parseInt(value);
219. fieldMethod.invoke(obj, intval);
220. } else if ("Long".equalsIgnoreCase(fieldType)) {
221. Long temp = Long.parseLong(value);
222. fieldMethod.invoke(obj, temp);
223. } else if ("Double".equalsIgnoreCase(fieldType)) {
224. Double temp = Double.parseDouble(value);
225. fieldMethod.invoke(obj, temp);
226. } else if ("Boolean".equalsIgnoreCase(fieldType)) {
227. Boolean temp = Boolean.parseBoolean(value);
228. fieldMethod.invoke(obj, temp);
229. } else {
230. System.out.println("setFieldValue not supper type:" + fieldType);
231. }
232. }
233. } catch (Exception e) {
234. continue;
235. }
236. }
238. }
240. /**
241. * 對象轉Map
242. * @param obj
243. * @return
244. */
245. public static Map<String, String> getFieldValueMap(Object obj) {
246. Class<?> cls = obj.getClass();
247. Map<String, String> valueMap = new HashMap<String, String>();
248. // 取出bean裡的所有方法
249. Method[] methods = cls.getDeclaredMethods();
250. Field[] fields = cls.getDeclaredFields();
251. for (Field field : fields) {
252. try {
253. String fieldType = field.getType().getSimpleName();
254. String fieldGetName = parseMethodName(field.getName(),"get");
255. if (!haveMethod(methods, fieldGetName)) {
256. continue;
257. }
258. Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});
259. Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
260. String result = null;
261. if ("Date".equals(fieldType)) {
262. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);
263. result = sdf.format((Date)fieldVal);
265. } else {
266. if (null != fieldVal) {
267. result = String.valueOf(fieldVal);
268. }
269. }
270. valueMap.put(field.getName(), result);
271. } catch (Exception e) {
272. continue;
273. }
274. }
275. return valueMap;
277. }
281. /**
282. * 給對象的字段賦值
283. * @param obj
284. * @param fieldSetMethod
285. * @param fieldType
286. * @param value
287. */
288. public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){
290. try {
291. if (null != value && !"".equals(value)) {
292. if ("String".equals(fieldType)) {
293. fieldSetMethod.invoke(obj, value.toString());
294. } else if ("Date".equals(fieldType)) {
295. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);
296. Date temp = sdf.parse(value.toString());
297. fieldSetMethod.invoke(obj, temp);
298. } else if ("Integer".equals(fieldType)
299. || "int".equals(fieldType)) {
300. Integer intval = Integer.parseInt(value.toString());
301. fieldSetMethod.invoke(obj, intval);
302. } else if ("Long".equalsIgnoreCase(fieldType)) {
303. Long temp = Long.parseLong(value.toString());
304. fieldSetMethod.invoke(obj, temp);
305. } else if ("Double".equalsIgnoreCase(fieldType)) {
306. Double temp = Double.parseDouble(value.toString());
307. fieldSetMethod.invoke(obj, temp);
308. } else if ("Boolean".equalsIgnoreCase(fieldType)) {
309. Boolean temp = Boolean.parseBoolean(value.toString());
310. fieldSetMethod.invoke(obj, temp);
311. } else {
312. fieldSetMethod.invoke(obj, value);
313. Log.e(TAG, TAG + ">>>>setFiedlValue -> not supper type" + fieldType);
314. }
315. }
317. } catch (Exception e) {
318. Log.e(TAG, TAG + ">>>>>>>>>>set value error.",e);
319. }
321. }
324. /**
325. * 反序列化簡單對象
326. * @param jo
327. * @param clazz
328. * @return
329. */
330. public static <T> T parseObject(JSONObject jo, Class<T> clazz) {
331. if (clazz == null || isNull(jo)) {
332. return null;
333. }
335. T obj = newInstance(clazz);
336. if (obj == null) {
337. return null;
338. }
339. if(isMap(clazz)){
340. setField(obj,jo);
341. }else{
342. // 取出bean裡的所有方法
343. Method[] methods = clazz.getDeclaredMethods();
344. Field[] fields = clazz.getDeclaredFields();
345. for (Field f : fields) {
346. String setMetodName = parseMethodName(f.getName(),"set");
347. if (!haveMethod(methods, setMetodName)) {
348. continue;
349. }
350. try {
351. Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
352. setField(obj,fieldMethod,f, jo);
353. } catch (Exception e) {
354. e.printStackTrace();
355. }
356. }
357. }
358. return obj;
359. }
362. /**
363. * 反序列化簡單對象
364. * @param jsonString
365. * @param clazz
366. * @return
367. */
368. public static <T> T parseObject(String jsonString, Class<T> clazz) {
369. if (clazz == null || jsonString == null || jsonString.length() == 0) {
370. return null;
371. }
373. JSONObject jo = null;
374. try {
375. jo = new JSONObject(jsonString);
376. } catch (JSONException e) {
377. e.printStackTrace();
378. }
380. if (isNull(jo)) {
381. return null;
382. }
384. return parseObject(jo, clazz);
385. }
387. /**
388. * 反序列化數組對象
389. * @param ja
390. * @param clazz
391. * @return
392. */
393. public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
394. if (clazz == null || isNull(ja)) {
395. return null;
396. }
398. int len = ja.length();
400. @SuppressWarnings("unchecked")
401. T[] array = (T[]) Array.newInstance(clazz, len);
403. for (int i = 0; i < len; ++i) {
404. try {
405. JSONObject jo = ja.getJSONObject(i);
406. T o = parseObject(jo, clazz);
407. array[i] = o;
408. } catch (JSONException e) {
409. e.printStackTrace();
410. }
411. }
413. return array;
414. }
417. /**
418. * 反序列化數組對象
419. * @param jsonString
420. * @param clazz
421. * @return
422. */
423. public static <T> T[] parseArray(String jsonString, Class<T> clazz) {
424. if (clazz == null || jsonString == null || jsonString.length() == 0) {
425. return null;
426. }
427. JSONArray jo = null;
428. try {
429. jo = new JSONArray(jsonString);
430. } catch (JSONException e) {
431. e.printStackTrace();
432. }
434. if (isNull(jo)) {
435. return null;
436. }
438. return parseArray(jo, clazz);
439. }
441. /**
442. * 反序列化泛型集合
443. * @param ja
444. * @param collectionClazz
445. * @param genericType
446. * @return
447. */
448. @SuppressWarnings("unchecked")
449. public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,
450. Class<T> genericType) {
452. if (collectionClazz == null || genericType == null || isNull(ja)) {
453. return null;
454. }
456. Collection<T> collection = (Collection<T>) newInstance(collectionClazz);
458. for (int i = 0; i < ja.length(); ++i) {
459. try {
460. JSONObject jo = ja.getJSONObject(i);
461. T o = parseObject(jo, genericType);
462. collection.add(o);
463. } catch (JSONException e) {
464. e.printStackTrace();
465. }
466. }
468. return collection;
469. }
471. /**
472. * 反序列化泛型集合
473. * @param jsonString
474. * @param collectionClazz
475. * @param genericType
476. * @return
477. */
478. public static <T> Collection<T> parseCollection(String jsonString, Class<?> collectionClazz,
479. Class<T> genericType) {
480. if (collectionClazz == null || genericType == null || jsonString == null
481. || jsonString.length() == 0) {
482. return null;
483. }
484. JSONArray jo = null;
485. try {
486. jo = new JSONArray(jsonString);
487. } catch (JSONException e) {
488. e.printStackTrace();
489. }
491. if (isNull(jo)) {
492. return null;
493. }
495. return parseCollection(jo, collectionClazz, genericType);
496. }
498. /**
499. * 根據類型創建對象
500. * @param clazz
501. * @return
502. */
503. private static <T> T newInstance(Class<T> clazz) {
504. if (clazz == null)
505. return null;
506. T obj = null;
507. try {
508. obj = clazz.newInstance();
509. } catch (Exception e) {
510. e.printStackTrace();
511. }
512. return obj;
513. }
515. /**
516. * 設定Map的值
517. * @param obj
518. * @param jo
519. */
520. private static void setField(Object obj, JSONObject jo) {
521. try {
522. @SuppressWarnings("unchecked")
523. Iterator<String> keyIter = jo.keys();
524. String key;
525. Object value;
526. @SuppressWarnings("unchecked")
527. Map<String, Object> valueMap = (Map<String, Object>) obj;
528. while (keyIter.hasNext()) {
529. key = (String) keyIter.next();
530. value = jo.get(key);
531. valueMap.put(key, value);
533. }
534. } catch (JSONException e) {
535. e.printStackTrace();
536. }
537. }
540. /**
541. * 設定字段的值
542. * @param obj
543. * @param fieldSetMethod
544. * @param f
545. * @param jo
546. */
547. private static void setField(Object obj, Method fieldSetMethod,Field f, JSONObject jo) {
548. String name = f.getName();
549. Class<?> clazz = f.getType();
550. try {
551. if (isArray(clazz)) { // 數組
552. Class<?> c = clazz.getComponentType();
553. JSONArray ja = jo.optJSONArray(name);
554. if (!isNull(ja)) {
555. Object array = parseArray(ja, c);
556. setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);
557. }
558. } else if (isCollection(clazz)) { // 泛型集合
559. // 獲取定義的泛型類型
560. Class<?> c = null;
561. Type gType = f.getGenericType();
562. if (gType instanceof ParameterizedType) {
563. ParameterizedType ptype = (ParameterizedType) gType;
564. Type[] targs = ptype.getActualTypeArguments();
565. if (targs != null && targs.length > 0) {
566. Type t = targs[0];
567. c = (Class<?>) t;
568. }
569. }
571. JSONArray ja = jo.optJSONArray(name);
572. if (!isNull(ja)) {
573. Object o = parseCollection(ja, clazz, c);
574. setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
575. }
576. } else if (isSingle(clazz)) { // 值類型
577. Object o = jo.opt(name);
578. if (o != null) {
579. setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
580. }
581. } else if (isObject(clazz)) { // 對象
582. JSONObject j = jo.optJSONObject(name);
583. if (!isNull(j)) {
584. Object o = parseObject(j, clazz);
585. setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
586. }
587. } else if (isList(clazz)) { // 列表
588. // JSONObject j = jo.optJSONObject(name);
589. // if (!isNull(j)) {
590. // Object o = parseObject(j, clazz);
591. // f.set(obj, o);
592. // }
593. } else {
594. throw new Exception("unknow type!");
595. }
596. } catch (Exception e) {
597. e.printStackTrace();
598. }
599. }
601. /**
602. * 設定字段的值
603. * @param obj
604. * @param f
605. * @param jo
606. */
607. private static void setField(Object obj, Field f, JSONObject jo) {
608. String name = f.getName();
609. Class<?> clazz = f.getType();
610. try {
611. if (isArray(clazz)) { // 數組
612. Class<?> c = clazz.getComponentType();
613. JSONArray ja = jo.optJSONArray(name);
614. if (!isNull(ja)) {
615. Object array = parseArray(ja, c);
616. f.set(obj, array);
617. }
618. } else if (isCollection(clazz)) { // 泛型集合
619. // 獲取定義的泛型類型
620. Class<?> c = null;
621. Type gType = f.getGenericType();
622. if (gType instanceof ParameterizedType) {
623. ParameterizedType ptype = (ParameterizedType) gType;
624. Type[] targs = ptype.getActualTypeArguments();
625. if (targs != null && targs.length > 0) {
626. Type t = targs[0];
627. c = (Class<?>) t;
628. }
629. }
631. JSONArray ja = jo.optJSONArray(name);
632. if (!isNull(ja)) {
633. Object o = parseCollection(ja, clazz, c);
634. f.set(obj, o);
635. }
636. } else if (isSingle(clazz)) { // 值類型
637. Object o = jo.opt(name);
638. if (o != null) {
639. f.set(obj, o);
640. }
641. } else if (isObject(clazz)) { // 對象
642. JSONObject j = jo.optJSONObject(name);
643. if (!isNull(j)) {
644. Object o = parseObject(j, clazz);
645. f.set(obj, o);
646. }
647. } else if (isList(clazz)) { // 列表
648. JSONObject j = jo.optJSONObject(name);
649. if (!isNull(j)) {
650. Object o = parseObject(j, clazz);
651. f.set(obj, o);
652. }
653. }else {
654. throw new Exception("unknow type!");
655. }
656. } catch (Exception e) {
657. e.printStackTrace();
658. }
659. }
661. /**
662. * 判斷對象是否為空
663. * @param obj
664. * @return
665. */
666. private static boolean isNull(Object obj) {
667. if (obj instanceof JSONObject) {
668. return JSONObject.NULL.equals(obj);
669. }
670. return obj == null;
671. }
673. /**
674. * 判斷是否是值類型
675. * @param clazz
676. * @return
677. */
678. private static boolean isSingle(Class<?> clazz) {
679. return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
680. }
682. /**
683. * 是否布爾值
684. * @param clazz
685. * @return
686. */
687. public static boolean isBoolean(Class<?> clazz) {
688. return (clazz != null)
689. && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
690. .isAssignableFrom(clazz)));
691. }
693. /**
694. * 是否數值
695. * @param clazz
696. * @return
697. */
698. public static boolean isNumber(Class<?> clazz) {
699. return (clazz != null)
700. && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))
701. || (Integer.TYPE.isAssignableFrom(clazz))
702. || (Long.TYPE.isAssignableFrom(clazz))
703. || (Float.TYPE.isAssignableFrom(clazz))
704. || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
705. .isAssignableFrom(clazz)));
706. }
708. /**
709. * 判斷是否是字符串
710. * @param clazz
711. * @return
712. */
713. public static boolean isString(Class<?> clazz) {
714. return (clazz != null)
715. && ((String.class.isAssignableFrom(clazz))
716. || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
717. .isAssignableFrom(clazz)));
718. }
720. /**
721. * 判斷是否是對象
722. * @param clazz
723. * @return
724. */
725. private static boolean isObject(Class<?> clazz) {
726. return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz);
727. }
729. /**
730. * 判斷是否是數組
731. * @param clazz
732. * @return
733. */
734. public static boolean isArray(Class<?> clazz) {
735. return clazz != null && clazz.isArray();
736. }
738. /**
739. * 判斷是否是集合
740. * @param clazz
741. * @return
742. */
743. public static boolean isCollection(Class<?> clazz) {
744. return clazz != null && Collection.class.isAssignableFrom(clazz);
745. }
747. /**
748. * 判斷是否是Map
749. * @param clazz
750. * @return
751. */
752. public static boolean isMap(Class<?> clazz) {
753. return clazz != null && Map.class.isAssignableFrom(clazz);
754. }
756. /**
757. * 判斷是否是列表
758. * @param clazz
759. * @return
760. */
761. public static boolean isList(Class<?> clazz) {
762. return clazz != null && List.class.isAssignableFrom(clazz);
763. }
766. }

測試代碼：

1. public class User{
2. private String name;
3. private String password;
4. public String getName() {
5. return name;
6. }
7. public void setName(String name) {
8. this.name = name;
9. }
10. public String getPassword() {
11. return password;
12. }
13. public void setPassword(String password) {
14. this.password = password;
15. }
17. }
19. void testObj(){
20. User user = new User();
21. user.setName("abcd");
22. user.setPassword("123456");
23. String jsonStrUser = JSONHelper.toJSON(user);
24. User jsonUser = JSONHelper.parseObject(jsonStrUser, User.class);
25. Map mapUser = JSONHelper.parseObject(jsonStrUser, HashMap.class);
26. }