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

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

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

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

 

JsonConvert.class

  1. import java.util.List;
  2. import java.util.Map;
  3. import java.util.Set;
  4. import org.apache.log4j.Logger;
  5. import com.kintech.common.utils.log.LogerHelper;
  6. import org.codehaus.jackson.map.DeserializationConfig;
  7. import org.codehaus.jackson.map.ObjectMapper;
  8. import org.codehaus.jackson.map.SerializationConfig;
  9. import org.codehaus.jackson.type.JavaType;
  10. import org.codehaus.jackson.type.TypeReference;
  12. public class JsonConvert {
  13.     private static final Logger logger = Logger.getLogger(JsonConvert.class);
  14.     private static final ObjectMapper mapper = new ObjectMapper(); //转换器
  15.     static{
  1. 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"));
  1.     }
  2.     
  3.     /**
  4.      * java对象(包括list)转json
  5.      * @throws Exception 
  6.      */
  7.     public static String toJSON(Object object){
  8.         try {
  9.             return mapper.writeValueAsString(object);
  10.         } catch (Exception e) {
  11.             //e.printStackTrace();
  12.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  13.             return null;
  14.         }
  15.         
  16.     } 
  17.     
  18.     
  19.     /**
  20.      * 针对hibernate关联model深度循环转json
  21.      * @throws Exception 
  22.      */
  23.     public static String toHJSON(Object object,int layer){
  24.         try {
  25.             if(object instanceof List){
  26.                 object = ConverHelper.getListCopy((List)object, layer);
  27.             }else if(object instanceof Set){
  28.                 object = ConverHelper.getSetCopy((Set)object, layer);
  29.             }else{
  30.                 object = ConverHelper.getCopy(layer,object);
  31.             }
  32.             return mapper.writeValueAsString(object);
  33.         } catch (Exception e) {
  34.             //e.printStackTrace();
  35.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  36.             return null;
  37.         }
  38.         
  39.     } 
  40.     
  41.     /**
  42.      * 针对hibernate关联model深度循环转json
  43.      * @throws Exception 
  44.      */
  45.     public static String toHJSON(Object object){
  46.         try {
  47.             if(object instanceof List){
  48.                 object = ConverHelper.getListCopy((List)object);
  49.             }else if(object instanceof Set){
  50.                 object = ConverHelper.getSetCopy((Set)object);
  51.             }else{
  52.                 object = ConverHelper.getCopy(object);
  53.             }
  54.             return mapper.writeValueAsString(object);
  55.         } catch (Exception e) {
  56.             //e.printStackTrace();
  57.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  58.             return null;
  59.         }
  60.         
  61.     } 
  62.     
  63.     
  64.     
  65.     /**
  66.      * json转java对象
  67.      * @param json
  68.      * @param cs
  69.      * @throws Exception
  70.      */
  71.     public static <T> T fromJson(String json, Class<T> cs) {
  72.         try {
  73.             return mapper.readValue(json, cs);
  74.         } catch (Exception e) {
  75.             //e.printStackTrace();
  76.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  77.             return null;
  78.         }
  79.     }
  80.     
  81.          /**
  82.      * json转java对象(Model中含有List<T>)
  83.          * 针对错误：java.util.LinkedHashMap cannot be cast to .....
  84.      * @param json
  85.      * @param cs
  86.      * @throws Exception
  87.      */
  88.     public static <T> T fromJson(String json, TypeReference<T> cs) {
  89.         try {
  90.             return mapper.readValue(json, cs);
  91.         } catch (Exception e) {
  92.             //e.printStackTrace();
  93.             throw new RuntimeException(MESSAGE);
  94.         }
  95.     }
  97.     /**
  98.      * json转map
  99.      * @param json
  100.      * @param cs
  101.      * @return
  102.      * @throws Exception
  103.      */
  104.     public static Map toMap(String json, Class<Map> cs) {
  105.         try {
  106.             return mapper.readValue(json, cs);
  107.         } catch (Exception e) {
  108.             //e.printStackTrace();
  109.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  110.             return null;
  111.         }
  113.     }
  114.     
  115.     /**
  116.      * json转list
  117.      * @param json
  118.      * @param beanClass
  119.      * @return
  120.      * @throws Exception
  121.      */
  122.     public static <T> List<T> jsonToList(String json, Class<T> beanClass) {
  123.         try {
  124.             return (List<T>) mapper.readValue(json, getCollectionType(List.class, beanClass));
  125.         } catch (Exception e) {
  126.             //e.printStackTrace();
  127.             LogerHelper.WebLog(LogerHelper.getPrintStr(e));
  128.             return null;
  129.         }
  131.     } 
  132.     
  133.     public static JavaType getCollectionType(Class<?> collectionClass, Class<?> elementClasses) {
  134.         return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);     
  135.     }   
  136.     
  137. }

 

