net.sf.json工具类

net.sf.json工具类

/**
*JSON和JAVA的POJO相互转换工具类
*/

public final class JSONHelper {

/**
 * 将数组转换成JSON
 * 
 * @param object
 * @return JSON
 */
public static String array2json(Object object) {
	JSONArray jsonArray = JSONArray.fromObject(object);
	return jsonArray.toString();
}

/**
 * 将JSON转换成数组
 * 
 * @param json
 *            JSON对象
 * @param valueClz
 *            数组中存放的对象的Class
 * @return 数组
 */
public static Object json2Array(String json, Class valueClz) {
	JSONArray jsonArray = JSONArray.fromObject(json);
	return JSONArray.toArray(jsonArray, valueClz);
}

/**
 * 将Collection转换成JSON
 * 
 * @param object
 * @return JSON
 */
public static String collection2json(Object object) {
	JSONArray jsonArray = JSONArray.fromObject(object);
	return jsonArray.toString();
}

/**
 * 将Map转换成JSON
 * 
 * @param object
 *            map
 * @return JSON
 */
public static String map2json(Object object) {
	JSONObject jsonObject = JSONObject.fromObject(object);
	return jsonObject.toString();
}

/**
 * 将JSON转换成Map
 * 
 * @param keyArray
 *            Map的key
 * @param json
 *            JSON
 * @param valueClz
 *            Map中value的Class
 * @return map
 */
public static Map json2Map(Object[] keyArray, String json, Class valueClz) {
	JSONObject jsonObject = JSONObject.fromObject(json);
	Map classMap = new HashMap();

	for (int i = 0; i < keyArray.length; i++) {
		classMap.put(keyArray[i], valueClz);
	}

	return (Map) JSONObject.toBean(jsonObject, Map.class, classMap);
}

/**
 * 将POJO转换成JSON
 * 
 * @param object
 *            POJO
 * @return JSON
 */
public static String bean2json(Object object) {
	JSONObject jsonObject = JSONObject.fromObject(object);
	return jsonObject.toString();
}

/**
 * 将JSON转换成POJO
 * 
 * @param json
 *            JSON
 * @param beanClz
 *            POJO的Class
 * @return POJO
 */
public static Object json2Object(String json, Class beanClz) {
	return JSONObject.toBean(JSONObject.fromObject(json), beanClz);
}

/**
 * 将String转换成JSON
 * 
 * @param key
 *            key
 * @param value
 *            value
 * @return JSON
 */
public static String string2json(String key, String value) {
	JSONObject object = new JSONObject();
	object.put(key, value);
	return object.toString();
}

/**
 * 将JSON转换成String
 * 
 * @param key
 *            key
 * @param json
 *            JSON
 * @return string
 */
public static String json2String(String json, String key) {
	JSONObject jsonObject = JSONObject.fromObject(json);
	return jsonObject.get(key).toString();
}

/**
 * 将List对象序列化为JSON文本
 * 
 * @param list
 *            对象集合
 * @return JSON文本
 */
public static <T> String toJSONString(List<T> list) {
	JSONArray jsonArray = JSONArray.fromObject(list);
	return jsonArray.toString();
}

/**
 * 将对象序列化为JSON文本
 * 
 * @param object
 *            对象
 * @return JSON文本
 */
public static String toJSONString(Object object) {
	JSONArray jsonArray = JSONArray.fromObject(object);
	return jsonArray.toString();
}

/**
 * 将JSON对象数组序列化为JSON文本
 * 
 * @param jsonArray
 *            JSON对象数组
 * @return JSON文本
 */
public static String toJSONString(JSONArray jsonArray) {
	return jsonArray.toString();
}

/**
 * 将JSON对象序列化为JSON文本
 * 
 * @param jsonObject
 *            JSON对象
 * @return JSON文本
 */
public static String toJSONString(JSONObject jsonObject) {
	return jsonObject.toString();
}

/**
 * 将对象转换为List对象
 * 
 * @param object
 *            JSON文本
 * @return List对象
 */
public static List toArrayList(Object object) {
	List arrayList = new ArrayList();

	JSONArray jsonArray = JSONArray.fromObject(object);

	Iterator it = jsonArray.iterator();
	while (it.hasNext()) {
		JSONObject jsonObject = (JSONObject) it.next();

		Iterator keys = jsonObject.keys();
		while (keys.hasNext()) {
			Object key = keys.next();
			Object value = jsonObject.get(key);
			arrayList.add(value);
		}
	}

	return arrayList;
}

/**
 * 将对象转换为JSON对象数组
 * 
 * @param object
 *            对象
 * @return JSON对象数组
 */
public static JSONArray toJSONArray(Object object) {
	return JSONArray.fromObject(object);
}

/**
 * 将对象转换为JSON对象
 * 
 * @param object
 *            对象
 * @return JSON对象
 */
public static JSONObject toJSONObject(Object object) {
	JsonConfig jsonConfig = new JsonConfig();
	jsonConfig.registerJsonValueProcessor(Date.class, new JsonDateValueProcessor());
	return JSONObject.fromObject(object, jsonConfig);
}

/**
 * 将对象转换为JSON对象
 * 
 * @param object
 *            对象
 * @param excludes
 *            过滤不需要转换的字段属性
 * @return JSON对象
 */
public static JSONObject toJSONObject(Object object, String[] excludes) {
	JsonConfig jsonConfig = new JsonConfig();
	jsonConfig.setExcludes(excludes);
	jsonConfig.registerJsonValueProcessor(Date.class, new JsonDateValueProcessor());
	return JSONObject.fromObject(object, jsonConfig);
}

/**
 * 将对象转换为HashMap
 * 
 * @param object
 *            对象
 * @return HashMap
 */
public static HashMap toHashMap(Object object) {
	HashMap<String, Object> data = new HashMap<String, Object>();
	JSONObject jsonObject = JSONHelper.toJSONObject(object);
	Iterator it = jsonObject.keys();
	while (it.hasNext()) {
		String key = String.valueOf(it.next());
		Object value = jsonObject.get(key);
		data.put(key, value);
	}

	return data;
}

/**
 * 将对象转换为非实体类型(Map<String,Object>)的List
 * 
 * @param object
 *            对象
 * @return List
 */
public static List<Map<String, Object>> toList(Object object) {
	List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
	JSONArray jsonArray = JSONArray.fromObject(object);
	for (Object obj : jsonArray) {
		JSONObject jsonObject = (JSONObject) obj;
		Map<String, Object> map = new HashMap<String, Object>();
		Iterator it = jsonObject.keys();
		while (it.hasNext()) {
			String key = (String) it.next();
			Object value = jsonObject.get(key);
			map.put((String) key, value);
		}
		list.add(map);
	}
	return list;
}

/**
 * 将JSON对象数组转换为传入类型的List
 * 
 * @param <T>
 *            泛型T代表实体类型
 * @param jsonArray
 *            JSON数组
 * @param objectClass
 *            对象的Class
 * @return List
 */
public static <T> List<T> toList(JSONArray jsonArray, Class<T> objectClass) {
	return JSONArray.toList(jsonArray, objectClass);
}

/**
 * 将对象转换为传入类型的List
 * 
 * @param <T>
 *            泛型T代表实体类型
 * @param object
 *            对象
 * @param objectClass
 *            对象的Class
 * @return List
 */
public static <T> List<T> toList(Object object, Class<T> objectClass) {
	JSONArray jsonArray = JSONArray.fromObject(object);

	return JSONArray.toList(jsonArray, objectClass);
}

/**
 * 将JSON对象转换为传入类型的对象
 * 
 * @param <T>
 *            泛型T代表实体类型
 * @param jsonObject
 *            JSON对象
 * @param beanClass
 *            对象的Class
 * @return 传入类型的对象
 */
public static <T> T toBean(JSONObject jsonObject, Class<T> beanClass) {
	return (T) JSONObject.toBean(jsonObject, beanClass);
}

/**
 * 将对象转换为传入类型的对象
 * 
 * @param <T>
 *            泛型T代表实体类型
 * @param object
 *            对象
 * @param beanClass
 *            对象的Class
 * @return 传入类型的对象
 */
public static <T> T toBean(Object object, Class<T> beanClass) {
	JSONObject jsonObject = JSONObject.fromObject(object);

	return (T) JSONObject.toBean(jsonObject, beanClass);
}

/**
 * 将JSON文本反序列化为主从关系的实体
 * 
 * @param <T>
 *            泛型T代表主实体类型
 * @param <D>
 *            泛型D代表从实体类型
 * @param jsonString
 *            JSON文本
 * @param mainClass
 *            主实体类型
 * @param detailName
 *            从实体类在主实体类中的属性名称
 * @param detailClass
 *            从实体类型
 * @return 主从关系的实体
 */
public static <T, D> T toBean(String jsonString, Class<T> mainClass, String detailName, Class<D> detailClass) {
	JSONObject jsonObject = JSONObject.fromObject(jsonString);
	JSONArray jsonArray = (JSONArray) jsonObject.get(detailName);

	T mainEntity = JSONHelper.toBean(jsonObject, mainClass);
	List<D> detailList = JSONHelper.toList(jsonArray, detailClass);

	try {
		BeanUtils.setProperty(mainEntity, detailName, detailList);
	} catch (Exception ex) {
		throw new RuntimeException("主从关系JSON反序列化实体失败！");
	}

	return mainEntity;
}

/**
 * 将JSON文本反序列化为主从关系的实体
 * 
 * @param <T>
 *            泛型T代表主实体类型
 * @param <D1>
 *            泛型D1 代表从实体类型
 * @param <D2>
 *            泛型D2 代表从实体类型
 * @param jsonString
 *            JSON文本
 * @param mainClass
 *            主实体类型
 * @param detailName1
 *            从实体类在主实体类中的属性
 * @param detailClass1
 *            从实体类型
 * @param detailName2
 *            从实体类在主实体类中的属性
 * @param detailClass2
 *            从实体类型
 * @return 主从关系的实体
 */
public static <T, D1, D2> T toBean(String jsonString, Class<T> mainClass, String detailName1, Class<D1> detailClass1, String detailName2,
		Class<D2> detailClass2) {
	JSONObject jsonObject = JSONObject.fromObject(jsonString);
	JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
	JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

	T mainEntity = JSONHelper.toBean(jsonObject, mainClass);
	List<D1> detailList1 = JSONHelper.toList(jsonArray1, detailClass1);
	List<D2> detailList2 = JSONHelper.toList(jsonArray2, detailClass2);

	try {
		BeanUtils.setProperty(mainEntity, detailName1, detailList1);
		BeanUtils.setProperty(mainEntity, detailName2, detailList2);
	} catch (Exception ex) {
		throw new RuntimeException("主从关系JSON反序列化实体失败！");
	}

	return mainEntity;
}

/**
 * 将JSON文本反序列化为主从关系的实体
 * 
 * @param <T>
 *            泛型T代表主实体类型
 * @param <D1>
 *            泛型D1 代表从实体类型
 * @param <D2>
 *            泛型D2 代表从实体类型
 * @param jsonString
 *            JSON文本
 * @param mainClass
 *            主实体类型
 * @param detailName1
 *            从实体类在主实体类中的属性
 * @param detailClass1
 *            从实体类型
 * @param detailName2
 *            从实体类在主实体类中的属性
 * @param detailClass2
 *            从实体类型
 * @param detailName3
 *            从实体类在主实体类中的属性
 * @param detailClass3
 *            从实体类型
 * @return 主从关系的实体
 */
public static <T, D1, D2, D3> T toBean(String jsonString, Class<T> mainClass, String detailName1, Class<D1> detailClass1, String detailName2,
		Class<D2> detailClass2, String detailName3, Class<D3> detailClass3) {
	JSONObject jsonObject = JSONObject.fromObject(jsonString);
	JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
	JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
	JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);

