将JavaBean 封装成JSON格式的字符串
封装JSON数据的代码片段
List<UserBean> listUser = new ArrayList<>(); //创建一个List集合
Map<String, UserBean> mapUser = new HashMap<>(); //创建一个Map集合
mapUser.put("map-key", new UserBean(4, "map-1", 10, 2.456789, null,null, null)); //添加一个map的元素
listUser.add(new UserBean(3, "list-1", 17, 1.456, null, null, null));//添加一个list的元素
UserBean[] arrayUser = { new UserBean(2, "array-1", 16, 10.0123456,null, null, null) }; //创建一个对象数组并添加一个元素
UserBean us = new UserBean(1, "大白", 18, 3.230, listUser, mapUser,arrayUser); //将list map 对象数组 都设置到JavaBean当中
Pson pson = Pson.Instance(); //初始化工具类
/**
* 使用工具进行封装JavaBean中的所有字段
*/
String jsonStr = pson.objectToJson(us);
System.out.println(jsonStr);
/**
* 使用工具进行封装JavaBean中的ID 与名字
*/
jsonStr = pson.objectToJson(us,"id","name");
System.out.println(jsonStr);
封装JSON格式后的数据
//封装所有的字段
{"id":1,"name":"大白","age":18,"money":3.23,"listUser":[{"id":3,"name":"list-1","age":17,"money":1.456}],"mapUser":{"map-key":{"id":4,"name":"map-1","age":10,"money":2.456789}},"arrayUser":[{"id":2,"name":"array-1","age":16,"money":10.0123456}]}
//封装指定的字段
{"id":1,"name":"大白"}
将JSON格式字符串解析成Object实体类
首先准备两个JSON格式的数据 一个为对象 一个为数组
JSON-1: String jsonStr = {"id":1,"name":"大白","age":18,"money":1.0453}
JSON-2: String jsonArray = [{"id":1,"name":"大白","age":18,"money":2.0453},{"id":1,"name":"大白","age":18,"money":1.0453}]
解析对象
Pson pson = Pson.Instance();
/**
* 调用工具类进行解析 一参为被解析的类的class对象 二参为JSON格式的字符串数据
*/
UserBean ub = pson.jsonToObject(UserBean.class, jsonStr);
System.out.println(ub);
//解析完毕后打印的ub对象
UserBean [id=1, name=大白, age=18, money=1.0453, listUser=null, mapUser=null, arrayUser=null]
解析数组
UserBean users[] = {}; // 首先先初始化一个空的数组
users = pson.jsonToObject(users.getClass(), jsonArray);
for (UserBean u : users) {
System.out.println(u);
}
//解析完毕后打印的数组元素
UserBean [id=1, name=大白1, age=18, money=1.0453, listUser=null, mapUser=null, arrayUser=null]
UserBean [id=2, name=大白2, age=18, money=2.0453, listUser=null, mapUser=null, arrayUser=null]
JSON工具类
使用工具类前需要有原生org.json包 <a href="http://www.jianshu.com/p/35ed550c5c9a">前往下载</a>
之前因为不太喜欢第三方的东西 虽然知道有Gson这类的第三方工具
所以自己动手写了一个工具
public class Pson {
private String pattern = "yyyy-MM-dd HH:mm:ss";//时间格式
public void setPattern(String pattern) {
this.pattern = pattern;
}
public static final Pson pson = new Pson();
public static Pson Instance() {
return pson;
}
private Pson() {
}
/**
* 将对象 转换成JSON格式的字符串
*
* @param object 需要封装的对象
* @param fieldName 需要封装的指定字段 如果为空 则封装所有字段
* @return 返回封装后的JSON格式的字符串
*/
public Object objectToJson(Object object, String... fieldName) {
return ObjectToString(object, fieldName);
}
/**
* 将对象 转换成JSON格式的字符串
*
* @param object
* @param fieldName 需要封装指定的字段
* @return 接收到之后 调用toString即可
*/
private Object ObjectToString(Object object, String... fieldName) {
if (object == null) {
return null;
} else if (object instanceof List<?>) { // 判断是否是List集合
List<Object> list = (List<Object>) object;
JSONArray array = new JSONArray();
if (list.size() != 0) {
Object oneObject = list.get(0);// 先取出第一个元素 然后判断是否是基本数据类型
// 或者String类型
if (toBasicData(oneObject)) { // 元素是基本数据类型
for (Object element : list) {
array.put(element);
}
} else {
for (Object element : list) {
array.put(ObjectToString(element, fieldName));
}
}
}
return array;
} else if (object.getClass().isArray()) {
Object oArray[] = (Object[]) object;
JSONArray jsonArray = new JSONArray();
/**
* 判断数组长度
*/
if (oArray.length != 0) {
if (toBasicData(oArray[0])) { // 判断数组的元素是基本数据 还是对象
for (Object elementObject : oArray) {
jsonArray.put(elementObject);
}
} else {
for (Object elementObject : oArray) {
jsonArray.put(ObjectToString(elementObject, fieldName));
}
}
}
return jsonArray;
} else if (object instanceof Map) {
Map<String, Object> map = (Map<String, Object>) object;
Set<Map.Entry<String, Object>> entries = map.entrySet();
JSONObject jsonObject = new JSONObject();
if (fieldName.length != 0) {//判断是否需要解析指定的字段
for (String keyName :
fieldName) {
jsonPutMap(jsonObject, keyName, map.get(keyName), fieldName);
}
} else {
/**
* 遍历MAP集合
*/
for (Map.Entry<String, Object> entry : entries) {
jsonPutMap(jsonObject, entry.getKey(), entry.getValue(), fieldName);
}
}
return jsonObject;
} else if (object instanceof Date) { //时间类
return new SimpleDateFormat(pattern).format((Date) object);
}
JSONObject json = new JSONObject();
Class<?> c = object.getClass();
Field fs[] = null;
if (fieldName != null && fieldName.length != 0) { // 判断是否需要 取出指定的字段
int len = fieldName.length;
fs = new Field[len];
int i = 0;
for (String s : fieldName) {
try {
fs[i] = c.getDeclaredField(s);
} catch (NoSuchFieldException | SecurityException e) {
e.printStackTrace();
}
i++;
}
} else {
fs = c.getDeclaredFields();
}
for (Field f : fs) {
if (f == null)
continue;
f.setAccessible(true);
try {
Object o = f.get(object);
if (o != null) { // 判断属性内容是否为空
if (toBasicData(o)) { // 判断是否是基本数据类型 或者是String类型
json.put(f.getName(), o);
} else { // 可能是一个JavaBean 或者是集合
json.put(f.getName(), ObjectToString(o, fieldName));
}
} else {
json.put(f.getName(), o);
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
}
}
return json;
}
/**
* 判断是否是字符串 或者是 基本数据类型
*
* @param object
* @return 基本数据类型|字符串类型 返回true
*/
private boolean toBasicData(Object object) {
if (object == null) {
return false;
} else if (object instanceof String || object instanceof Integer || object instanceof Boolean
|| object instanceof Character || object instanceof Byte || object instanceof Short
|| object instanceof Long || object instanceof Float || object instanceof Double) {
return true;
}
return false;
}
/**
* 判断是否是字符串 或者是 基本数据类型
*
* @param oc
* @return 基本数据类型|字符串类型 返回true
*/
private boolean toBasicData(Class<?> oc) {
if (oc.isPrimitive() || oc.isAssignableFrom(String.class) || oc.isAssignableFrom(Integer.class)
|| oc.isAssignableFrom(Boolean.class) || oc.isAssignableFrom(Character.class)
|| oc.isAssignableFrom(Byte.class) || oc.isAssignableFrom(Short.class)
|| oc.isAssignableFrom(Long.class) || oc.isAssignableFrom(Float.class)
|| oc.isAssignableFrom(Double.class)) {
return true;
}
return false;
}
/**
* 将JSON转JavaBean对象实例
*
* @param oClass JavaBean的Class对象
* @param jsonStr JSON对象
* @param <T>
* @return
*/
public <T> T jsonToObject(Class<?> oClass, String jsonStr) {
T objectData = null;
try {
if (oClass.isArray()) {// 该class为数组的时候
JSONArray array = new JSONArray(jsonStr);
int len = array.length();
// 获取到数组元素的class
Class<?> ComponentType = oClass.getComponentType();
Object createArray = Array.newInstance(ComponentType, array.length());// 创建一个与JSON数组长度相同的数组
if (toBasicData(ComponentType.newInstance())) { // 进行判断是否是基本数据类型或字符串类型
for (int i = 0; i < len; i++) {
Array.set(createArray, i, array.get(i));
}
} else {
for (int i = 0; i < len; i++) {
Array.set(createArray, i, jsonToObject(ComponentType, array.get(i).toString()));
}
}
objectData = (T) createArray;
} else if (oClass.isAssignableFrom(Date.class)) {//时间类型
Date parse = new SimpleDateFormat(pattern).parse(jsonStr);
objectData = (T) parse;
} else {// 如果不是数组的话 则默认以JavaBean的形式进行解析
objectData = (T) oClass.newInstance(); // 创建该class的对象的实例
JSONObject json = new JSONObject(jsonStr);
Field[] fields = oClass.getDeclaredFields();// 获取到所有的属性
for (Field fs : fields) {// 开始遍历属性
fs.setAccessible(true);
Class<?> cl = fs.getType(); // 取出该属性代表的class
String fieldName = fs.getName(); // 取出该属性的名称
/**
* 判断该属性名字在json中不为空
*/
if (!json.isNull(fieldName)) {
String jsonData = json.get(fieldName).toString();
/**
* 判断 属性字段是否是数组类型
*/
if (cl.isArray()) {
fs.set(objectData, analyticArray(cl, jsonData));
} else if (toBasicData(cl)) { // 基本数据类型
fs.set(objectData, json.get(fieldName));
} else if (cl.isInterface()) { // 接口
Object oj = analyticInterface(cl, (ParameterizedType) fs.getGenericType(), jsonData);
fs.set(objectData, oj);
} else if (cl.isAssignableFrom(ArrayList.class)) { // 判断该成员属性是否为ArrayList集合
Object oj = analyticInterface(List.class, (ParameterizedType) fs.getGenericType(),
jsonData);
fs.set(objectData, oj);
} else if (cl.isAssignableFrom(HashMap.class)) { // 判断该成员属性是否为HashMap集合
Object oj = analyticInterface(Map.class, (ParameterizedType) fs.getGenericType(), jsonData);
fs.set(objectData, oj);
} else { // 如果以上条件都没有成立 则当对象来解析
fs.set(objectData, jsonToObject(cl, jsonData));
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return objectData;
}
/**
* 解析数组数据
*
* @param arrayClass 数组的class对象
* @param jsonStr Json格式的字符串数据
* @return
*/
private Object analyticArray(Class<?> arrayClass, String jsonStr) {
try {
// 首先 先获取到数组的子元素的类型class
Class<?> componentType = arrayClass.getComponentType();
// 判断子元素类型 是否是基本类型 或者是String类型
boolean is = toBasicData(componentType.newInstance());
JSONArray jsonArray = new JSONArray(jsonStr);
int len = jsonArray.length();
/**
* 创建一个与该数组类型一至 长度与JSONArray长度一致的数组
*/
Object elementObject = Array.newInstance(componentType, len);
if (is) {
for (int i = 0; i < len; i++) {
Array.set(elementObject, i, jsonArray.get(i));
}
} else { // 如果不是基本数据类型的话 则调用解析对象的方法
for (int i = 0; i < len; i++) {
Array.set(elementObject, i, jsonToObject(componentType, jsonArray.getString(i)));
}
}
return elementObject;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 解析成员属性为接口的方法 只支持Map List 集合接口 其他的 均返回null
*
* @param interfaceClass 接口Class对象
* @param jsonStr JSON格式的文本
* @param parameterizedType 泛型的管理
* @return 返回解析后的实例
*/
private Object analyticInterface(Class<?> interfaceClass, ParameterizedType parameterizedType, String jsonStr) {
Object breakObject = null;
try {
if (interfaceClass.isAssignableFrom(List.class)) { // List集合
JSONArray array = new JSONArray(jsonStr);
int len = array.length();
Class<?> c = (Class<?>) parameterizedType.getActualTypeArguments()[0];// 获取到List集合的泛型
List<Object> list = new ArrayList<>();
if (toBasicData(c)) {// 判断List的泛型是否为String 或基本类型
for (int i = 0; i < len; i++) {
list.add(array.get(i));
}
} else {// 调用解析对象方法
for (int i = 0; i < len; i++) {
list.add(jsonToObject(c, array.getString(i)));
}
}
breakObject = list;
} else if (interfaceClass.isAssignableFrom(Map.class)) {
/**
* 如果是map集合的话 是会有两个泛型的 对应的为 key value
*/
Class<?> k = (Class<?>) parameterizedType.getActualTypeArguments()[0];
Class<?> v = (Class<?>) parameterizedType.getActualTypeArguments()[1];
if (!k.isAssignableFrom(String.class)) {
throw new ClassCastException("key 请用String类型");
} else {
Map<String, Object> map = new HashMap<>();
JSONObject json = new JSONObject(jsonStr);
Iterator<String> iterator = json.keys();
if (toBasicData(v)) {// 判断value是否为基本类型或String类型
while (iterator.hasNext()) {
String key = iterator.next();
map.put(key, json.get(key));
}
} else {
while (iterator.hasNext()) {
String key = iterator.next();
map.put(key, jsonToObject(v, json.getString(key)));
}
}
breakObject = map;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return breakObject;
}
/**
* JSON put map的key values
*
* @param jsonObject
* @param key
* @param values
* @param fieldName
*/
private void jsonPutMap(JSONObject jsonObject, String key, Object values, String... fieldName) {
try {
if (toBasicData(values)) {// 判断是否是基本数据类型
jsonObject.put(key, values);
} else {
jsonObject.put(key, ObjectToString(values, fieldName));
}
} catch (JSONException e) {
e.printStackTrace();
}
}
}