ConvertHelper（类名不要带 _ ）

  1. package com.kps.common.utils;
  3. import java.io.ObjectInputStream.GetField;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.sql.Timestamp;
  7. import java.util.ArrayList;
  8. import java.util.Arrays;
  9. import java.util.Date;
  10. import java.util.HashMap;
  11. import java.util.HashSet;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.Map.Entry;
  15. import java.util.Set;
  16. import org.apache.log4j.Logger;
  17. import org.hibernate.collection.internal.PersistentBag;
  18. import org.hibernate.collection.internal.PersistentMap;
  19. import org.hibernate.collection.internal.PersistentSet;
  20. import com.kps.model.SuperBaseModel;
  22. /**
  23.  * 按层次copy hibernate对象
  24.  * 
  25.  */
  26. @SuppressWarnings("all")
  27. public class ConverHelper{
  28.     private static final Logger logger = Logger.getLogger(ConverHelper.class);
  29.     private static String MESSAGE = "copy object error!"; 
  30.     private static int LAYER =3;
  31.     
  32.     /**
  33.      * 得到属性（包括父类）
  34.      */
  35.     private static List<Field> getFields(Class cs){
  36.         List<Field> fieldList = new ArrayList<>() ;
  37.         Class tempClass = cs;
  38.         while (tempClass != null) {//当父类为null的时候说明到达了最上层的父类(Object类).
  39.               fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
  40.               tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
  41.         }
  42.         return fieldList;
  43.         
  44.     }
  45.     
  46.     /**
  47.      * 最核心的方法，用来解析hibernate model；
  48.      * @param layer 解析深度
  49.      * @param t 为hibernate model
  50.      * 
  51.      */
  52.     public static <T> T getCopy(T t,int...layers) {
  53.         if (t == null) return null;
  54.         if (t instanceof SuperBaseModel) { //如果为hibernate映射model
  55.             int layer = LAYER;
  56.             if (layers != null && layers.length > 0) {
  57.                 layer = layers[0];
  58.             }
  59.             
  60.             if (layer > 0) {
  61.                 layer--;
  62.             } else {
  63.                 return null;
  64.             }
  66.             try {
  67.                 Class<?> oClass = (Class<?>) t.getClass();
  68.                 String className = oClass.getName();
  69.                 
  70.                 // 通过观察发现代理对象(懒加载)和实体对象是有关联的
  71.                 // 规律大概是“类名_字符串”，这样可以通过传入对象取实体对象的类名（包括传入实体对象）;
  72.                 // 懒加载为代理对象不让查询数据库
  73.                 if(className.indexOf("_")>=0) return null;
  74.                 
  75.                 String entityClassName = className.split("_")[0];
  76.                 Class entityClass = Class.forName(entityClassName);// 获取实体对象class实例
  77.                 Object newT = entityClass.newInstance();// 创建实体对象用于储存传入对象信息;
  78.                 List<Field> fields = getFields(entityClass);
  79.                 for (Field f : fields) { // 反射获取对象属性拼出get、set方法
  80.                     String fieldName = f.getName();
  81.                     if (fieldName.equalsIgnoreCase("serialVersionUID")) {
  82.                         continue;
  83.                     }
  84.                     String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
  85.                     String setMethodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
  86.                     Method getMethod = oClass.getMethod(getMethodName);
  87.                     Object obj = getMethod.invoke(t);// 获取属性的值
  88.                     if (obj != null) {
  89.                         /*
  90.                          * System.out.println("转换"+obj);
  91.                          * System.out.println("转换"+obj.getClass());
  92.                          * System.out.println("转换"+ntClass);
  93.                          */
  94.                         /*
  95.                          * logger.info("转换" + obj); logger.info("转换" +
  96.                          * obj.getClass()); logger.info("转换" + ntClass);
  97.                          */
  98.                         
  99.                         // 通过观察发现代理对象(懒加载)和实体对象是有关联的
  100.                         // 规律大概是“类名_字符串”，这样可以通过传入对象取实体对象的类名（包括传入实体对象）;
  101.                         String objClassName = obj.getClass().getName().split("_")[0];
  102.                         Class objClass = Class.forName(objClassName);
  103.                         if (objClass.isAssignableFrom(PersistentSet.class)||objClass.isAssignableFrom(HashSet.class))// 关联查询属性是set hibernate返回的是PersistentSet
  104.                             objClass = Set.class;
  105.                         else if (objClass.isAssignableFrom(PersistentBag.class)||objClass.isAssignableFrom(ArrayList.class))//关联查询属性是list hibernate返回的是PersistentBag
  106.                             objClass = List.class;
  107.                         else if (objClass.isAssignableFrom(PersistentMap.class)||objClass.isAssignableFrom(HashMap.class))//关联查询属性是Map hibernate返回的是PersistentMap
  108.                             objClass = Map.class;
  109.                         else if (objClass.isAssignableFrom(Timestamp.class))// 处理数据库取到时间的问题
  110.                             objClass = Date.class;
  111.                         Method setmethod = entityClass.getMethod(setMethodName, objClass);// 获取实体类中的set方法；
  112.                         if (obj instanceof Set) { //如果属于set调用getSetCopy方法
  113.                             Set<Object> set = (Set<Object>) obj;
  114.                             setmethod.invoke(newT, getSetCopy(set, layer));
  115.                         } else if (obj instanceof List) { //如果属于list调用getListCopy方法
  116.                             List<Object> list = (List<Object>) obj;
  117.                             setmethod.invoke(newT, getListCopy(list, layer));
  118.                         } else if (obj instanceof Map) { //如果属于map调用getMapCopy方法
  119.                             Map map = (Map)obj;
  120.                             setmethod.invoke(newT, getMapCopy(map, layer));
  121.                         }else {// 属于其他类型
  122.                             setmethod.invoke(newT, getCopy(obj, layer));
  123.                         }
  124.                     }
  125.                 }
  126.                 return (T) newT;
  128.             } catch (Exception e) {
  129.                 logger.error(LogerHelper.getPrintStr(e));
  130.                 throw new RuntimeException(MESSAGE);
  131.             }
  133.         }else{
  134.             return t;
  135.         }
  136.         
  137.         
  138.     }
  139.     
  140.     
  142.     
  143.     
  144.     
  145.     /**
  146.      * @param layer
  147.      * @param T 为hibernate model
  148.      * @return
  149.      */
  150.     public static <T> Set<T> getSetCopy(Set<T> set, int...layers) {
  151.         if(set==null) return null;
  152.         int layer = LAYER;
  153.         if(layers!=null&&layers.length>0){
  154.             layer = layers[0];
  155.         }
  156. //        if (layer > 0) {
  157. //            layer--;
  158. //        } else {
  159. //            return null;
  160. //        }
  161.         Set<T> newSet = new HashSet<T>();
  162.         for (T obj : set) {
  163.             newSet.add(getCopy(obj,layer));
  164.         }
  165.         return newSet;
  166.     }
  167.   
  168.     
  169.     /**
  170.      * @param layer
  171.      * @param T 为hibernate model
  172.      */
  173.     public static <T> List<T> getListCopy(List<T> list, int...layers) {
  174.         if (list == null) return null;
  175.         int layer = LAYER;
  176.         if(layers!=null&&layers.length>0){
  177.             layer = layers[0];
  178.         }
  179.        /* if (layer > 0) {
  180.             layer--;
  181.         } else {
  182.             return null;
  183.         }*/
  184.         ArrayList<T> arrayList = new ArrayList<T>();
  185.         for (T obj : list) {
  186.             arrayList.add(getCopy(obj,layer));
  187.         }
  188.         return arrayList;
  189.     }
  190.     
  191.     /**
  192.      * @param layer
  193.      * @param T 为hibernate model
  194.      */
  195.     public static <K,V> Map<K,V> getMapCopy(Map<K,V> map, int...layers) {
  196.         if (map == null) return null;
  197.         int layer = LAYER;
  198.         if(layers!=null&&layers.length>0){
  199.             layer = layers[0];
  200.         }
  201.        /* if (layer > 0) {
  202.             layer--;
  203.         } else {
  204.             return null;
  205.         }*/
  206.         Map<K,V> rMap = new HashMap<K, V>();
  207.         for (K key : map.keySet()) {
  208.             rMap.put(key, getCopy(map.get(key),layer));
  209.         }
  210.         return rMap;
  211.     }
  212.     
  213. }

 

 

 

 

 

 

 

 

 

  1.  

版权声明：本文为hanjun0612原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/hanjun0612/p/9779781.html