主要使用了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;
} }
												

java json转换(一)的更多相关文章

  1. java json转换工具类

    在java项目中,通常会用到json类型的转换,常常需要对 json字符串和对象进行相互转换. 在制作自定义的json转换类之前,先引入以下依赖 <!--json相关工具--><de ...

  2. java json转换

    https://blog.csdn.net/WillJGL/article/details/77866224 SpringBoot中如果需要实现json的序列化和反序列化,我们会使用json解析工具. ...

  3. java json转换(二)

    package com.kps.common.utils; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArra ...

  4. java json 转换

    1.直接输出: 2.字符串 通过eval转换输出,里面涉及到一个转义问题,还要注意eval的用法里面需要加"("+ + ")" 3.

  5. Java对象转换成xml对象和Java对象转换成JSON对象

    1.把Java对象转换成JSON对象 apache提供的json-lib小工具,它可以方便的使用Java语言来创建JSON字符串.也可以把JavaBean转换成JSON字符串. json-lib的核心 ...

  6. FastJson、Jackson、Gson进行Java对象转换Json细节处理

    前言 Java对象在转json的时候,如果对象里面有属性值为null的话,那么在json序列化的时候要不要序列出来呢?对比以下json转换方式 一.fastJson 1.fastJson在转换java ...

  7. FastJson、Jackson、Gson进行Java对象转换Json的细节处理

    前言 Java对象在转json的时候,如果对象里面有属性值为null的话,那么在json序列化的时候要不要序列出来呢?对比以下json转换方式 一.fastJson 1.fastJson在转换java ...

  8. java json与map互相转换(二)

      java json与map互相转换(二) CreationTime--2018年7月16日15点09分 Author:Marydon 1.准备工作 所需jar包: commons-beanutil ...

  9. java json与map互相转换(一)

      java json与map互相转换(一) CreationTime--2018年7月16日 Author:Marydon 1.准备工作 所需jar包:json-20180130.jar impor ...

随机推荐

  1. Jmeter(三十五)_分布式

    jmeter分布式简单步骤说明: 1:添加远程服务器IP到配置文件 在JMETER_HOME / bin / jmeter.properties中,找到名为“ remote_hosts ” 的属性,并 ...

  2. 十四、怎么获取data-id中的值

    <!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8&quo ...

  3. H5 13-子元素选择器

    13-子元素选择器 p{ color: red; } */ /* #identity>p{ color: blue; } */ div>ul>li>p{ color: purp ...

  4. Bad Hair Day POJ - 3250 (单调栈入门题)

    Some of Farmer John's N cows (1 ≤ N ≤ 80,000) are having a bad hair day! Since each cow is self-cons ...

  5. anaconda 出现add 。。。进不去

    找到.condarc 文件  C:\Users\leiyi内 把里面内容替换为 channels: - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pk ...

  6. 单列模式,装饰器、new方法、类/静态方法实现单列模式

    一.单列模式 单例模式(Singleton Pattern)是一种常用的软件设计模式,该模式的主要目的是确保某一个类只有一个实例存在. 如,某个服务器程序的配置信息存放在一个文件中,客户端通过一个 C ...

  7. nginx学习笔记二

    一,nginx架构在Linux系统中以daemon(守护进程)的方式在后台运行,后台进程包含一个master进程和多个worker进程(多进程的工作方式) master进程 | 信号 | | ---- ...

  8. Java Core - 序列化和反序列化

    把对象转换为字节序列的过程称为对象的序列化 把字节序列恢复成对象的过程称为对象的反序列化 一.对象的序列化的应用: 1.把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中. 2.在网络上传送对象 ...

  9. Linux查看硬件等基本参数

    http://www.cnblogs.com/xd502djj/archive/2011/02/28/1967350.html

  10. node-cookie-parserDemo

    let express = require('express'); let app = new express(); let cookieParser = require('cookie-parser ...