基于org.json的快速构建和解析json文本扩展工具

之前做过一个项目需要使用json来传输数据，我用的是org.json,但是其构造和解析方法过于繁琐，想到之前解析xml时用的simpleXml可以通过注解的方式构造和解析xml文本，

我就参考simpleXml,利用java的反射机制做了一个基于org.json的工具包，这个工具同样可以通过注解来构造json。

首先是一个接口，这个接口是个标记，表名一个类可以使用这个工具转换json

package dikaros.json.annotation;

/**
 * 动态转换标记<br>
 * 表示该实例类可以被动态转换成json信息<br>
 * @author Dikaros
 *
 */
public interface Jsonable {

}

接下来是声明的注解JsonParam

package dikaros.json.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * JsonParam 标准类型注解用在类的基本属性前<br>
 * 在生成json文本后为键值对的key<br>
 * @author Dikaros
 *
 */
//注解会在class字节码文件中存在，在运行时可以通过反射获取到  
@Retention(RetentionPolicy.RUNTIME) 
public @interface JsonParam {
	/**
	 * json文本 键
	 * @return
	 */
	public String name() default "";
	
}

注解JsonListParam

package dikaros.json.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * JsonParam 标准类型注解用在类的基本属性前<br>
 * 在生成json文本后为键值对的key<br>
 * className表示数组类型或集合的泛型如<code>String.class</code><br>
 * 枚举类型TYPE表示数组类型ARRAY表示数组，例如int[]， LIST表示集合，例如java.util.List<br>
 * 
 * @author Dikaros
 * @see TYPE
 * 
 */
// 注解会在class字节码文件中存在，在运行时可以通过反射获取到
@Retention(RetentionPolicy.RUNTIME)
public @interface JsonListParam {
	public String name() default "";

	/**
	 * 数组类型或集合泛型
	 * @return
	 */
	public Class contentClassName();

	/**
	 * 设置是集合还是数组
	 * @return <code>TYPE.ARRAY</code>或<code>TYPE.LIST</code>
	 * @see TYPE
	 */
	public TYPE classType() default TYPE.LIST;

	/**
	 * 多数据类型<br>
	 * ARRAY表示数组，例如int[]<br>
	 * LIST表示集合，例如java.util.List<br>
	 * 默认为LIST
	 * 
	 * @author Dikaros
	 * 
	 */
	public enum TYPE {
		ARRAY, LIST
	};
}

然后就是主要的工具类了，由于这个类是基于org,json的，所以相关的org.json大家可以从其他地方下载，另外本文还附带了一个jar包，需要的可以下载

package dikaros.json;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import dikaros.json.annotation.JsonListParam;
import dikaros.json.annotation.JsonParam;
import dikaros.json.annotation.Jsonable;
import dikaros.json.annotation.JsonListParam.TYPE;
import dikaros.org.json.JSONArray;
import dikaros.org.json.JSONException;
import dikaros.org.json.JSONObject;
import dikaros.org.json.JSONStringer;

/**
 * org.json扩展<br>
 * 将类构造成简单的json文本<br>
 * 注意：构造的类需要实现Jsonable接口，并且是标准的JavaBean<br>
 * 原理：通过反射机制获取需要转换成json对象的注解，根据注解的内容生成key<br>
 * 由于注解是添加在变量上的，如果类拥有标准get和set方法，则通过反射获取<br>
 * 并执行这些方法即可当作value<br>
 * 建议：将一些类型改变为基本类型，如java.util.Date用long来表示
 * 
 * @author Dikaros
 * @see Jsonable
 * @see JsonParam
 * @see JsonListParam
 */
public class JsonExtendedUtil {

	/**
	 * 构造一个对象的json
	 * 
	 * @param object
	 *            需要转换成json的对象，需要实现Jsonable接口
	 * @return json文本
	 * @throws Exception
	 */
	public static String generateJson(Object object) throws Exception {
		JSONStringer stringer = new JSONStringer();
		stringer.array();
		generateObjectMessage(object, stringer);
		stringer.endArray();
		return stringer.toString();
	}

