java json转换（一）

主要使用了2个类 JsonConvert.class 和 ConvertHelper.class

由于常规转json。只要model牵涉到复杂的关联实体对象。那么就会出现 深度循环的错误。

因此这里通过ConvertHelper.class来解决 深度循环的控制次数。

这个ConvertHelper.class也是同事网上找的，效率上可能慢了点。

但是一般转json，我的项目中都是为了存放到redis缓存的。所以之后也就不存在转换的情况了。

JsonConvert.class

import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import com.kintech.common.utils.log.LogerHelper;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.type.JavaType;
import org.codehaus.jackson.type.TypeReference;

public class JsonConvert {
    private static final Logger logger = Logger.getLogger(JsonConvert.class);
    private static final ObjectMapper mapper = new ObjectMapper(); //转换器
    static{

mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true) ;
mapper.disable(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS); //忽略映射属性
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    }

    /**
     * java对象(包括list)转json
     * @throws Exception
     */
    public static String toJSON(Object object){
        try {
            return mapper.writeValueAsString(object);
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }

    } 

    /**
     * 针对hibernate关联model深度循环转json
     * @throws Exception
     */
    public static String toHJSON(Object object,int layer){
        try {
            if(object instanceof List){
                object = ConverHelper.getListCopy((List)object, layer);
            }else if(object instanceof Set){
                object = ConverHelper.getSetCopy((Set)object, layer);
            }else{
                object = ConverHelper.getCopy(layer,object);
            }
            return mapper.writeValueAsString(object);
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }

    } 

    /**
     * 针对hibernate关联model深度循环转json
     * @throws Exception
     */
    public static String toHJSON(Object object){
        try {
            if(object instanceof List){
                object = ConverHelper.getListCopy((List)object);
            }else if(object instanceof Set){
                object = ConverHelper.getSetCopy((Set)object);
            }else{
                object = ConverHelper.getCopy(object);
            }
            return mapper.writeValueAsString(object);
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }

    } 

    /**
     * json转java对象
     * @param json
     * @param cs
     * @throws Exception
     */
    public static <T> T fromJson(String json, Class<T> cs) {
        try {
            return mapper.readValue(json, cs);
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }
    }

         /**
     * json转java对象(Model中含有List<T>)
         * 针对错误：java.util.LinkedHashMap cannot be cast to .....
     * @param json
     * @param cs
     * @throws Exception
     */
    public static <T> T fromJson(String json, TypeReference<T> cs) {
        try {
            return mapper.readValue(json, cs);
        } catch (Exception e) {
            //e.printStackTrace();
            throw new RuntimeException(MESSAGE);
        }
    }

    /**
     * json转map
     * @param json
     * @param cs
     * @return
     * @throws Exception
     */
    public static Map toMap(String json, Class<Map> cs) {
        try {
            return mapper.readValue(json, cs);
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }

    }

    /**
     * json转list
     * @param json
     * @param beanClass
     * @return
     * @throws Exception
     */
    public static <T> List<T> jsonToList(String json, Class<T> beanClass) {
        try {
            return (List<T>) mapper.readValue(json, getCollectionType(List.class, beanClass));
        } catch (Exception e) {
            //e.printStackTrace();
            LogerHelper.WebLog(LogerHelper.getPrintStr(e));
            return null;
        }

    } 

    public static JavaType getCollectionType(Class<?> collectionClass, Class<?> elementClasses) {
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }   

}

ConvertHelper

package com.kps.common.utils;

import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.log4j.Logger;
import org.hibernate.collection.internal.PersistentBag;
import org.hibernate.collection.internal.PersistentMap;
import org.hibernate.collection.internal.PersistentSet;
import com.kps.model.SuperBaseModel;

/**
 * 按层次copy hibernate对象
 *
 */
@SuppressWarnings("all")
public class ConverHelper{
    private static final Logger logger = Logger.getLogger(ConverHelper.class);
    private static String MESSAGE = "copy object error!";
    private static int LAYER =3;

    /**
     * 得到属性（包括父类）
     */
    private static List<Field> getFields(Class cs){
        List<Field> fieldList = new ArrayList<>() ;
        Class tempClass = cs;
        while (tempClass != null) {//当父类为null的时候说明到达了最上层的父类(Object类).
              fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
              tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
        }
        return fieldList;

    }

