Android学習ノートのJSONのシーケンス化の基本的な使い方
49081 ワード
最近、どのように1つのデータオブジェクトをWCFを通じてサーバーに伝えることができるかを探しています.ネット上で1つのオブジェクトがJSONのデータフォーマットにシーケンス化された投稿を見ました.ここで整理します.
JSONのJSOnStringerというクラスを使用していますが、このような主な機能は、1つのデータ型をすばやくシーケンス化し、標準的なJSONデータにすることです.
ここで注意しなければならないのは、
.object()と.endObject()は、Object基準に従って数値に境界を追加するために同時に使用する必要があります.同様に、配列に対しても境界を生成するための標準的な方法のセットがある.Array()と.endArray().
基本原理としては,データの入力がどのタイプに属するかを判断し,具体的なタイプ(オブジェクト,配列,集合,Map,Stringなどの単一の基礎データ型)に基づいてシーケンス化することである.
私はオブジェクトを列にしています.
一、データオブジェクト
二、メインインタフェース(オブジェクトを初期化し、値を付与する)呼び出しシーケンス化方法
三、JSONシーケンス化(これこそメイン料理)
注:中のこれらの方法は具体的に私もどのように言うことを知らないで、自分で试してみて、后で一歩一歩デバッグさせて、中がどのように歩いているのかを见てみるととてもはっきりするはずです.やはり多くの問題を指摘してほしい.学び合う...
JSONのJSOnStringerというクラスを使用していますが、このような主な機能は、1つのデータ型をすばやくシーケンス化し、標準的な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 }注:中のこれらの方法は具体的に私もどのように言うことを知らないで、自分で试してみて、后で一歩一歩デバッグさせて、中がどのように歩いているのかを见てみるととてもはっきりするはずです.やはり多くの問題を指摘してほしい.学び合う...