	/**
	 * 构造json<br>
	 * 原理:通过反射机制获取注解并将其作为key，再调用field的get方法即可得到value
	 * 
	 * @param object
	 *            需要转换成json的对象，需要实现Jsonable接口
	 * @param stringer
	 *            org.json的json构造器
	 * @throws Exception
	 */
	private static void generateObjectMessage(Object object,
			JSONStringer stringer) throws Exception {
		// 如果object没有实现Jsonable接口，则抛出异常
		if (!(object instanceof Jsonable)) {
			throw new Exception("不支持的类型格式，是否忘记了实现JsonAble接口");
		}
		// 开始构造json对象
		stringer.object();
		Class clazz = object.getClass();
		Field[] fields = clazz.getDeclaredFields();
		for (Field field : fields) {
			if (field.isAnnotationPresent(JsonParam.class)) {
				JsonParam jsonParam = field.getAnnotation(JsonParam.class);
				// json键
				stringer.key(jsonParam.name());
				Method method = getFieldMethod(clazz, field);
				Object value = method.invoke(object, new Object[] {});
				// json值
				stringer.value(value);
			} else if (field.isAnnotationPresent(JsonListParam.class)) {
				// System.out.println("list");
				JsonListParam jsonListParam = field
						.getAnnotation(JsonListParam.class);
				// 字段名称，根据字段名称获取其对应的get方法
				Method method = getFieldMethod(clazz, field);

				Object value = method.invoke(object, new Object[] {});
				if (value == null) {
					continue;
				}
				if (jsonListParam.classType() == TYPE.ARRAY) {

					Array.getLength(value);
					// 调用get方法
					stringer.key(jsonListParam.name());
					// 集合的键
					stringer.array();

					// 集合字段
					for (int i = 0; i < Array.getLength(value); i++) {
						Object listItem = Array.get(value, i);
						// 如果集合是JsonAble的实例则调用此函数
						if ((listItem instanceof Jsonable)) {
							generateObjectMessage(listItem, stringer);
						}
						// 如果集合不是JsonAble的实例
						else if (isBaseType(listItem)) {
							stringer.value(listItem);
						} else {
							throw new Exception("集合元素类型不支持，请将集合内元素实现JsonAble接口");
						}
					}
					// 集合结束
					stringer.endArray();
				} else if (jsonListParam.classType() == TYPE.LIST) {
					// 调用get方法
					stringer.key(jsonListParam.name());
					// 集合的键
					stringer.array();

					// 集合字段
					List list = (List) value;
					for (Object listItem : list) {
						// 如果集合是JsonAble的实例则调用此函数
						if ((listItem instanceof Jsonable)) {
							generateObjectMessage(listItem, stringer);
						}
						// 如果集合不是JsonAble的实例
						else if (isBaseType(listItem)) {
							stringer.value(listItem);
						} else {
							throw new Exception("集合元素类型不支持，请将集合内元素实现JsonAble接口");
						}
					}
					// 集合结束
					stringer.endArray();
				}

			}
		}
		// json对象结束
		stringer.endObject();
	}

	/**
	 * 判断对象是否是基本类型
	 * 
	 * @return true是，false 不是
	 */
	private static boolean isBaseType(Object obj) {
		boolean result = false;
		if ((obj instanceof Integer) || (obj instanceof Byte)
				|| (obj instanceof Double) || (obj instanceof Boolean)
				|| (obj instanceof String) || (obj instanceof Short)
				|| (obj instanceof Long) || (obj instanceof Character)
				|| (obj instanceof Float)) {
			result = true;
		}

		return result;
	}

