Android 学习笔记之 JSON的序列化基本用法

最近在找怎样可以将一个数据对象通过WCF传给服务器,在网上看到了一个对象序列化成JSON的数据格式的帖子,这里整理下。

用到了JSON中的JSONStringer这个类,此类的主要功能就是可以快速的将一个数据类型序列化,成为一个标准的JSON数据。

其中需要注意的是:

.object()和.endObject()必须同时使用,是为了按照Object标准给数值添加边界。同样,针对数组也有一组标准的方法来生成边界.array()和.endArray()。

基本原理就是一个数据传入先判断它是属于哪个类型,再根据具体的类型进行序列化(对象,数组,集合,Map,单个的基础数据类型如String)。

我是以对象为列子的

一、数据对象

 1 public class ListInfoObj {
 2 
 3     private List<String> Names;
 4     private List<String> Sixs;
 5 
 6     public List<String> getNames() {
 7         return Names;
 8     }
 9 
10     public void setNames(List<String> names) {
11         Names = names;
12     }
13 
14     public List<String> getSixs() {
15         return Sixs;
16     }
17 
18     public void setSixs(List<String> sixs) {
19         Sixs = sixs;
20     }

二、主界面(初始化对象并赋值)调用序列化方法

 1 public class MainActivity extends Activity {
 2     private Button toJsonBut;
 3     private TextView msgView;
 4     private ListInfoObj mListInfoObj;
 5 
 6     @Override
 7     protected void onCreate(Bundle savedInstanceState) {
 8         super.onCreate(savedInstanceState);
 9         setContentView(R.layout.activity_main);
10         this.toJsonBut = (Button) this.findViewById(R.id.tojson);
11         this.msgView = (TextView) this.findViewById(R.id.msg);
12         this.toJsonBut.setOnClickListener(listener);
13     }
14 
15     View.OnClickListener listener = new View.OnClickListener() {
16 
17         @Override
18         public void onClick(View v) {
19             // TODO Auto-generated method stub
20             String jsonList;
21             //初始化对象并赋值
22             getObj();
23             //对象序列化
24             ObjtoJson blObjtoJson = new ObjtoJson();
25             jsonList = blObjtoJson.toJson(mListInfoObj);
26             //显示数据
27             msgView.setText(jsonList);
28 
29         }
30     };
31 
32     /**
33      * 给数据对象赋值
34      */
35     private void getObj() {    
36         this.mListInfoObj = new ListInfoObj();
37         List<String> name = new ArrayList<String>();
38         name.add("大宝");
39         name.add("中宝");
40         name.add("小宝");
41         List<String> six = new ArrayList<String>();
42         six.add("男");
43         six.add("妖");
44         six.add("女");
45         this.mListInfoObj.setNames(name);
46         this.mListInfoObj.setSixs(six);
47     }

三、JSON序列化(这才是主菜)

  1 public class ObjtoJson {
  2 
  3     public String toJson(Object obj) {
  4         String jsonStr = null;
  5         //生成一个JSONStringer对象
  6         JSONStringer js = new JSONStringer();
  7         //调用序列化方法
  8         serialize(js, obj);
  9         //转换成字符串
 10         jsonStr = js.toString();
 11         return jsonStr;
 12     }
 13 
 14     /**
 15      * 根据所传的数据类型进行序列化
 16      * @param js
 17      * @param obj  传入的数据类型
 18      */
 19     private static void serialize(JSONStringer js, Object obj) {
 20         //判断是否为空
 21         if (isNull(obj)) {
 22             try {
 23                 js.value(null);
 24             } catch (Exception e) {
 25                 // TODO: handle exception
 26                 Log.i("js赋值异常", e.toString());
 27             }
 28         }
 29         Class<?> clazz = obj.getClass();
 30         if (isObject(clazz)) { // 对象
 31             serializeObject(js, obj);
 32         } else if (isArray(clazz)) { // 数组
 33             serializeArray(js, obj);
 34         } else if (isCollection(clazz)) { // 集合
 35             Collection<?> collection = (Collection<?>) obj;
 36             serializeCollect(js, collection);
 37         } else if (isMap(clazz)) { // 集合
 38             HashMap<?, ?> collection = (HashMap<?, ?>) obj;
 39             serializeMap(js, collection);
 40         } else { // 单个值
 41             try {
 42                 js.value(obj);
 43             } catch (JSONException e) {
 44                 e.printStackTrace();
 45             }
 46         }
 47 
 48     }
 49 
 50     /**
 51      * 序列化数组
 52      * 
 53      * @param js
 54      *            json对象
 55      * @param array
 56      *            数组
 57      */
 58     private static void serializeArray(JSONStringer js, Object array) {
 59         try {
 60             js.array();
 61             for (int i = 0; i < Array.getLength(array); ++i) {
 62                 Object o = Array.get(array, i);
 63                 //回调序列化方法
 64                 serialize(js, o);
 65             }
 66             js.endArray();
 67         } catch (Exception e) {
 68             e.printStackTrace();
 69         }
 70     }
 71 
 72     /**
 73      * 序列化集合
 74      * 
 75      * @param js
 76      *            json对象
 77      * @param collection
 78      *            集合
 79      */
 80     private static void serializeCollect(JSONStringer js,
 81             Collection<?> collection) {
 82         try {
 83             js.array();
 84             for (Object o : collection) {
 85                 serialize(js, o);
 86             }
 87             js.endArray();
 88         } catch (Exception e) {
 89             e.printStackTrace();
 90         }
 91     }
 92 
 93     /**
 94      * 序列化Map
 95      * 
 96      * @param js
 97      *            json对象
 98      * @param map
 99      *            map对象
100      */
101     private static void serializeMap(JSONStringer js, Map<?, ?> map) {
102         try {
103             js.object();
104             @SuppressWarnings("unchecked")
105             Map<String, Object> valueMap = (Map<String, Object>) map;
106             Iterator<Map.Entry<String, Object>> it = valueMap.entrySet()
107                     .iterator();
108             while (it.hasNext()) {
109                 Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it
110                         .next();
111                 js.key(entry.getKey());
112                 serialize(js, entry.getValue());
113             }
114             js.endObject();
115         } catch (Exception e) {
116             e.printStackTrace();
117         }
118     }
119     
120     /**
121      * 序列化对象
122      * 
123      * @param js
124      *            json对象
125      * @param obj
126      *            待序列化对象
127      */
128     private static void serializeObject(JSONStringer js, Object obj) {
129         try {
130             js.object();
131             Class<? extends Object> objClazz = obj.getClass();
132             Method[] methods = objClazz.getDeclaredMethods();
133             Field[] fields = objClazz.getDeclaredFields();
134             for (Field field : fields) {
135                 try {
136                     String fieldType = field.getType().getSimpleName();
137                     String fieldGetName = parseMethodName(field.getName(),
138                             "get");
139                     if (!haveMethod(methods, fieldGetName)) {
140                         continue;
141                     }
142                     Method fieldGetMet = objClazz.getMethod(fieldGetName,
143                             new Class[] {});
144                     Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});
145                     String result = null;
146                     if ("Date".equals(fieldType)) {
147                         SimpleDateFormat sdf = new SimpleDateFormat(
148                                 "yyyy-MM-dd HH:mm:ss", Locale.US);
149                         result = sdf.format((Date) fieldVal);
150 
151                     } else {
152                         if (null != fieldVal) {
153                             result = String.valueOf(fieldVal);
154                         }
155                     }
156                     js.key(field.getName());
157                     serialize(js, result);
158                 } catch (Exception e) {
159                     continue;
160                 }
161             }
162             js.endObject();
163         } catch (Exception e) {
164             e.printStackTrace();
165         }
166     }
167 
168     /**
169      * 判断是否存在某属性的 get方法
170      * 
171      * @param methods
172      *            引用方法的数组
173      * @param fieldMethod
174      *            方法名称
175      * @return true或者false
176      */
177     public static boolean haveMethod(Method[] methods, String fieldMethod) {
178         for (Method met : methods) {
179             if (fieldMethod.equals(met.getName())) {
180                 return true;
181             }
182         }
183         return false;
184     }
185 
186     /**
187      * 拼接某属性的 get或者set方法
188      * 
189      * @param fieldName
190      *            字段名称
191      * @param methodType
192      *            方法类型
193      * @return 方法名称
194      */
195     public static String parseMethodName(String fieldName, String methodType) {
196         if (null == fieldName || "".equals(fieldName)) {
197             return null;
198         }
199         return methodType + fieldName.substring(0, 1).toUpperCase()
200                 + fieldName.substring(1);
201     }
202 
203     private static boolean isNull(Object obj) {
204         if (obj instanceof JSONObject) {
205             return JSONObject.NULL.equals(obj);
206         }
207         return obj == null;
208     }
209 
210     /**
211      * 判断是否是值类型
212      * 
213      * @param clazz
214      * @return
215      */
216     private static boolean isSingle(Class<?> clazz) {
217         return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
218     }
219 
220     /**
221      * 是否布尔值
222      * 
223      * @param clazz
224      * @return
225      */
226     public static boolean isBoolean(Class<?> clazz) {
227         return (clazz != null)
228                 && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
229                         .isAssignableFrom(clazz)));
230     }
231 
232     /**
233      * 是否数值
234      * 
235      * @param clazz
236      * @return
237      */
238     public static boolean isNumber(Class<?> clazz) {
239         return (clazz != null)
240                 && ((Byte.TYPE.isAssignableFrom(clazz))
241                         || (Short.TYPE.isAssignableFrom(clazz))
242                         || (Integer.TYPE.isAssignableFrom(clazz))
243                         || (Long.TYPE.isAssignableFrom(clazz))
244                         || (Float.TYPE.isAssignableFrom(clazz))
245                         || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
246                             .isAssignableFrom(clazz)));
247     }
248 
249     /**
250      * 判断是否是字符串
251      * 
252      * @param clazz
253      * @return
254      */
255     public static boolean isString(Class<?> clazz) {
256         return (clazz != null)
257                 && ((String.class.isAssignableFrom(clazz))
258                         || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
259                             .isAssignableFrom(clazz)));
260     }
261 
262     /**
263      * 判断是否是对象
264      * 
265      * @param clazz
266      * @return
267      */
268     private static boolean isObject(Class<?> clazz) {
269         return clazz != null && !isSingle(clazz) && !isArray(clazz)
270                 && !isCollection(clazz) && !isMap(clazz);
271     }
272 
273     /**
274      * 判断是否是数组
275      * 
276      * @param clazz
277      * @return
278      */
279     public static boolean isArray(Class<?> clazz) {
280         return clazz != null && clazz.isArray();
281     }
282 
283     /**
284      * 判断是否是集合
285      * 
286      * @param clazz
287      * @return
288      */
289     public static boolean isCollection(Class<?> clazz) {
290         return clazz != null && Collection.class.isAssignableFrom(clazz);
291     }
292 
293     /**
294      * 判断是否是Map
295      * 
296      * @param clazz
297      * @return
298      */
299     public static boolean isMap(Class<?> clazz) {
300         return clazz != null && Map.class.isAssignableFrom(clazz);
301     }
302 
303     /**
304      * 判断是否是列表
305      * 
306      * @param clazz
307      * @return
308      */
309     public static boolean isList(Class<?> clazz) {
310         return clazz != null && List.class.isAssignableFrom(clazz);
311     }

注:里面这些方法具体我也不知道怎么说,自己去试下,让后一步步调试,看看里面是怎么走的应该就会很清楚的。还是希望大家可以多多指出问题。相互学习。。。。

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。