JSONConvertor2.java

package com.jiuqi.lbsinterface.json;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;

public class JSONConvertor2 {
	private static String CLASS = "class";
	private static String DATA = "data";
	/**
	 * 默认class名称
	 */
	private static String DefaultClassName = "";
	private static String NullClassName = "null";
	private static String NullData = "null";

	public static JSONObject serializable(Object t) {
		JSONObject jo = new JSONObject();
		try {
			if (null == t) {
				jo.put(CLASS, NullClassName);
				jo.put(DATA, NullData);
			} else if (t instanceof Class<?>) {
				jo.put(CLASS, DefaultClassName);
				jo.put(DATA, ((Class<?>) t).getName());
			} else {
				jo.put(CLASS, t.getClass().getName());
				Gson gson = getGson();
				jo.put(DATA, gson.toJson(t));
			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return jo;
	}

	public static JSONObject serializable(Object t, Type type) {
		JSONObject jo = new JSONObject();
		try {
			if (null == t) {
				jo.put(CLASS, NullClassName);
				jo.put(DATA, NullData);
			} else if (t instanceof Class<?>) {
				jo.put(CLASS, DefaultClassName);
				jo.put(DATA, ((Class<?>) t).getName());
			} else {
				if (null == type || !(type instanceof ParameterizedType)) {
					throw new RuntimeException(type + ":样式错误！");
				}
				jo.put(CLASS, type);
				Gson gson = getGson();
				jo.put(DATA, gson.toJson(t));
			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return jo;
	}

	public static Object unSerializable(Type c, JSONObject json) {
		Gson gson = getGson();
		try {
			// try {
			// Class<?> oc = Class.forName(json.getString(CLASS), true,
			// Thread.currentThread().getContextClassLoader());
			// if(!(oc.isAssignableFrom(List.class) ||
			// oc.isAssignableFrom(Map.class))){
			// c = oc;
			// }
			// } catch (ClassNotFoundException e) {
			// }
			String data = json.getString(DATA);
			String className = json.getString(CLASS);
			if (NullClassName.equals(className)) {
				return null;
			} else if (DefaultClassName.equals(className)) {
				try {
					return Class.forName(data, true, Thread.currentThread()
							.getContextClassLoader());
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
			} else {
				return gson.fromJson(data, c);
			}
		} catch (JsonSyntaxException e) {
			e.printStackTrace();
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
	}

	private static Gson getGson() {
		return new Gson();
	}

	public static Object unAutoSerializable(JSONObject json, Type returnType) {
		if (null == json) {
			return null;
		}
		try {
			String className = json.getString(CLASS);
			String data = json.getString(DATA);
			if (NullClassName.equals(className)) {
				return null;
			} else if (DefaultClassName.equals(className)) {
				return Class.forName(data, true, Thread.currentThread()
						.getContextClassLoader());
			} else {
				Gson gson = getGson();
				data.length();
				// gson.fromJson(data, List<DriverBean>.class);
				// Object l = gson.fromJson(data, new
				// TypeToken<List<DriverBean>>(){}.getType());
				if (className.equals("java.lang.map")
						|| className.equals("java.util.HashMap")
						|| className.equals("java.util.List")
						|| className.equals("java.util.ArrayList")) {
					return gson.fromJson(data, returnType);
				}
				return gson.fromJson(data, getIType(className));
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static Object unSerializable(JSONObject json) {
		if (null == json) {
			return null;
		}
		try {
			String className = json.getString(CLASS);
			String data = json.getString(DATA);
			if (NullClassName.equals(className)) {
				return null;
			} else if (DefaultClassName.equals(className)) {
				return Class.forName(data, true, Thread.currentThread()
						.getContextClassLoader());
			} else {
				Gson gson = getGson();
				data.length();
				// gson.fromJson(data, List<DriverBean>.class);
				// Object l = gson.fromJson(data, new
				// TypeToken<List<DriverBean>>(){}.getType());
				return gson.fromJson(data, getIType(className));
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
	}

	private static Type getIType(String className)
			throws ClassNotFoundException {
		ClassLoader contextClassLoader = Thread.currentThread()
				.getContextClassLoader();
		if (className.endsWith(">") && className.contains("<")) {
			String[] ss = className.split("<");
			Class<?> rawType = Class.forName(ss[0], true, contextClassLoader);
			//
			if (List.class.isAssignableFrom(rawType)) {
				rawType = ArrayList.class;
			}
			//
			Type gType = Class.forName(ss[1].substring(0, ss[1].length() - 1),
					true, contextClassLoader);
			return $Gson$Types.newParameterizedTypeWithOwner(null, rawType,
					gType);
		}
		return Class.forName(className, true, contextClassLoader);
	}

	public static JSONArray serializableArray(Object... objs) {
		JSONArray array = new JSONArray();
		if (null != objs) {
			for (Object obj : objs) {
				array.put(serializable(obj));
			}
		}
		return array;
	}

	public static Object[] unSerializableArray(JSONArray array) {
		Object[] objs = new Object[array.length()];
		for (int i = 0; i < array.length(); i++) {
			try {
				objs[i] = unSerializable(array.getJSONObject(i));
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return objs;
	}

	public static JsonArrayResult unSerializableArray_Result(JSONArray array) {
		JsonArrayResult result = new JsonArrayResult();
		int length = array.length();
		Object[] objs = new Object[length];
		Class<?>[] params = new Class<?>[length];
		for (int i = 0; i < length; i++) {
			try {
				JSONObject json = array.getJSONObject(i);
				if (null == json) {
					continue;
				}
				try {
					String className = json.getString(CLASS);
					String data = json.getString(DATA);
					if (NullClassName.equals(className)) {
						// null;
					} else if (DefaultClassName.equals(className)) {
						params[i] = Class.class;
						objs[i] = Class.forName(data, true, Thread
								.currentThread().getContextClassLoader());
					} else {
						Gson gson = getGson();
						Class<?> c = Class.forName(className, true, Thread
								.currentThread().getContextClassLoader());
						params[i] = c;
						objs[i] = gson.fromJson(data, c);
					}
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				} catch (JSONException e) {
					e.printStackTrace();
				}
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		result.setObjs(objs);
		result.setParamClass(params);
		return result;
	}
}