最近在找怎样可以将一个数据对象通过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 }
注:里面这些方法具体我也不知道怎么说,自己去试下,让后一步步调试,看看里面是怎么走的应该就会很清楚的。还是希望大家可以多多指出问题。相互学习。。。。