java基于反射JSONUtil类

在java中json用的很广泛了。但是适中官方不提供json>bean和bean>json的工具类，在此次编写过程中发现为啥官方不提供，在有些类（包括自定义）很难json>bean。但是我还是写了一部分，希望和大家分享，共同把这个类完善好。此次还没有考虑Data数据类型，不多说了，贴代码：

package org.json;

import java.lang.reflect.Field;

/**
 * @name org.json.JSONUtil
 * @describe 提供json转javabean和javebean转json方法
 * @author JEFF
 * @since 2012/11/15 
 * JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式 除了字符 "，\，/
 * 和一些控制符（\b，\f，\n，\r，\t）需要编码外，其他 Unicode 字符可以直接输出 Object 对象在 JSON 中是用 {}
 * 包含一系列无序的 Key-Value 键值对表示的，实际上此处的 Object 相当于 Java 中的 Map<String,Object>，
 * 而不是 Java 的 Class 。注意 Key 只能用 String 表示。
 * Prototype提供了 evalJSON() 方法，能直接将服务器返回的 JSON 文本变成一个 JavaScript 变量
 */
public class JSONUtil {
	/**
	 * 把对象封装为JSON格式
	 * 
	 * @param o
	 *            对象
	 * @return JSON格式
	 */
	@SuppressWarnings("unchecked")
	public static String toJson(final Object o) {
		if (o == null) {
			return "null";
		}
		if (o instanceof String) // String
		{
			return string2Json((String) o);
		}
		if (o instanceof Boolean) // Boolean
		{
			return boolean2Json((Boolean) o);
		}
		if (o instanceof Number) // Number
		{
			return number2Json((Number) o);
		}
		if (o instanceof Map) // Map
		{
			return map2Json((Map<String, Object>) o);
		}
		if (o instanceof Collection) // List Set
		{
			return collection2Json((Collection<Object>) o);
		}
		if (o instanceof Object[]) // 对象数组
		{
			return array2Json((Object[]) o);
		}
		if (o instanceof int[])// 基本类型数组
		{
			return intArray2Json((int[]) o);
		}
		if (o instanceof boolean[])// 基本类型数组
		{
			return booleanArray2Json((boolean[]) o);
		}
		if (o instanceof long[])// 基本类型数组
		{
			return longArray2Json((long[]) o);
		}
		if (o instanceof float[])// 基本类型数组
		{
			return floatArray2Json((float[]) o);
		}
		if (o instanceof double[])// 基本类型数组
		{
			return doubleArray2Json((double[]) o);
		}
		if (o instanceof short[])// 基本类型数组
		{
			return shortArray2Json((short[]) o);
		}
		if (o instanceof byte[])// 基本类型数组
		{
			return byteArray2Json((byte[]) o);
		}
		if (o instanceof Object) // 保底收尾对象
		{
			return Bean2Json(o);
		}

		throw new RuntimeException("不支持的类型: " + o.getClass().getName());
	}

	/**
	 * 将 String 对象编码为 JSON格式，只需处理好特殊字符
	 * 
	 * @param s
	 *            String 对象
	 * @return JSON格式
	 */
	static String string2Json(final String s) {
		final StringBuilder sb = new StringBuilder(s.length() + 20);
		sb.append('\"');
		for (int i = 0; i < s.length(); i++) {
			final char c = s.charAt(i);
			switch (c) {
			case '\"':
				sb.append("\\\"");
				break;
			case '\\':
				sb.append("\\\\");
				break;
			case '/':
				sb.append("\\/");
				break;
			case '\b':
				sb.append("\\b");
				break;
			case '\f':
				sb.append("\\f");
				break;
			case '\n':
				sb.append("\\n");
				break;
			case '\r':
				sb.append("\\r");
				break;
			case '\t':
				sb.append("\\t");
				break;
			default:
				sb.append(c);
			}
		}
		sb.append('\"');
		return sb.toString();
	}

	/**
	 * 将 Number 表示为 JSON格式
	 * 
	 * @param number
	 *            Number
	 * @return JSON格式
	 */
	static String number2Json(final Number number) {
		return number.toString();
	}

	/**
	 * 将 Boolean 表示为 JSON格式
	 * 
	 * @param bool
	 *            Boolean
	 * @return JSON格式
	 */
	static String boolean2Json(final Boolean bool) {
		return bool.toString();
	}