	T mainEntity = JSONHelper.toBean(jsonObject, mainClass);
	List<D1> detailList1 = JSONHelper.toList(jsonArray1, detailClass1);
	List<D2> detailList2 = JSONHelper.toList(jsonArray2, detailClass2);
	List<D3> detailList3 = JSONHelper.toList(jsonArray3, detailClass3);

	try {
		BeanUtils.setProperty(mainEntity, detailName1, detailList1);
		BeanUtils.setProperty(mainEntity, detailName2, detailList2);
		BeanUtils.setProperty(mainEntity, detailName3, detailList3);
	} catch (Exception ex) {
		throw new RuntimeException("主从关系JSON反序列化实体失败！");
	}

	return mainEntity;
}

/**
 * 将JSON文本反序列化为主从关系的实体
 * 
 * @param <T>
 *            主实体类型
 * @param jsonString
 *            JSON文本
 * @param mainClass
 *            主实体类型
 * @param detailClass
 *            存放了多个从实体在主实体中属性名称和类型
 * @return 主从关系的实体
 */
public static <T> T toBean(String jsonString, Class<T> mainClass, HashMap<String, Class> detailClass) {
	JSONObject jsonObject = JSONObject.fromObject(jsonString);
	T mainEntity = JSONHelper.toBean(jsonObject, mainClass);
	for (Object key : detailClass.keySet()) {
		try {
			Class value = (Class) detailClass.get(key);
			BeanUtils.setProperty(mainEntity, key.toString(), value);
		} catch (Exception ex) {
			throw new RuntimeException("主从关系JSON反序列化实体失败！");
		}
	}
	return mainEntity;
}