    /**
     * 最核心的方法，用来解析hibernate model；
     * @param layer 解析深度
     * @param t 为hibernate model
     *
     */
    public static <T> T getCopy(T t,int...layers) {
        if (t == null) return null;
        if (t instanceof SuperBaseModel) { //如果为hibernate映射model
            int layer = LAYER;
            if (layers != null && layers.length > 0) {
                layer = layers[0];
            }

            if (layer > 0) {
                layer--;
            } else {
                return null;
            }

            try {
                Class<?> oClass = (Class<?>) t.getClass();
                String className = oClass.getName();

                // 通过观察发现代理对象(懒加载)和实体对象是有关联的
                // 规律大概是“类名_字符串”，这样可以通过传入对象取实体对象的类名（包括传入实体对象）;
                // 懒加载为代理对象不让查询数据库
                if(className.indexOf("_")>=0) return null;

                String entityClassName = className.split("_")[0];
                Class entityClass = Class.forName(entityClassName);// 获取实体对象class实例
                Object newT = entityClass.newInstance();// 创建实体对象用于储存传入对象信息;
                List<Field> fields = getFields(entityClass);
                for (Field f : fields) { // 反射获取对象属性拼出get、set方法
                    String fieldName = f.getName();
                    if (fieldName.equalsIgnoreCase("serialVersionUID")) {
                        continue;
                    }
                    String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                    String setMethodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                    Method getMethod = oClass.getMethod(getMethodName);
                    Object obj = getMethod.invoke(t);// 获取属性的值
                    if (obj != null) {
                        /*
                         * System.out.println("转换"+obj);
                         * System.out.println("转换"+obj.getClass());
                         * System.out.println("转换"+ntClass);
                         */
                        /*
                         * logger.info("转换" + obj); logger.info("转换" +
                         * obj.getClass()); logger.info("转换" + ntClass);
                         */

                        // 通过观察发现代理对象(懒加载)和实体对象是有关联的
                        // 规律大概是“类名_字符串”，这样可以通过传入对象取实体对象的类名（包括传入实体对象）;
                        String objClassName = obj.getClass().getName().split("_")[0];
                        Class objClass = Class.forName(objClassName);
                        if (objClass.isAssignableFrom(PersistentSet.class)||objClass.isAssignableFrom(HashSet.class))// 关联查询属性是set hibernate返回的是PersistentSet
                            objClass = Set.class;
                        else if (objClass.isAssignableFrom(PersistentBag.class)||objClass.isAssignableFrom(ArrayList.class))//关联查询属性是list hibernate返回的是PersistentBag
                            objClass = List.class;
                        else if (objClass.isAssignableFrom(PersistentMap.class)||objClass.isAssignableFrom(HashMap.class))//关联查询属性是Map hibernate返回的是PersistentMap
                            objClass = Map.class;
                        else if (objClass.isAssignableFrom(Timestamp.class))// 处理数据库取到时间的问题
                            objClass = Date.class;
                        Method setmethod = entityClass.getMethod(setMethodName, objClass);// 获取实体类中的set方法；
                        if (obj instanceof Set) { //如果属于set调用getSetCopy方法
                            Set<Object> set = (Set<Object>) obj;
                            setmethod.invoke(newT, getSetCopy(set, layer));
                        } else if (obj instanceof List) { //如果属于list调用getListCopy方法
                            List<Object> list = (List<Object>) obj;
                            setmethod.invoke(newT, getListCopy(list, layer));
                        } else if (obj instanceof Map) { //如果属于map调用getMapCopy方法
                            Map map = (Map)obj;
                            setmethod.invoke(newT, getMapCopy(map, layer));
                        }else {// 属于其他类型
                            setmethod.invoke(newT, getCopy(obj, layer));
                        }
                    }
                }
                return (T) newT;

            } catch (Exception e) {
                logger.error(LogerHelper.getPrintStr(e));
                throw new RuntimeException(MESSAGE);
            }

        }else{
            return t;
        }

    }

    /**
     * @param layer
     * @param T 为hibernate model
     * @return
     */
    public static <T> Set<T> getSetCopy(Set<T> set, int...layers) {
        if(set==null) return null;
        int layer = LAYER;
        if(layers!=null&&layers.length>0){
            layer = layers[0];
        }
//        if (layer > 0) {
//            layer--;
//        } else {
//            return null;
//        }
        Set<T> newSet = new HashSet<T>();
        for (T obj : set) {
            newSet.add(getCopy(obj,layer));
        }
        return newSet;
    }

    /**
     * @param layer
     * @param T 为hibernate model
     */
    public static <T> List<T> getListCopy(List<T> list, int...layers) {
        if (list == null) return null;
        int layer = LAYER;
        if(layers!=null&&layers.length>0){
            layer = layers[0];
        }
       /* if (layer > 0) {
            layer--;
        } else {
            return null;
        }*/
        ArrayList<T> arrayList = new ArrayList<T>();
        for (T obj : list) {
            arrayList.add(getCopy(obj,layer));
        }
        return arrayList;
    }

    /**
     * @param layer
     * @param T 为hibernate model
     */
    public static <K,V> Map<K,V> getMapCopy(Map<K,V> map, int...layers) {
        if (map == null) return null;
        int layer = LAYER;
        if(layers!=null&&layers.length>0){
            layer = layers[0];
        }
       /* if (layer > 0) {
            layer--;
        } else {
            return null;
        }*/
        Map<K,V> rMap = new HashMap<K, V>();
        for (K key : map.keySet()) {
            rMap.put(key, getCopy(map.get(key),layer));
        }
        return rMap;
    }

}