	/**
	 * 将 Collection 编码为 JSON 格式 (List,Set)
	 * 
	 * @param c
	 * @return
	 */
	static String collection2Json(final Collection<Object> c) {
		final Object[] arrObj = c.toArray();
		return toJson(arrObj);
	}

	/**
	 * 将 Map<String, Object> 编码为 JSON 格式
	 * 
	 * @param map
	 * @return
	 */
	static String map2Json(final Map<String, Object> map) {
		if (map.isEmpty()) {
			return "{}";
		}
		final StringBuilder sb = new StringBuilder(map.size() << 4); // 4次方
		sb.append('{');
		final Set<String> keys = map.keySet();
		for (final String key : keys) {
			final Object value = map.get(key);
			sb.append('\"');
			sb.append(key); // 不能包含特殊字符
			sb.append('\"');
			sb.append(':');
			sb.append(toJson(value)); // 循环引用的对象会引发无限递归
			sb.append(',');
		}
		// 将最后的 ',' 变为 '}':
		sb.setCharAt(sb.length() - 1, '}');
		return sb.toString();
	}

	/**
	 * 将数组编码为 JSON 格式
	 * 
	 * @param array
	 *            数组
	 * @return JSON 格式
	 */
	static String array2Json(final Object[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4); // 4次方
		sb.append('[');
		for (final Object o : array) {
			sb.append(toJson(o));
			sb.append(',');
		}
		// 将最后添加的 ',' 变为 ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String intArray2Json(final int[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final int o : array) {
			sb.append(Integer.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String longArray2Json(final long[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final long o : array) {
			sb.append(Long.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String booleanArray2Json(final boolean[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final boolean o : array) {
			sb.append(Boolean.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String floatArray2Json(final float[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final float o : array) {
			sb.append(Float.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String doubleArray2Json(final double[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final double o : array) {
			sb.append(Double.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String shortArray2Json(final short[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final short o : array) {
			sb.append(Short.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	static String byteArray2Json(final byte[] array) {
		if (array.length == 0) {
			return "[]";
		}
		final StringBuilder sb = new StringBuilder(array.length << 4);
		sb.append('[');
		for (final byte o : array) {
			sb.append(Byte.toString(o));
			sb.append(',');
		}
		// set last ',' to ']':
		sb.setCharAt(sb.length() - 1, ']');
		return sb.toString();
	}

	public static String Bean2Json(final Object bean) {
		// 数据检查
		if (bean == null) {
			return "{}";
		}
		final Method[] methods = bean.getClass().getMethods(); // 方法数组
		final StringBuilder sb = new StringBuilder(methods.length << 4); // 4次方
		sb.append('{');

		for (final Method method : methods) {
			try {
				final String name = method.getName();
				String key = "";
				if (name.startsWith("get")) {
					key = name.substring(3);

					// 防死循环
					final String[] arrs = { "Class" };
					boolean bl = false;
					for (final String s : arrs) {
						if (s.equals(key)) {
							bl = true;
							continue;
						}
					}
					if (bl) {
						continue; // 防死循环
					}
				} else if (name.startsWith("is")) {
					key = name.substring(2);
				}
				if (key.length() > 0 && Character.isUpperCase(key.charAt(0))
						&& method.getParameterTypes().length == 0) {
					if (key.length() == 1) {
						key = key.toLowerCase();
					} else if (!Character.isUpperCase(key.charAt(1))) {
						key = key.substring(0, 1).toLowerCase()
								+ key.substring(1);
					}
					final Object elementObj = method.invoke(bean);

					// System.out.println("###" + key + ":" +
					// elementObj.toString());

					sb.append('\"');
					sb.append(key); // 不能包含特殊字符
					sb.append('\"');
					sb.append(':');
					sb.append(toJson(elementObj)); // 循环引用的对象会引发无限递归
					sb.append(',');
				}
			} catch (final Exception e) {
				// e.getMessage();
				throw new RuntimeException("在将bean封装成JSON格式时异常："
						+ e.getMessage(), e);
			}
		}
		if (sb.length() == 1) {
			return bean.toString();
		} else {
			sb.setCharAt(sb.length() - 1, '}');
			return sb.toString();
		}
	}

	static void setJson2Field(Object object, JSONObject jsonObject, Field field) {
		field.setAccessible(true);
		try {
			setField(object, jsonObject, field);
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	private static void setField(Object object, JSONObject jsonObject,
			Field field) throws IllegalArgumentException,
			IllegalAccessException, JSONException {
		String name = field.getName();
		String type = field.getType().getSimpleName();
		Object value = jsonObject.get(name);
		if (value instanceof String) // String
		{
			field.set(object, jsonObject.getString(name));
		} else if (value instanceof Boolean) // Boolean
		{
			field.set(object, jsonObject.getBoolean(name));
		} else if (value instanceof Number) // Number
		{
			if (value instanceof Integer) {
				field.set(object, jsonObject.getInt(name));
			} else if (value instanceof Float) {
				field.set(object, Float.parseFloat(value.toString()));
			} else if (value instanceof Double) {
				field.set(object, Float.parseFloat(value.toString()));
			} else if (value instanceof Long) {
				field.set(object, jsonObject.getLong(name));
			} else if (value instanceof Short) {
				field.set(object, Short.parseShort(value.toString()));
			}
		} else if (value instanceof JSONArray) {
			if (int[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				int[] ss = new int[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = values.getInt(i);
				}
				field.set(object, ss);
			} else if (double[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				double[] ss = new double[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = values.getDouble(i);
				}
				field.set(object, ss);
			} else if (float[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				float[] ss = new float[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = Float.parseFloat(values.get(i).toString());
				}
				field.set(object, ss);
			} else if (long[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				long[] ss = new long[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = values.getLong(i);
				}
				field.set(object, ss);
			} else if (String[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				String[] ss = new String[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = values.getString(i);
				}
				field.set(object, ss);
			} else if (Object[].class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				Object[] ss = new Object[values.length()];
				for (int i = 0; i < values.length(); i++) {
					ss[i] = Json2Bean(values.getJSONArray(i).toString(), values
							.get(i).getClass());
				}
				field.set(object, ss);
			} else if (List.class.getSimpleName().equals(type)
					|| ArrayList.class.getSimpleName().equals(type)) {
				JSONArray values = jsonObject.getJSONArray(name);
				ArrayList list = new ArrayList(values.length());
				for (int i = 0; i < values.length(); i++) {
					list.add(values.get(i));
				}
				field.set(object, list);
			}
		} else if (value instanceof JSONObject) // 保底收尾对象
		{
			 if (Map.class.getSimpleName().equals(type)) {
					JSONObject obj = jsonObject.getJSONObject(name);
					Map<String, Object> map = new HashMap<String, Object>();
					Iterator<String> keys = obj.keys();
					do {
						String s = keys.next();
						map.put(s, obj.get(s));
					} while (keys.hasNext());
					field.set(object, map);
			}else{
				try {
					JSONObject jo = jsonObject.getJSONObject(name);
					Object obj = Json2Bean(jo.toString(),
							Class.forName(field.getType().getName()));
					field.set(object, obj);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 将json字符串转换为指定Class
	 * 
	 * @param json
	 * @param clazz
	 * @return
	 */
	public static Object Json2Bean(final String json, Class<?> clazz) {
		Object object = null;
		JSONObject jsonObject = null;
		if (json != null && json.trim().length() > 0) {
			try {
				jsonObject = new JSONObject(json);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		try {
			object = clazz.newInstance();
			Field[] fields = clazz.getDeclaredFields();
			for (Field field : fields) {
				setJson2Field(object, jsonObject, field);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (isNULL(jsonObject,object)) {
			throw new JsonParseClassException("转换对象错误，不能转换" + object.getClass());
		}
		return object;
	}

	@SuppressWarnings("unchecked")
	private static boolean isNULL(JSONObject jsonObject, Object clazz) {
		if (clazz == null || jsonObject == null) {
			return true;
		}
		Iterator<String> iterator = jsonObject.keys();
		List<String> s = new ArrayList<String>();
		do {
			s.add(iterator.next());
		} while (iterator.hasNext());
		int num = 0;
		try {
			Field[] fields = clazz.getClass().getDeclaredFields();
			for (int i = 0; i < fields.length; i++) {
				fields[i].setAccessible(true);
				String name = fields[i].getName();
				if(s.contains(name)){
					num++;
				}
			}
		} catch (Exception e) {

		}
		if (num == s.size())
			return false;
		return true;
	}
}

        本人功力有限，希望大家帮我完善这个类。谢谢。