/**
 * 创建一颗树，以json字符串形式返回
 * 
 * @param list
 *            原始数据列表
 * @return 树
 */
public static String createTreeJson(List<JSONObject> list, String text) {
	JSONArray rootArray = new JSONArray();
	for (int i = 0; i < list.size(); i++) {
		JSONObject resource = list.get(i);
		// resource.put("iconCls","icon-blank");
		resource.put("text", resource.getString(text));
		if (resource.get("pid").toString().equals("0")) {
			JSONObject rootObj = createBranch(list, resource, text);
			rootArray.add(rootObj);
		}
	}
	return rootArray.toString();
}

/**
 * 实现模糊查询
 * 
 * @param list
 *            原始数据列表
 * @return 树
 */
public static String createSearchTreeJson(List<JSONObject> list, String text) {
	JSONArray rootArray = new JSONArray();
	for (int i = 0; i < list.size(); i++) {
		boolean flag = true;
		JSONObject resource_i = list.get(i);
		for (int j = 0; j < list.size(); j++) {
			JSONObject resource_j = list.get(j);
			if (resource_i.get("pid").toString().equals(resource_j.get("id").toString())) {
				flag = false;
				break;
			}
		}
		// 不存在父节点的，则可以直接创建树
		if (flag) {
			JSONObject rootObj = createBranch(list, resource_i, text);
			rootArray.add(rootObj);
		}
	}
	return rootArray.toString();
}