	/**
	 * 获取JavaBean字段的get方法
	 */
	private static Method getFieldMethod(Class clazz, Field field)
			throws Exception {
		String fieldName = field.getName();
		fieldName = fieldName.substring(0, 1).toUpperCase()
				+ fieldName.substring(1);
		Method method = null;
		try {
			if (field.getType() == Boolean.class) {
				method = clazz.getMethod("is" + fieldName, null);
			} else {
				method = clazz.getMethod("get" + fieldName, null);
			}
		} catch (NoSuchMethodException e) {
			throw new Exception("不是标准的JavaBean,注意JavaBean的格式");
		}
		return method;
	}

	/**
	 * 获取JavaBean字段的set方法
	 */
	@SuppressWarnings("unchecked")
	private static Method setFieldMethod(Class clazz, Field field)
			throws Exception {
		String fieldName = field.getName();
		fieldName = fieldName.substring(0, 1).toUpperCase()
				+ fieldName.substring(1);
		Method method = null;
		try {
			// System.out.println("set---" + fieldName);
			method = clazz.getMethod("set" + fieldName,
					new Class[] { field.getType() });
		} catch (NoSuchMethodException e) {
			throw new Exception("不是标准的JavaBean,注意JavaBean的格式");
		}
		return method;
	}

	public static Object compileJson(Class clazz, String jsonFile)
			throws Exception {
		JSONArray array = new JSONArray(jsonFile);
		Object object = null;
		if (array.length() > 0) {
			JSONObject jsonObject = array.getJSONObject(0);
			object = clazz.newInstance();
			getObjectFromJsonFile(object, jsonObject.toString());
		}

		return object;
	}

	/**
	 * 解析Json<br>
	 * 原理：传入Object获取其类型，通过其类型的注解调用属性的set方法更改Object的值<br>
	 * 注意：该方法的传入json是一个JSONObject型的
	 * 
	 * @param jsonable
	 *            待转换的类
	 * @param jsonFile
	 *            需要解析的jsonFile
	 * @throws Exception
	 */
	private static void getObjectFromJsonFile(Object jsonable, String jsonFile)
			throws Exception {
		if (!(jsonable instanceof Jsonable)) {
			throw new Exception("不支持的类型格式，是否忘记了实现JsonAble接口");
		}
		// 获取class
		Class clazz = jsonable.getClass();
		JSONObject obj = new JSONObject(jsonFile);
		// 获取类所有的属性
		Field[] fields = clazz.getDeclaredFields();
		// 遍历所有的属性
		for (Field field : fields) {
			/*
			 * 如果属性中存在JsonParam的注解 从JsonFile中获取内容 通过反射机制调用set方法更新属性
			 */
			if (field.isAnnotationPresent(JsonParam.class)) {
				JsonParam jsonParam = field.getAnnotation(JsonParam.class);
				String keyName = jsonParam.name();
				Object value = obj.get(keyName);
				Method method = setFieldMethod(clazz, field);
				// 调用set方法更新属性
				method.invoke(jsonable, new Object[] { value });

			}
			/*
			 * 如果属性中存在JsonListParam的注解 从JsonFile中获取内容 判断多值类型是集合还是数组
			 * 根据类型采用不同的方法更新属性
			 */
			else if (field.isAnnotationPresent(JsonListParam.class)) {
				JsonListParam jsonListParam = field
						.getAnnotation(JsonListParam.class);
				// 获取键
				String keyName = jsonListParam.name();

				JSONArray jArray = null;
				/*
				 * 判断有没有这样的keyName 如果没有，跳过进行下一次循环
				 */
				try {
					jArray = obj.getJSONArray(keyName);
				} catch (Exception e) {
					continue;
				}
				if (!(field.getType().equals(List.class))
						&& !field.getType().isArray()) {
					throw new Exception("类型错误，类型不是List的实例");
				}
				Method method = setFieldMethod(clazz, field);
				TYPE classType = jsonListParam.classType();
				/*
				 * 如果是集合 构建集合 递归调用此方法进行设置
				 */
				if (classType == TYPE.LIST) {
					List list = new ArrayList<>();
					for (int i = 0; i < jArray.length(); i++) {
						JSONObject item = jArray.getJSONObject(i);
						Class itemClass = jsonListParam.contentClassName();
						Object itemObject = itemClass.newInstance();
						if (itemObject instanceof Jsonable) {
							getObjectFromJsonFile(itemObject, item.toString());
							list.add(itemObject);
						} else if (isBaseType(itemObject)) {
							list.add(jArray.get(i));
						}
					}
					method.invoke(jsonable, new Object[] { list });
				}
				/*
				 * 如果是数组 根据JSONArray大小构建数组 递归调用此方法进行设置
				 */
				else if (classType == TYPE.ARRAY) {

					// Object[] items = new Object[jArray.length()];
					Object items = Array.newInstance(
							jsonListParam.contentClassName(), jArray.length());
					for (int i = 0; i < jArray.length(); i++) {
						Class itemClass = jsonListParam.contentClassName();
						Object itemObject = itemClass.newInstance();
						if (itemObject instanceof Jsonable) {
							JSONObject item = jArray.getJSONObject(i);
							getObjectFromJsonFile(itemObject, item.toString());
							// items[i] = itemObject;
							Array.set(items, i, itemObject);
						} else if (isBaseType(itemObject)) {
							Array.set(items, i, jArray.get(i));

						}
					}
					System.out.println("method--->" + method.getName() + ":"
							+ method.getParameterTypes()[0]);
					method.invoke(jsonable, new Object[] { items });
				}

			}
		}

	}

