JSON不对称反序列化映射方案
源码Git地址： https://github.com/git-simm/simm-framework.git (欢迎大家提交优化代码 ^_^)
一、业务场景
公司先有业务系统，后来觉得需要抽离公共的底层权限服务。再加上之前的业务对象命名不规范，这次想要一次搞定。面对这种场景，摆在我面前的有三套方案。
- 用底层权限服务提供的数据格式，把业务代码中不规范的引用都改一遍。影响面实在太广，放弃；
- 加一个数据适配层，从底层权限服务请求到json数据，定义一套匹配的pojo类型进行接收。之后再用适配方法，进行对象转换，得到适合系统使用的业务对象。这种搞法比较传统，代理层、适配器都需要自己人工处理。代码量还是较大，不够优雅；
- 利用反射+注解的方式，让程序自动去匹配不对等的属性，自行完成数据适配的过程。这种搞法就便捷多了，以后遇到名称不匹配的属性，我就直接添加个注解就行了。接下来就开撸吧。
二、实现目标
- 简单对象，属性都是简单类型，能够自动映射；
- 复杂的Class，要能递归进行自动映射；
- 复杂的List对象，要能递归进行自动映射；
三、实现方案
- 核心转换实现类 ：ProxyJsonUtil
- 映射关系解析实现类： ProxyResolveUtil
- 反射赋值工具类：ReflectUtil
- 权限平台请求代理：AuthorityUtil
1. 新建两个注解 ProxyEntity、ProxyProp
/**
* 代理实体(用于json序列化&反序列化)
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ProxyEntity {
//代理实体名
String value() default "";
} /**
* 代理属性(用于json序列化&反序列化)
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface ProxyProp {
//属性名
String value();
}
2、核心代码 反射+递归 进行字段映射
package simm.framework.jsonext; import org.springframework.data.util.Pair;
import simm.framework.jsonext.annotations.ProxyEntity;
import simm.framework.jsonext.annotations.ProxyProp;
import simm.framework.jsonext.entity.ProxyField;
import simm.framework.jsonext.entity.ProxyMsg; import java.lang.reflect.Field;
import java.util.*; /**
* 代理信息解析工具
*/
public class ProxyResolveUtil {
/**
* 同步锁
*/
private static Object _lock = new Object();
/**
* 代理类型缓存
*/
//对类型缓存做线程安全处理
private static Map<String,ProxyMsg> clazzCache = Collections.synchronizedMap(new HashMap<String,ProxyMsg>()); /**
* 获取代理信息
* @param clazz
* @return
*/
public static ProxyMsg getProxyMsg(Class clazz){
String key = clazz.getName();
if(clazzCache.containsKey(key)) return clazzCache.get(key);
synchronized (_lock){
//双重检查
if(clazzCache.containsKey(key)) return clazzCache.get(key);
//开始解析
clazzCache.put(key,getClazzProxyMsg(clazz));
}
return clazzCache.get(key);
} /**
* 获取类型代理信息
* @param clazz
* @return
*/
private static ProxyMsg getClazzProxyMsg(Class clazz){
ProxyEntity proxyEntity = (ProxyEntity) clazz.getAnnotation(ProxyEntity.class);
if(proxyEntity==null) return null;
ProxyMsg proxyMsg = new ProxyMsg();
proxyMsg.setClazz(clazz);
proxyMsg.setProxyName(proxyEntity.value());
//解析字段信息
List<ProxyField> propList = new ArrayList<>();
List<Pair<String, String>> listConfig= new ArrayList<>();
HashMap<String, String> mapConfig= new HashMap<>();
for (Field field: clazz.getDeclaredFields()){
ProxyProp proxyProp = field.getAnnotation(ProxyProp.class);
if(proxyProp == null){
mapConfig.put(field.getName(),field.getName());
continue;
}else{
ProxyField pField = new ProxyField();
pField.setField(field);
pField.setFieldName(field.getName());
pField.setProxyName(proxyProp.value());
propList.add(pField);
//beanutils 做属性拷贝时，使用该参数
listConfig.add(Pair.of(pField.getProxyName(),pField.getFieldName()));
mapConfig.put(pField.getProxyName(),pField.getFieldName());
}
}
proxyMsg.setFields(propList);
proxyMsg.setListConfig(listConfig);
proxyMsg.setMapConfig(mapConfig);
return proxyMsg;
}
}
package simm.framework.jsonext; import java.lang.reflect.*;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map; public class ReflectUtil {
/**
* 同步锁
*/
private static Object _lock = new Object();
/**
* 代理字段缓存
*/
//对类型缓存做线程安全处理
private static Map<String,Field> fieldCache = Collections.synchronizedMap(new HashMap<String,Field>()); /**
* 获取字段信息
* @param entity
* @param fieldName
* @param <E>
* @return
*/
public static <E> Field getField(E entity,String fieldName){
String key = entity.getClass().getName()+"@"+fieldName;
if(fieldCache.containsKey(key)) return fieldCache.get(key);
synchronized (_lock){
//双重检查
if(fieldCache.containsKey(key)) return fieldCache.get(key);
//开始解析
Field f = null;
try {
f = entity.getClass().getDeclaredField(fieldName);
f.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
fieldCache.put(key,f);
}
return fieldCache.get(key);
}
/**
* 获取list 属性的 泛型类型
* @param entity
* @param fieldName
* @return
*/
public static <E> Class<?> getActClazz(E entity, String fieldName){
Field f = getField(entity,fieldName);
if(f.getType() == java.util.List.class){
// 如果是List类型，得到其Generic的类型
Type genericType = f.getGenericType();
if(genericType == null) return null;
// 如果是泛型参数的类型
if(genericType instanceof ParameterizedType){
ParameterizedType pt = (ParameterizedType) genericType;
//得到泛型里的class类型对象
Class<?> genericClazz = (Class<?>)pt.getActualTypeArguments()[0];
return genericClazz;
}
}
return (Class<?>) f.getGenericType();
}
/**
* 获取字段值
* @param target
* @param fieldName
* @param <E>
* @return
* @throws Exception
*/
public static <E> Object getFieldVal(E target, String fieldName){
try {
return getField(target,fieldName).get(target);
} catch (IllegalAccessException e) {
e.printStackTrace();
return null;
}
} /**
* 设置字段值
* @param target
* @param fieldName
* @param <E>
* @return
*/
public static <E> void setFieldVal(E target, String fieldName,Object value) {
try {
getField(target,fieldName).set(target,value);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
package simm.framework.jsonext; import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.util.TypeUtils;
import org.springframework.data.util.Pair;
import simm.framework.jsonext.entity.ProxyMsg; import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Map; public class ProxyJsonUtil {
/**
* 批量拷贝
* @param source
* @param clazz
* @param <E>
* @param deepCopy 是否需要递归处理
* @return
*/
public static <E> List<E> cast(List<JSONObject> source, Class<E> clazz,boolean deepCopy) {
List<E> result = new ArrayList<>();
for (JSONObject t : source) {
E object = cast(t, clazz, deepCopy);
result.add(object);
}
return result;
} /**
* 单条拷贝
* @param source
* @param clazz
* @param <E>
* @return
*/
public static <E> E cast(JSONObject source, Class<E> clazz, boolean deepCopy) {
return copyProperties(source, clazz, deepCopy);
} /**
* 拷贝属性
* @param source
* @param clazz
* @param <E>
* @param deepCopy
* @return
*/
private static <E> E copyProperties(JSONObject source, Class<E> clazz, boolean deepCopy) {
try {
E object = TypeUtils.castToJavaBean(source, clazz, ParserConfig.getGlobalInstance());
copyProperties(source, object, deepCopy);
return object;
} catch (Exception e) {
e.printStackTrace();
return null;
}
} /**
* JsonObject属性值拷贝
* @param source
* @param target
* @param <E>
* @param deepCopy
*/
private static <E> void copyProperties(JSONObject source,E target, boolean deepCopy) throws Exception {
if(deepCopy){
//深层递归，处理子对象赋值
proxyEntityCast(source, target, deepCopy);
}
//代理字段赋值
proxyFieldCast(source, target);
} /**
* 深层递归，处理子对象赋值
* @param source
* @param target
* @param deepCopy
* @param <E>
* @throws Exception
*/
private static <E> void proxyEntityCast(JSONObject source, E target, boolean deepCopy) throws Exception {
ProxyMsg msg = ProxyResolveUtil.getProxyMsg(target.getClass());
Map<String,String> map = msg.getMapConfig();
for (Map.Entry<String, Object> entry : source.entrySet()){
//映射实体不包含该属性，则退出代理赋值
if(!map.containsKey(entry.getKey()))continue;
//获取映射实体的字段名
String fieldName = map.get(entry.getKey());
Object value = entry.getValue();
if(value instanceof JSONArray){
jsonArrayCast(target, deepCopy, fieldName, (JSONArray) value);
}else if(value instanceof JSONObject){
jsonObjectCast(target, deepCopy, fieldName, (JSONObject) value);
}
}
} /**
* JSONObject转换处理
* @param target
* @param deepCopy
* @param fieldName
* @param value
* @param <E>
* @throws Exception
*/
private static <E> void jsonObjectCast(E target, boolean deepCopy, String fieldName, JSONObject value) throws Exception {
//属性是一个JSONObject 对象
Object fieldTarget = ReflectUtil.getFieldVal(target, fieldName);
if(fieldTarget == null){
Type fieldType = ReflectUtil.getField(target, fieldName).getGenericType();
ReflectUtil.setFieldVal(target, fieldName,copyProperties(value,(Class)fieldType,deepCopy));
}else{
//递归为JsonObject属性赋值
copyProperties(value,fieldTarget,deepCopy);
}
} /**
* JSONArray 字段处理
* @param target
* @param deepCopy
* @param fieldName
* @param value
* @param <E>
* @throws Exception
*/
private static <E> void jsonArrayCast(E target, boolean deepCopy, String fieldName, JSONArray value) throws Exception {
//属性是一个 JSONArray 的列表对象
//获取需要被赋值的目标对象
Object fieldTarget = ReflectUtil.getFieldVal(target, fieldName);
//目标对象为空，退出运行
Class<?> fieldGenericClazz = ReflectUtil.getActClazz(target,fieldName);
if(fieldTarget == null){
fieldTarget = new ArrayList();
ReflectUtil.setFieldVal(target, fieldName,fieldTarget);
}
JSONArray tempList = value;
if(fieldTarget instanceof List){
// 如果是List类型，得到其Generic的类型
List<Object> temps = (List<Object>)fieldTarget;
for(int i=0;i<tempList.size();i++){
//递归为JsonObject属性赋值
if(temps.size()<=i){
//自动创建新对象
temps.add(copyProperties((JSONObject)tempList.get(i),fieldGenericClazz,deepCopy));
}else{
copyProperties((JSONObject)tempList.get(i),temps.get(i),deepCopy);
}
}
}
}
/**
* 代理字段赋值
* @param source
* @param target
* @param <E>
*/
private static <E> void proxyFieldCast(JSONObject source, E target) {
//代理字段赋值
ProxyMsg msg = ProxyResolveUtil.getProxyMsg(target.getClass());
for (Pair<String, String> pair : msg.getListConfig()) {
String key = pair.getFirst();
if(!source.containsKey(key)) continue;
Object value = source.get(key);
if(value instanceof JSONArray || value instanceof JSONObject) continue;
ReflectUtil.setFieldVal(target, pair.getSecond(),value);
}
}
}
JSON不对称反序列化映射方案的更多相关文章
- C# JSON 序列化和反序列化——JavaScriptSerializer实现
一. JavaScriptSerializer 类由异步通信层内部使用,用于序列化和反序列化在浏览器和 Web 服务器之间传递的数据.您无法访问序列化程序的此实例.但是,此类公开了公共 API.因此, ...
- 序列化对象C++对象的JSON序列化与反序列化探索
新手发帖,很多方面都是刚入门,有错误的地方请大家见谅,欢迎批评指正 一:背景 作为一名C++开发人员,我始终很期待能够像C#与JAVA那样,可以省力的进行对象的序列化与反序列化,但到现在为止,还没有找 ...
- C++对象的JSON序列化与反序列化探索
一:背景 作为一名C++开发人员,我一直很期待能够像C#与JAVA那样,可以轻松的进行对象的序列化与反序列化,但到目前为止,尚未找到相对完美的解决方案. 本文旨在抛砖引玉,期待有更好的解决方案:同时向 ...
- Net中JSON序列化和反序列化处理（日期时间特殊处理）
0 缘由 笔者最近在web api端使用Json.Net进行序列化处理,而在调用端使用DataContractSerializer进行反序列化,遇到日期时间处理反序列化不成功[备注:笔者使用Net ...
- C++对象的JSON序列化与反序列化探索完结-列表的序列化与反序列化
在前两篇文章中,我们已经完成对普通对象以及复杂对象嵌套的序列化与反序列化,见如下地址: C++对象的JSON序列化与反序列化探索 C++对象的JSON序列化与反序列化探索续-复杂对象的序列化与反序列化 ...
- C++对象的JSON序列化与反序列化探索续-复杂对象的序列化与反序列化
本文是基本上一篇博文进行改进而成,上一篇请见: C++对象的JSON序列化与反序列化探索 此处就不多说了,直接上代码. 1. 序列化基类 #pragma once #include <strin ...
- 迄今为止 .Net 平台功能最强大，性能最佳的 JSON 序列化和反序列化库。
Swifter.Json 这是迄今为止 .Net 平台功能最强大,性能最佳的 JSON 序列化和反序列化库. Github : https://github.com/Dogwei/Swifter.Js ...
- Newtonsoft.Json C# Json序列化和反序列化工具的使用、类型方法大全 C# 算法题系列(二) 各位相加、整数反转、回文数、罗马数字转整数 C# 算法题系列(一) 两数之和、无重复字符的最长子串 DateTime Tips c#发送邮件，可发送多个附件 MVC图片上传详解
Newtonsoft.Json C# Json序列化和反序列化工具的使用.类型方法大全 Newtonsoft.Json Newtonsoft.Json 是.Net平台操作Json的工具,他的介绍就 ...
- DotNet的JSON序列化与反序列化
JSON(JavaScript Object Notation)JavaScript对象表示法,它是一种基于文本,独立于语言的轻量级数据交换格式.在现在的通信中,较多的采用JSON数据格式,JSON有 ...
随机推荐
- vue router 传参 获取不到query,params
千万要注意,获取query/params 是this.$route.query 不是this.$router.query!!!
- 如何禁用 FastAdmin 双击编辑功能？
如何禁用 FastAdmin 双击编辑功能? 新版 (1.0.0.20180513_beta)增加一个新功能,可以禁止双击编辑. 很多人还是喜欢双击选中复制,默认的双击编辑还是不怎么习惯. 可以以下文 ...
- jmeter --- 测试计划里的元件
1.线程组 线程组元件是任何一个测试计划的开始点.在一个测试计划中的所有元件都必须在某个线程组下.顾名思义,线程组元件控制JMeter执行你的测试计划时候使用的线程数量.对线程组的控制允许你: 设置线 ...
- 关于Android Studio上得处女座福音功能——reformat code
在mac上,选中需要的代码,然后 Option+(shift) + Command + L 全部重新排列!!爽飞!
- 几种经典的hash算法
计算理论中,没有Hash函数的说法,只有单向函数的说法.所谓的单向函数,是一个复杂的定义,大家可以去看计算理论或者密码学方面的数据.用“人 类”的语言描述单向函数就是:如果某个函数在给定输入的时候,很 ...
- logging模块讲解
logging模块 很多程序都有记录日志的需求,并且日志中包含的信息即有正常的程序访问日志,还可能有错误.警告等信息输出,python的logging模块提供了标准的日志接口,你可以通过它存储各种格式 ...
- Resize事件和SizeChanged事件
窗体加载的时候, 就会触发Form_ResizeBeginForm_ResizeEnd 窗体的拖动会触发:Form_ResizeBeginForm_ResizeEnd 窗体的最小化按钮会触发:Form ...
- linux平台总线驱动设备模型之点亮LED
这一节里,我们来使用平台驱动设备这一套架构来实现我们之前使用简单的字符设备驱动点亮LED,这里并无实际意义,只是告诉大家如果编写平台总线驱动设备. 问:如何编写平台总线驱动设备这一套架构的设备驱动? ...
- SSH开发中的注解使用
在SSH中使用注解可以减少配置XML文件,毕竟随着项目规模的扩大,配置bean将把Spring的配置文件(applicationContext.xml)变得很混乱 在Spring的配置文件中开启注解扫 ...
- linux中内存使用,swap,cache,buffer的含义总结
首先介绍一下linux中内存是如何使用的.当有应用需要读写磁盘数据时,由系统把相关数据从磁盘读取到内存,如果物理内存不够,则把内存中的部分数据导入到磁盘,从而把磁盘的部分空间当作虚拟内存来使用,也称为 ...