/**
 * 递归创建分支节点Json对象
 * 
 * @param list
 *            创建树的原始数据
 * @param currentNode
 *            当前节点
 * @return 当前节点与该节点的子节点json对象
 */
public static JSONObject createBranch(List<JSONObject> list, JSONObject currentNode, String text) {
	/*
	 * 将javabean对象解析成为JSON对象
	 */
	JSONObject currentObj = JSONObject.fromObject(currentNode);
	JSONArray childArray = new JSONArray();
	/*
	 * 循环遍历原始数据列表，判断列表中某对象的父id值是否等于当前节点的id值，
	 * 如果相等，进入递归创建新节点的子节点，直至无子节点时，返回节点，并将该 节点放入当前节点的子节点列表中
	 */
	for (int i = 0; i < list.size(); i++) {
		JSONObject newNode = list.get(i);
		// newNode.put("iconCls","icon-blank");
		newNode.put("text", newNode.getString(text));
		if (newNode.getString("pid") != null && newNode.getString("pid").compareTo(currentNode.getString("id")) == 0) {
			JSONObject childObj = createBranch(list, newNode, text);
			childArray.add(childObj);
		}
	}
	/*
	 * 判断当前子节点数组是否为空，不为空将子节点数组加入children字段中
	 */
	if (!childArray.isEmpty()) {
		currentObj.put("children", childArray);
	}
	return currentObj;
}