	/**
	 * 获取long值
	 * 
	 * @param jsonFile
	 * @param param
	 * @return
	 */
	public static long getLongParam(String jsonFile, String param) {
		long result = 0;
		JSONObject obj;
		JSONArray array;

		try {
			array = new JSONArray(jsonFile);
			if (array.length() > 0) {
				obj = array.getJSONObject(0);
				result = obj.getLong(param);
			}

		} catch (JSONException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 获取boolean值
	 * 
	 * @param jsonFile
	 * @param param
	 * @return
	 */
	public static boolean getBooleanParam(String jsonFile, String param) {
		boolean result = false;
		JSONObject obj;
		JSONArray array;

		try {
			array = new JSONArray(jsonFile);
			if (array.length() > 0) {
				obj = array.getJSONObject(0);
				result = obj.getBoolean(param);
			}

		} catch (JSONException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 获取指定字段的内容
	 * 
	 * @param jsonFile
	 * @param param
	 * @return
	 */
	public static String getParam(String jsonFile, String param) {
		String result = null;
		JSONObject obj;
		JSONArray array;

		try {
			array = new JSONArray(jsonFile);
			if (array.length() > 0) {
				obj = array.getJSONObject(0);
				result = obj.getString(param);
			}

		} catch (JSONException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 从json文件中获取整型值
	 * 
	 * @param jsonFile
	 * @param param
	 * @return
	 */
	public static int getIntParam(String jsonFile, String param) {
		int result = -1;
		JSONObject obj;
		JSONArray array;

		try {
			array = new JSONArray(jsonFile);
			if (array.length() > 0) {
				obj = array.getJSONObject(0);
				result = obj.getInt(param);
			}

		} catch (JSONException e) {
			e.printStackTrace();
		}
		return result;
	}
	
	/**
	 * 构建 传输信息
	 * 
	 * @param map
	 * @return
	 */
	public static String constructMapJson(HashMap map) {
		Set set = map.keySet();
		JSONStringer jsonStringer = new JSONStringer();
		try {
			jsonStringer.array();
			jsonStringer.object();

			for (Iterator iterator = set.iterator(); iterator.hasNext();) {
				String key = (String) iterator.next();
				jsonStringer.key(key);
				jsonStringer.value(map.get(key));
			}
			jsonStringer.endObject();
			jsonStringer.endArray();
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return jsonStringer.toString();
	}


}

下面有一个实例，这个实例演示怎么使用这个工具

假定有一个类Person，注意，由于利用的是java的反射机制，所以这个类一定要是标准的JavaBean，被注解的属性必须有getter和setter方法。

package dikaros.example;

import java.util.Arrays;
import java.util.List;

import dikaros.json.annotation.JsonListParam;
import dikaros.json.annotation.JsonParam;
import dikaros.json.annotation.Jsonable;
import dikaros.json.annotation.JsonListParam.TYPE;

/**
 * 示例对象
 * @author Dikaros
 *
 */
public class Person implements Jsonable{
	public Person(String name, String gender, int age, String cityName) {
		this.name = name;
		this.gender = gender;
		this.age = age;
		this.cityName = cityName;
	}
	
	public Person() {
	}
	
	@JsonParam(name="name")
	String name;
	
	@JsonParam(name="gender")
	String gender;
	
	@JsonParam(name="age")
	int age;
	
	@JsonParam(name="cityName")
	String cityName;
	
	@JsonListParam(name="friends",contentClassName=Person.class,classType = TYPE.LIST)
	List<Person> friend;
	
	@JsonListParam(name="phones",contentClassName=String.class,classType = TYPE.ARRAY)
	String [] phones;
	
	
	/**
	 * @return name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name 要设置的 name
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return gender
	 */
	public String getGender() {
		return gender;
	}
	/**
	 * @param gender 要设置的 gender
	 */
	public void setGender(String gender) {
		this.gender = gender;
	}
	/**
	 * @return cityName
	 */
	public String getCityName() {
		return cityName;
	}
	/**
	 * @param cityName 要设置的 cityName
	 */
	public void setCityName(String cityName) {
		this.cityName = cityName;
	}
	/**
	 * @return age
	 */
	public int getAge() {
		return age;
	}
	/**
	 * @param age 要设置的 age
	 */
	public void setAge(int age) {
		this.age = age;
	}
	/**
	 * @return friend
	 */
	public List<Person> getFriend() {
		return friend;
	}
	/**
	 * @param friend 要设置的 friend
	 */
	public void setFriend(List<Person> friend) {
		this.friend = friend;
	}

	/* （非 Javadoc）
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Person [name=" + name + ", gender=" + gender + ", age=" + age
				+ ", cityName=" + cityName + ", friend=" + friend + ", phones="
				+ Arrays.toString(phones) + "]";
	}

	/**
	 * @return phones
	 */
	public String[] getPhones() {
		return phones;
	}

	/**
	 * @param phones 要设置的 phones
	 */
	public void setPhones(String[] phones) {
		this.phones = phones;
	}

	
	
}

下面是调用

package dikaros.example;

import java.util.ArrayList;

import dikaros.json.JsonExtendedUtil;

public class Example {
	public static void main(String[] args) throws Exception {
		Person person = new Person("老王", "男", 20, "长沙");
		String[] phones ={"13000000000","14000000000"};
		person.setPhones(phones);
		ArrayList<Person> friends = new ArrayList<>();
		friends.add(new Person("A妹子", "女", 19, "江西"));
		friends.add(new Person("B妹子", "女", 20, "湖北"));
		person.setFriend(friends);
		String jsonFile = JsonExtendedUtil.generateJson(person);
		System.out.println(jsonFile);
		
		Person person2 = (Person) JsonExtendedUtil.compileJson(Person.class, jsonFile);
		System.out.println(person2);
	}
}

输出结果

[{"name":"老王","gender":"男","age":20,"cityName":"长沙","friends":[{"name":"A妹纸","gender":"女","age":19,"cityName":"江西"},{"name":"B妹纸","gender":"女","age":20,"cityName":"湖北"}],"phones":["13000000000","14000000000"]}]
Person [name=老王, gender=男, age=20, cityName=长沙, friend=[Person [name=A妹纸, gender=女, age=19, cityName=江西, friend=null, phones=null], Person [name=B妹纸, gender=女, age=20, cityName=湖北, friend=null, phones=null]], phones=[13000000000,14000000000]]

我这里有整合了org.json的工具包，需要的可以下载，顺便换点积分 下载工具