1. 程式人生 > >JSON與Java物件互轉 工具類

JSON與Java物件互轉 工具類

話不多說,上程式碼~

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONObject;


class shop implements Serializable{
	private static final long serialVersionUID = 1L;
	String name;
	Date openTime;
	Date closeTime;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Date getOpenTime() {
		return openTime;
	}
	public void setOpenTime(Date openTime) {
		this.openTime = openTime;
	}
	public Date getCloseTime() {
		return closeTime;
	}
	public void setCloseTime(Date closeTime) {
		this.closeTime = closeTime;
	}
	
}

public class JSON {  
	static Logger logger = Logger.getLogger(JSON.class);
	
	
	public static void main(String[] args) {
		shop s1 = new shop();
		s1.setName("1..");
		s1.setOpenTime(new Date());
		try {
			System.out.println(JSON.toJson(s1));
			String s = "{\"name\":\"1..\",\"openTime\":\"2018-4-13 16:36:27\"}";
			shop ss = (shop)JSON.toObject(s, shop.class);
			System.out.println(ss.getOpenTime());
			System.out.println(ss.getCloseTime());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
    /** 
     * JSON字串轉成Object物件<br> 
     * 此方法假設沒有把子類當成父類去使用<br> 
     * 不然會出現解析出來的物件沒有子類屬性<br> 
     * @param json 
     * @param clazz 
     * @return 
     */  
    public static Object toObject(String json, Class<?> clazz) {  
        return toObject(json, clazz, null, null);  
    }  
      
    /** 
     * JSON字串轉成Object物件<br> 
     * 此方法可以把子類當成父類去使用<br> 
     * 但是需要提供一個map<br> 
     * 告訴程式對應的(子)類<br> 
     * @param json 
     * @param map 
     * @return 
     */  
    public static Object toObject(String json, Map<String,String> map) {  
        return toObject(json, null, null, map);  
    }  
      
    /** 
     * JSON字串轉成Object物件<br> 
     * 此方法可以把子類當成父類去使用<br> 
     * 但是需要提供一個基礎的basePackage<br> 
     * 並且在生成JSON的時候,也需要傳入這個basePackage 
     * @param json 
     * @return 
     */  
    public static Object toObject(String json, String basePackage) {  
        return toObject(json, null, basePackage, null);  
    }  
      
    /** 
     * JSON字串轉成Object物件<br> 
     * 此方法可以把子類當成父類去使用<br> 
     * 但是需要提供一個基礎的basePackage<br> 
     * 並且在生成JSON的時候,也需要傳入這個basePackage 
     * @param json 
     * @return 
     */  
    public static Object toObject(String json, Class<?> clazz, String basePackage) {  
        return toObject(json, clazz, basePackage, null);  
    }  
      
    /** 
     * Object物件轉成JSON字串<br> 
     * 此方法假設沒有把子類當成父類去使用<br> 
     * 不然反轉的時候可能會出現解析出來的物件沒有子類屬性<br> 
     * @param obj 
     * @return 
     */  
    public static String toJson(Object obj) {   
        return toJson(obj, null, false);  
    }  
      
    /** 
     * Object物件轉成JSON字串<br> 
     * 對應反轉方法:toObject(String json, Map<String,String> map) 
     * @param obj 
     * @param createClassInfo 
     * @return 
     */  
    public static String toJson(Object obj, boolean createClassInfo) {   
        return toJson(obj, null, createClassInfo);  
    }  
      
    /** 
     * Object物件轉成JSON字串<br> 
     * 對應反轉方法:toObject(String json, String basePackage) 
     * @param obj 
     * @return 
     */  
    public static String toJson(Object obj, String basePackage) {   
        return toJson(obj, basePackage, false);  
    }  
      
    public static String format(String json) {  
        String fillStringUnit = "  ";  
        if (json == null || json.trim().length() == 0) {  
            return null;  
        }  
  
        int fixedLenth = 0;  
        ArrayList<String> tokenList = new ArrayList<String>();  
        {  
            String jsonTemp = json;  
            // 預讀取  
            while (jsonTemp.length() > 0) {  
                String token = getToken(jsonTemp);  
                jsonTemp = jsonTemp.substring(token.length());  
                token = token.trim();  
                tokenList.add(token);  
            }  
        }  
  
        for (int i = 0; i < tokenList.size(); i++) {  
            String token = tokenList.get(i);  
            int length = token.getBytes().length;  
            if (length > fixedLenth && i < tokenList.size() - 1  
                    && tokenList.get(i + 1).equals(":")) {  
                fixedLenth = length;  
            }  
        }  
  
        StringBuilder buf = new StringBuilder();  
        int count = 0;  
        for (int i = 0; i < tokenList.size(); i++) {  
  
            String token = tokenList.get(i);  
  
            if (token.equals(",")) {  
                buf.append(token);  
                doFill(buf, count, fillStringUnit);  
                continue;  
            }  
            if (token.equals(":")) {  
                buf.append(" ").append(token).append(" ");  
                continue;  
            }  
            if (token.equals("{")) {  
                String nextToken = tokenList.get(i + 1);  
                if (nextToken.equals("}")) {  
                    i++;  
                    buf.append("{ }");  
                } else {  
                    count++;  
                    buf.append(token);  
                    doFill(buf, count, fillStringUnit);  
                }  
                continue;  
            }  
            if (token.equals("}")) {  
                count--;  
                doFill(buf, count, fillStringUnit);  
                buf.append(token);  
                continue;  
            }  
            if (token.equals("[")) {  
                String nextToken = tokenList.get(i + 1);  
                if (nextToken.equals("]")) {  
                    i++;  
                    buf.append("[ ]");  
                } else {  
                    count++;  
                    buf.append(token);  
                    doFill(buf, count, fillStringUnit);  
                }  
                continue;  
            }  
            if (token.equals("]")) {  
                count--;  
                doFill(buf, count, fillStringUnit);  
                buf.append(token);  
                continue;  
            }  
  
            buf.append(token);  
            // 左對齊  
            if (i < tokenList.size() - 1 && tokenList.get(i + 1).equals(":")) {  
                int fillLength = fixedLenth - token.getBytes().length;  
                if (fillLength > 0) {  
                    for (int j = 0; j < fillLength; j++) {  
                        buf.append(" ");  
                    }  
                }  
            }  
        }  
        return buf.toString();  
    }  
      
    /** 
     *  
     * @param json 
     *            JSONObject的字串形式 
     * @param clazz 
     *            Object的class 
     * @return 
     */  
    private static final String ENTER_REPLACE_STR = "\\n";  
    private static Object toObject(String json, Class<?> clazz, String basePackage, Map<String,String> map) {  
        if (json == null || json.equals("")) {  
            return json;  
        } else {  
            json = json.replace("\r\n", ENTER_REPLACE_STR).replace("\n", ENTER_REPLACE_STR);  
        }  
        Object object = null;  
        try {  
            if (json.charAt(0) == '[') {  
                object = toList(json, clazz, basePackage, map);  
            } else if (json.charAt(0) == '{'){  
                JSONObject infoObject = new JSONObject(json);  
                //  
                //  
                if (infoObject.has("class")) {  
                    String className = infoObject.getString("class");  
                    if (className != null) {  
                        if (map != null && map.get(className) != null) {  
                            clazz = Class.forName(map.get(className));  
                        } else if (basePackage != null) {  
                            clazz = Class.forName(basePackage + className);  
                        }  
                    }  
                }  
                if (clazz == null) {  
                    throw new NullPointerException("clazz, basePackage, map不能全部為空。");  
                }  
                object = clazz.newInstance();  
                //  
                //  
                Iterator<?> iterator = infoObject.keys();  
                while (iterator.hasNext()) {  
                    String key = (String) iterator.next();  
                    Object fieldValue = null;  
                    List<Field> fields = getAllFields(null, clazz);  
                    for (int i = 0; i < fields.size(); i++) {  
                        Field field = fields.get(i);  
                        if (field.getName().equalsIgnoreCase(key)) {  
                            field.setAccessible(true);  
                            fieldValue = getFieldValue(field, infoObject, key, basePackage, map);  
                            if (null != fieldValue) {  
                                field.set(object, fieldValue);  
                            }  
                            field.setAccessible(false);  
                        }  
                    }  
                }  
            } else {  
                return json;  
            }  
        } catch (Exception e) { 
        	e.printStackTrace();
        	logger.error("=====JSON EXCEPTION=====", e);  
        }  
        if (object instanceof List<?>) {  
            List<?> list = (List<?>) object;  
            for (int i = 0; i < list.size(); i++) {  
                replaceObjectBr(list.get(i));  
            }  
        } else {  
            replaceObjectBr(object);  
        }  
        return object;  
    }  
      
    /** 
     *  
     * @param json 
     *            JSONArray的字串形式 
     * @param clazz 
     *            List內物件的class 
     * @return 
     */  
    private static List<?> toList(String json, Class<?> clazz, String basePackage, Map<String,String> map) {  
        List<Object> list = null;  
        try {  
            JSONArray jsonArray = (JSONArray) new JSONArray(json);  
            list = new ArrayList<Object>();  
            for (int i = 0; i < jsonArray.length(); i++) {  
                String jsonvalue = jsonArray.getJSONObject(i).toString();  
                switch (getJSONType(jsonvalue)) {  
                case JSON_TYPE_OBJECT: {  
/*                  JSONObject subObject = new JSONObject(jsonvalue); 
                    Class<?> newClazz = null; 
                    if (subObject.has("class")) { 
                        String className = subObject.getString("class"); 
                        if (className != null) { 
                            if (map != null && map.get(className) != null) { 
                                newClazz = Class.forName(map.get(className)); 
                            } else if (basePackage != null) { 
                                newClazz = Class.forName(basePackage + className); 
                            } 
                        } 
                    }*/  
                    list.add(toObject(jsonvalue, clazz, basePackage, map));  
                    break;  
                }  
                case JSON_TYPE_ARRAY: {  
                    List<?> infoList = toList(jsonvalue, clazz, basePackage, map);  
                    list.add(infoList);  
                    break;  
                }  
                default:  
                    break;  
                }  
            }  
        } catch (Exception e) {  
        	e.printStackTrace();
            logger.error("=====JSON EXCEPTION=====", e);  
        }  
        return list;  
    }  
      
    private static String toJson(Object obj, String basePackage, boolean createClass) {  
        if (obj instanceof String) {  
            return obj.toString();  
        } else {  
            StringBuffer xmlBuffer = new StringBuffer("");  
            if (obj instanceof List<?>) {  
                xmlBuffer.append("[");  
                List<?> list = (List<?>) obj;  
                for (int i = 0; i < list.size(); i++) {  
                    addObjectToBuffer(xmlBuffer, list.get(i), basePackage, createClass);  
                    if (i < list.size() - 1) {  
                        xmlBuffer.append(",");  
                    }  
                }  
                xmlBuffer.append("]");  
            } else {  
                addObjectToBuffer(xmlBuffer, obj, basePackage, createClass);  
            }  
            return xmlBuffer.toString();  
        }  
    }  
      
    /** 
     * 在JSON->Object的時候 
     * 根據JSON的鍵(key) 
     * 生成Field的值(value) 
     * @param field 
     * @param infoObject 
     * @param key 
     * @param basePackage 
     * @return 
     * @throws Exception 
     */  
    private static Object getFieldValue(Field field, JSONObject infoObject, String key, String basePackage, Map<String,String> map) throws Exception {  
        Object fieldValue = null;  
        Class<?> fieldClass = field.getType();  
        if (fieldClass.getSimpleName().toString().equals("int")  
                || fieldClass.getSimpleName().toString().equals(  
                        "Integer")) {  
            fieldValue = infoObject.getInt(key);  
        } else if (fieldClass.getSimpleName().toString()  
                .equalsIgnoreCase("String")) {  
            fieldValue = infoObject.getString(key);  
        } else if (fieldClass.getSimpleName().toString()  
                .equalsIgnoreCase("double")) {  
            fieldValue = infoObject.getDouble(key);  
        } else if (fieldClass.getSimpleName().toString()  
                .equalsIgnoreCase("boolean")) {  
            fieldValue = infoObject.getBoolean(key);  
        } else if (fieldClass.getSimpleName().toString()  
                .equalsIgnoreCase("long")) {  
            fieldValue = infoObject.getLong(key);  
        } else if (fieldClass.getSimpleName().toString()  
                .equalsIgnoreCase("Date")) {  
            fieldValue = DateFormatUtil.toDate(infoObject.getString(key));  
        } else {  
            String jsonvalue = infoObject.getString(key);  
            switch (getJSONType(jsonvalue)) {  
            case JSON_TYPE_OBJECT: {  
                fieldValue = toObject(jsonvalue, fieldClass, basePackage, map);  
                break;  
            }  
            case JSON_TYPE_ARRAY: {  
                // 獲取泛型的class  
                Type genericFieldType = field.getGenericType();  
                if (genericFieldType instanceof ParameterizedType) {  
                    ParameterizedType aType = (ParameterizedType) genericFieldType;  
                    Type[] fieldArgTypes = aType  
                            .getActualTypeArguments();  
                    for (Type fieldArgType : fieldArgTypes) {  
                        Class<?> fieldArgClass = (Class<?>) fieldArgType;  
//                      if (map != null && map.get(key) != null) {  
//                          fieldArgClass = Class.forName(map.get(key));  
//                      }  
                        fieldValue = toList(jsonvalue, fieldArgClass, basePackage, map);  
                    }  
                }  
                break;  
            }  
            default:  
                break;  
            }  
        }  
        return fieldValue;  
    }  
      
    private static List<Field> getAllFields(List<Field> fields, Class<?> clazz) {  
        if (fields == null) {  
            fields = new ArrayList<Field>();  
        }  
        try {  
            if (clazz.getSuperclass() != null) {  
                Field[] fieldsSelf = clazz.getDeclaredFields();  
                for (Field field : fieldsSelf) {  
                    if (!Modifier.isFinal(field.getModifiers())) {  
                        fields.add(field);  
                    }  
                }  
                getAllFields(fields, clazz.getSuperclass());  
            }  
        } catch (Exception e) {  
        	e.printStackTrace();
            logger.error("=====JSON Exception=====", e);  
        }  
        return fields;  
    }  
      
    private static void addObjectToBuffer(StringBuffer xmlBuffer, Object obj, String basePackage, boolean createClass) {  
        xmlBuffer.append("{");  
        // 獲取所有屬性  
        List<Field> fields = new ArrayList<Field>();  
        getAllFields(fields, obj.getClass());  
        for (int i = -1; i < fields.size(); i++) {  
            if (i == -1) {  
                if (basePackage != null || createClass) {  
                    // 加入類資訊  
                    xmlBuffer.append("\"");  
                    xmlBuffer.append("class");  
                    xmlBuffer.append("\":");  
                    xmlBuffer.append("\"");  
                    if (basePackage != null) {  
                        xmlBuffer.append(obj.getClass().getName().replace(basePackage, ""));  
                    } else {  
                        xmlBuffer.append(obj.getClass().getSimpleName());  
                    }  
                    xmlBuffer.append("\",");  
                }  
                continue;  
            }  
            Field field = fields.get(i);  
            String fieldName = field.getName();  
            // 拼接GET方法名  
            Object fieldValue = null;  
            Method method = null;  
            try {  
                String methodName = "get" + ((char) (fieldName.charAt(0) - 32))  
                        + fieldName.substring(1);  
                // System.out.println("methodName->" + methodName);  
                method = obj.getClass().getMethod(methodName);  
            } catch (Exception e) {  
                String methodName = "is" + ((char) (fieldName.charAt(0) - 32))  
                        + fieldName.substring(1);  
                try {  
                    method = obj.getClass().getMethod(methodName);  
                } catch (Exception e1) {  
                	e1.printStackTrace();
                    logger.error("=====To JSON Object Exception=====", e);  
                }  
            }  
            if (method != null) {  
                try {  
                    fieldValue = method.invoke(obj);  
                } catch (Exception e) {  
                	e.printStackTrace();
                    logger.error("=====To JSON Object Exception=====", e);  
                }  
            }  
            if (null != fieldValue) {  
                xmlBuffer.append("\"");  
                xmlBuffer.append(fieldName);  
                xmlBuffer.append("\":");  
                if (fieldValue instanceof Date) {  
                    xmlBuffer.append("\"");  
                    xmlBuffer.append((DateFormatUtil.toTimeFormat((Date) fieldValue)));  
                    xmlBuffer.append("\"");  
                } else if (fieldValue instanceof Integer  
                        || fieldValue instanceof Double  
                        || fieldValue instanceof Long  
                        || fieldValue instanceof Boolean) {  
                    xmlBuffer.append("\"");  
                    xmlBuffer.append(fieldValue.toString());  
                    xmlBuffer.append("\"");  
                } else if (fieldValue instanceof String) {  
                    xmlBuffer.append("\"");  
                    String str = fieldValue.toString();  
                    xmlBuffer.append(str);  
                    xmlBuffer.append("\"");  
                } else if (fieldValue instanceof List<?>) {  
                    addListToBuffer(xmlBuffer, fieldValue, basePackage, createClass);  
                } else {  
                    addObjectToBuffer(xmlBuffer, fieldValue, basePackage, createClass);  
                }  
                xmlBuffer.append(",");  
            }  
            if (i == fields.size() - 1 && xmlBuffer.charAt(xmlBuffer.length() - 1) == ',') {  
                xmlBuffer.deleteCharAt(xmlBuffer.length() - 1);  
            }  
        }  
        xmlBuffer.append("}");  
    }  
  
    private static void addListToBuffer(StringBuffer xmlBuffer, Object fieldvalue, String basePackage,boolean createClass) {  
        xmlBuffer.append("[");  
        List<?> v_list = (List<?>) fieldvalue;  
        for (int i = 0; i < v_list.size(); i++) {  
            addObjectToBuffer(xmlBuffer, v_list.get(i), basePackage, createClass);  
            if (i < v_list.size() - 1) {  
                xmlBuffer.append(",");  
            }  
        }  
        xmlBuffer.append("]");  
    }  
  
    private static JSON_TYPE getJSONType(String str) {  
        final char[] strChar = str.substring(0, 1).toCharArray();  
        final char firstChar = strChar[0];  
        if (firstChar == '{') {  
            return JSON_TYPE.JSON_TYPE_OBJECT;  
        } else if (firstChar == '[') {  
            return JSON_TYPE.JSON_TYPE_ARRAY;  
        } else {  
            return JSON_TYPE.JSON_TYPE_ERROR;  
        }  
    }  
  
    private static String getToken(String json) {  
        StringBuilder buf = new StringBuilder();  
        boolean isInYinHao = false;  
        while (json.length() > 0) {  
            String token = json.substring(0, 1);  
            json = json.substring(1);  
  
            if (!isInYinHao  
                    && (token.equals(":") || token.equals("{")  
                            || token.equals("}") || token.equals("[")  
                            || token.equals("]") || token.equals(","))) {  
                if (buf.toString().trim().length() == 0) {  
                    buf.append(token);  
                }  
  
                break;  
            }  
  
            if (token.equals("\\")) {  
                buf.append(token);  
                buf.append(json.substring(0, 1));  
                json = json.substring(1);  
                continue;  
            }  
            if (token.equals("\"")) {  
                buf.append(token);  
                if (isInYinHao) {  
                    break;  
                } else {  
                    isInYinHao = true;  
                    continue;  
                }  
            }  
            buf.append(token);  
        }  
        return buf.toString();  
    }  
  
    private static void doFill(StringBuilder buf, int count, String fillStringUnit) {  
        buf.append("\n");  
        for (int i = 0; i < count; i++) {  
            buf.append(fillStringUnit);  
        }  
    }  
      
    /** 
     * 替換掉/n  
     * @param obj 此Object不可以是List 
     */  
    private static void replaceObjectBr(Object obj) {  
        // 獲取所有屬性  
        Field[] fields = obj.getClass().getDeclaredFields();  
        for (int i = 0; i < fields.length; i++) {  
            Field field = fields[i];  
            if (!Modifier.isFinal(field.getModifiers())) {  
                continue;  
            }  
            field.setAccessible(true);  
            Object fieldValue = null;  
            try {  
                fieldValue = field.get(obj);  
                if (fieldValue instanceof Integer) {  
                } else if (fieldValue instanceof Double) {  
                } else if (fieldValue instanceof Boolean) {  
                } else if (fieldValue instanceof Long) {  
                } else if (fieldValue instanceof Date) {  
                } else if (fieldValue instanceof String) {  
                    if (fieldValue != null) {  
                        String str = fieldValue.toString();  
                        field.set(obj, str.replaceAll(ENTER_REPLACE_STR, "\n"));  
                    }  
                }else if (fieldValue instanceof List<?>) {  
                    if (fieldValue != null) {  
                        List<?> list = (List<?>) fieldValue;  
                        for (int j = 0; j < list.size(); j++) {  
                            replaceObjectBr(list.get(j));  
                        }  
                    }  
                } else {  
                    if (fieldValue != null) {  
                        replaceObjectBr(fieldValue);  
                    }  
                }  
            } catch (Exception e) {  
            	e.printStackTrace();
                logger.error("=====JSON Exception=====", e);  
            } finally {  
                field.setAccessible(false);  
            }  
        }  
    }  
  
    private enum JSON_TYPE {  
        /** JSONObject */  
        JSON_TYPE_OBJECT,  
        /** JSONArray */  
        JSON_TYPE_ARRAY,  
        /** 不是JSON格式的字串 */  
        JSON_TYPE_ERROR  
    }  
} 
class DateFormatUtil{

	public static Object toDate(String string) {
		// TODO Auto-generated method stub
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = null;
		try {
			date = sdf.parse(string);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return date;
	}

	public static Object toTimeFormat(Date fieldValue) {
		
		return fieldValue.toLocaleString();
	}
	
}

自行刪除不必要的部分~