/**
 * tree
 * 
 * @param list
 * @param text
 * @return
 */
public static List<JSONObject> deptTreeJson(List<JSONObject> list, String text) {
	List<JSONObject> arrayList = new ArrayList<JSONObject>();
	// 获取集合中所有的根目录
	List<JSONObject> rootJson = getRootJson(list);
	if (rootJson.size() > 0) {
		for (JSONObject jsonObject : rootJson) {
			JSONObject deptBranch = createDeptBranch(list, jsonObject, text);
			arrayList.add(deptBranch);
		}
	}
	return arrayList;
}

/**
 * 递归
 * 
 * @param list
 * @param currentNode
 * @param text
 * @return
 */
private static JSONObject createDeptBranch(List<JSONObject> list, JSONObject currentNode, String text) {
	/*
	 * 将javabean对象解析成为JSON对象
	 */
	JSONObject currentObj = JSONObject.fromObject(currentNode);
	JSONArray childArray = new JSONArray();
	/*
	 * 循环遍历原始数据列表，判断列表中某对象的父id值是否等于当前节点的id值，
	 * 如果相等，进入递归创建新节点的子节点，直至无子节点时，返回节点，并将该 节点放入当前节点的子节点列表中
	 */
	for (int i = 0; i < list.size(); i++) {
		JSONObject newNode = list.get(i);
		newNode.put("text", newNode.getString(text));
		if (newNode.getString("pid") != null && newNode.getString("pid").equals(currentNode.getString("id"))) {
			JSONObject childObj = createBranch(list, newNode, text);
			childArray.add(childObj);
		}
	}
	/*
	 * 判断当前子节点数组是否为空，不为空将子节点数组加入children字段中
	 */
	if (!childArray.isEmpty()) {
		currentObj.put("children", childArray);
	}
	return currentObj;

}

/**
 * 获取集合中的所有的根目录
 * 
 * @param list
 * @return
 */
private static List<JSONObject> getRootJson(List<JSONObject> list) {
	ArrayList<JSONObject> arrayList = new ArrayList<JSONObject>();
	ArrayList<String> idList2 = new ArrayList<String>();
	// 把父Id添加到集合中
	for (JSONObject jsonObject : list) {
		idList2.add(jsonObject.getString("id"));
	}
	for (JSONObject jsonObject : list) {
		if (!idList2.contains(jsonObject.getString("pid"))) {
			arrayList.add(jsonObject);
		}
	}
	return arrayList;
}

/** bean 转换为Map **/
public static <K, V> Map<K, V> Bean2Map(Object javaBean) {
	Map<K, V> ret = new HashMap<K, V>();
	try {
		Method[] methods = javaBean.getClass().getDeclaredMethods();
		for (Method method : methods) {
			if (method.getName().startsWith("get")) {
				String field = method.getName();
				field = field.substring(field.indexOf("get") + 3);
				field = field.toLowerCase().charAt(0) + field.substring(1);
				Object value = method.invoke(javaBean, (Object[]) null);
				ret.put((K) field, (V) (null == value ? "" : String.valueOf(value)));
			}
		}
	} catch (Exception e) {
	}
	return ret;
}
}