一. 介绍
第一节简单介绍怎么使用数据对象转换：一种高效的数据对象转换方式(1)
https://blog.csdn.net/ssyujay/article/details/81638984
第二节详细介绍怎么使用数据对象转换：一种高效的数据对象转换方式(2)
https://blog.csdn.net/ssyujay/article/details/81813394
第三节主要是介绍具体实现方式，hub就是数据对象转换，hub就是数据枢纽。
二. 代码实现详解
1. xml解析类，HubXmlParser.java
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import yui.comn.hub.model.HubXmlColumn;
import yui.comn.hub.model.HubXmlColumnAttr;
import yui.comn.hub.model.HubXmlElement;
import yui.comn.hub.model.HubXmlHandlerConfig;
import yui.comn.hub.utils.HubStringUtils;
import yui.comn.utils.StrUtils;
import yui.comn.utils.Symbol;
import yui.comn.utils.annotation.Note;
import yui.comn.utils.annotation.TableNote;
/**
* 数据装换中转站-xml解析
* @author yuyi
*/
@SuppressWarnings("unchecked")
public class HubXmlParser {
private Logger logger = LoggerFactory.getLogger(HubXmlParser.class);
/**
* 解析xml,获取grid类型list
*/
public List<HubXmlColumn> parseXmlGridColToList(Class<?> clazz, String name) {
return parseXmlColToList(clazz, HubXmlElement.grid.name(), name);
}
/**
* 解析xml,获取grid类型map
*/
public Map<String, HubXmlColumn> parseXmlGridColToMap(Class<?> clazz, String name) {
return parseXmlColToMap(clazz, HubXmlElement.grid.name(), name);
}
/**
* 解析xml,获取search类型map
*/
public Map<String, String> parseXmlSearchColToMap(Class<?> clazz, String name) {
List<HubXmlColumn> columns = parseXmlColToList(clazz, HubXmlElement.search.name(), name);
Map<String, String> map = new HashMap<String, String>();
for (HubXmlColumn column : columns) {
map.put(column.getName(), column.getMapper());
}
return map;
}
/**
* 解析xml,获取对应的type类型的元素Map
*/
public Map<String, HubXmlColumn> parseXmlColToMap(Class<?> clazz, String type, String name) {
List<HubXmlColumn> columns = parseXmlColToList(clazz, type, name);
Map<String, HubXmlColumn> map = new LinkedHashMap<String, HubXmlColumn>();
for (HubXmlColumn column : columns) {
map.put(column.getName(), column);
}
return map;
}
/**
* 解析xml,获取对应的type类型的元素列表
*/
public List<HubXmlColumn> parseXmlColToList(Class<?> clazz, String type, String name) {
List<HubXmlColumn> columns = new ArrayList<>();
Element pel = parseXmlToElement(clazz, type, name);
List<Element> elements = pel.elements();
for (Element el : elements) {
String prefix = el.attributeValue(HubXmlColumnAttr.prefix.name());
String className = el.attributeValue(HubXmlColumnAttr.type.name());
if (StringUtils.isBlank(className)) {
HubXmlColumn col = new HubXmlColumn();
String colName = el.attributeValue(HubXmlColumnAttr.name.name());
String colToName = el.attributeValue(HubXmlColumnAttr.toName.name());
//如果前缀不为空
if (StringUtils.isNotBlank(prefix)) {
colName = StrUtils.upperCaseFirstCharAndAddPrefix(colName, prefix);
if (StringUtils.isNotBlank(colToName)) {
colToName = StrUtils.upperCaseFirstCharAndAddPrefix(colToName, prefix);
}
}
col.setName(colName);
col.setMapper(el.attributeValue(HubXmlColumnAttr.mapper.name()));
col.setDescr(el.attributeValue(HubXmlColumnAttr.descr.name()));
String viewOrder = el.attributeValue(HubXmlColumnAttr.viewOrder.name());
if (StringUtils.isNotBlank(viewOrder)) {
col.setViewOrder(Integer.valueOf(viewOrder));
}
col.setHandler(el.attributeValue(HubXmlColumnAttr.handler.name()));
col.setToName(colToName);
col.setToDescr(el.attributeValue(HubXmlColumnAttr.toDescr.name()));
col.setHandlerConfigs(getConfigs(col.getHandler(), colName));
columns.add(col);
} else {
//通过对象类有Note属性的字段，解析成List<HubColumn>
if (StringUtils.equals(HubXmlElement.grid.name(), type)){
addGridColumnByType(columns, prefix, className);
} else {
addSearchColumnByType(columns, prefix, className);
}
}
}
//排序
Collections.sort(columns);
return columns;
}
/**
* 把class中属性的值，加入search列表中
*/
private void addSearchColumnByType(List<HubXmlColumn> columns, String prefix, String className) {
try {
Class<?> clazz = Class.forName(className);
String tableName = null;
//先通过对象类TableNote注释获取表名，如果没有该属性，通过解析对象类名获取表名，比如SysUserVo,得到T_SYS_USER
TableNote tableNote = clazz.getAnnotation(TableNote.class);
if (null != tableNote) {
//通过注解取表名
tableName = tableNote.value();
if (StringUtils.isBlank(tableName)) {
tableName = tableNote.tableName();
}
} else {
//通过解析对象类名获取表名
tableName = HubStringUtils.getTableNameByVoName(clazz.getSimpleName());
}
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Note note = field.getAnnotation(Note.class);
if (null != note) {
HubXmlColumn col = new HubXmlColumn();
String name = field.getName();
//如果前缀不为空
if (StringUtils.isNotBlank(prefix)) {
name = StrUtils.upperCaseFirstCharAndAddPrefix(name, prefix);
}
col.setName(name);
String attrName = StrUtils.toUnderlineAndUpperCaseByHump(field.getName());
col.setMapper(tableName + Symbol.DOT + attrName);
col.setDescr(note.value());
columns.add(col);
}
}
} catch (Exception e) {
String errMsg = "通过className解析Column失败， className:" + className;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
/**
* 把class中有Note属性的字段，加入Grid列表中
*/
private void addGridColumnByType(List<HubXmlColumn> columns, String prefix, String className) {
try {
Class<?> clazz = Class.forName(className);
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Note note = field.getAnnotation(Note.class);
if (null != note) {
HubXmlColumn col = new HubXmlColumn();
String name = field.getName();
String toName = note.toName();
//如果前缀不为空
if (StringUtils.isNotBlank(prefix)) {
name = StrUtils.upperCaseFirstCharAndAddPrefix(name, prefix);
if (StringUtils.isNotBlank(toName)) {
toName = StrUtils.upperCaseFirstCharAndAddPrefix(toName, prefix);
}
}
//获取字段描述
String descr = note.value();
if (StringUtils.isBlank(descr)) {
descr = note.descr();
}
col.setName(name);
//比如sysUserVo.usNm
col.setMapper(StrUtils.lowerCaseFirstChar(clazz.getSimpleName()) + Symbol.DOT + field.getName());
col.setDescr(descr);
col.setViewOrder(note.viewOrder());
col.setHandler(note.handler());
col.setToName(toName);
col.setToDescr(note.toDescr());
col.setHandlerConfigs(getConfigs(note.handler(), name));
columns.add(col);
}
}
} catch (Exception e) {
String errMsg = "通过className解析Column失败， className:" + className;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
/**
* 解析column中的handler属性成为List<HubXmlHandlerConfig>
*/
private List<HubXmlHandlerConfig> getConfigs(String handler, String selfParam) {
if (StringUtils.isBlank(handler)) {
return null;
}
List<HubXmlHandlerConfig> handlerConfigs = new ArrayList<>();
String[] configs = StringUtils.split(handler, Symbol.SEMICOLON);
for (String config : configs) {
handlerConfigs.add(getConfig(config, selfParam));
}
return handlerConfigs;
}
/**
* 解析column中的handler属性成为HubXmlHandlerConfig
*/
private HubXmlHandlerConfig getConfig(String config, String selfParam) {
List<String> params = new ArrayList<>();
params.add(selfParam);
//如果没有括号
int openParenIndex = StringUtils.indexOf(config, Symbol.OPNE_PAREN);
int closeParenIndex = StringUtils.indexOf(config, Symbol.CLOSE_PAREN);
if (openParenIndex == -1 || closeParenIndex == -1) {
return new HubXmlHandlerConfig(config, params);
}
String handler = StringUtils.substringBefore(config, Symbol.OPNE_PAREN);
//空括号
if (closeParenIndex - openParenIndex == -1) {
return new HubXmlHandlerConfig(handler, params);
}
String paramStr = StringUtils.substringBetween(config, Symbol.OPNE_PAREN, Symbol.CLOSE_PAREN);
String[] tempParams = StringUtils.split(paramStr, Symbol.COMMA);
for (String tempParam : tempParams) {
params.add(tempParam);
}
return new HubXmlHandlerConfig(handler, params);
}
/**
* 解析xml,获取对应的type类型元素
*/
private Element parseXmlToElement(Class<?> clazz, String type, String name) {
Document document = this.parseXmlToDoc(clazz, type, name);
Element rootEl = document.getRootElement();
List<Element> elements = rootEl.elements(type);
for (Element el : elements) {
if (StringUtils.equals(name, el.attributeValue(HubXmlColumnAttr.name.name()))) {
return el;
}
}
String errMsg = "class:" + clazz.getSimpleName() + "; type:" + type + "; name:" + name + ", 找不到对应的元素";
logger.error(errMsg);
throw new RuntimeException(errMsg);
}
/**
* 把xml文件解析成 Document类对象
*/
private Document parseXmlToDoc (Class<?> clazz, String type, String name) {
InputStream ins = clazz.getResourceAsStream(getXmlName(clazz));
try {
return new SAXReader().read(ins);
} catch (DocumentException e) {
String errMsg = "class:" + clazz.getSimpleName() + "; type:" + type + "; name:" + name;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
} finally {
IOUtils.closeQuietly(ins);
}
}
/**
* 通过class获取对应的xml名称, 比如sysUserController.class类获取sysUserController.xml文件名
*/
private String getXmlName(Class<?> clazz) {
return new StringBuffer().append(clazz.getSimpleName()).append(".xml").toString();
}
}
2. xml解析缓存，HubXmlCache.java
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.lang3.StringUtils;
import yui.comn.hub.model.HubXmlColumn;
import yui.comn.utils.Symbol;
/**
* xml 配置文件解析后缓存
* @author yuyi
*/
public class HubXmlCache {
// grid map缓存
private Map<String, Map<String, HubXmlColumn>> gridMapCache = new HashMap<>();
// grid list缓存
private Map<String, List<HubXmlColumn>> gridListCache = new HashMap<>();
// search map缓存
private Map<String, Map<String, String>> searchCache = new HashMap<>();
//xml解析器
private HubXmlParser hubXmlParser = new HubXmlParser();
/** 是否开启缓存 */
public boolean cache = true;
private static HubXmlCache hubXmlCache = new HubXmlCache();
public static HubXmlCache getInstance() {
return hubXmlCache;
}
/**
* 缓存Map中的key是由Controller类名加上name
*/
private String spliceKey(Class<?> clazz, String name) {
return new StringBuffer().append(clazz.getSimpleName()).append(Symbol.DOT).append(name).toString();
}
public Map<String, String> toSearch(Class<?> clazz, String name) {
String searchKey = spliceKey(clazz, name);
Map<String, String> searchMap = searchCache.get(searchKey);
if (null == searchMap) {
searchMap = hubXmlParser.parseXmlSearchColToMap(clazz, name);
if (isCache()) {
searchCache.put(searchKey, searchMap);
}
}
return searchMap;
}
public Map<String, String> toGridKvMap(Class<?> clazz, String name) {
Map<String, HubXmlColumn> gridMap = toGridMap(clazz, name);
Map<String, String> resultMap = new LinkedHashMap<>();
for (Entry<String, HubXmlColumn> entry : gridMap.entrySet()) {
HubXmlColumn col = entry.getValue();
resultMap.put(entry.getKey(), col.getDescr());
if (StringUtils.isNotBlank(col.getHandler()) && StringUtils.isNotBlank(col.getToName())) {
resultMap.put(col.getToName(), col.getToDescr());
}
}
return resultMap;
}
public Map<String, HubXmlColumn> toGridMap(Class<?> clazz, String name) {
String gridKey = spliceKey(clazz, name);
Map<String, HubXmlColumn> gridMap = gridMapCache.get(gridKey);
if (null == gridMap) {
gridMap = hubXmlParser.parseXmlGridColToMap(clazz, name);
if (isCache()) {
gridMapCache.put(gridKey, gridMap);
}
}
return gridMap;
}
public List<HubXmlColumn> toGridList(Class<?> clazz, String name) {
String gridKey = spliceKey(clazz, name);
List<HubXmlColumn> gridList = gridListCache.get(gridKey);
if (null == gridList) {
gridList = hubXmlParser.parseXmlGridColToList(clazz, name);
Collections.sort(gridList);
if (isCache()) {
gridListCache.put(gridKey, gridList);
}
}
return gridList;
}
public boolean isCache() {
return cache;
}
public void setCache(boolean cache) {
this.cache = cache;
}
}3. 将数据对象转化为map对象，HubDataToMapParser.java
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import yui.comn.hub.data.handler.HubDataHandlerProcess;
import yui.comn.hub.model.HubJavaType;
import yui.comn.hub.model.HubXmlColumn;
import yui.comn.hub.utils.HubStringUtils;
import yui.comn.hub.xml.parser.HubXmlCache;
import yui.comn.utils.Symbol;
/**
* 把Dto对象解析成map对象
* @author yuyi
*/
public class HubDataToMapParser {
private Logger logger = LoggerFactory.getLogger(HubDataToMapParser.class);
private static HubDataToMapParser parser = new HubDataToMapParser();
public static HubDataToMapParser getInstance() {
return parser;
}
/**
* 列表转Map列表
*/
public List<Map<String, Object>> toMapListByObjList(Class<?> clazz, String name, Collection<?> list) {
Map<String, HubXmlColumn> colMap = HubXmlCache.getInstance().toGridMap(clazz, name);
return toMapListByObjList(colMap, list);
}
/**
* 对象转Map
*/
public Map<String, Object> toMapByObj(Class<?> clazz, String name, Object obj) {
Map<String, HubXmlColumn> colMap = HubXmlCache.getInstance().toGridMap(clazz, name);
return toMapByObj(colMap, obj);
}
/**
* 列表转Map列表
*/
private List<Map<String, Object>> toMapListByObjList(Map<String, HubXmlColumn> colMap, Collection<?> list) {
List<Map<String, Object>> resultList = new ArrayList<>();
if (CollectionUtils.isNotEmpty(list)) {
for (Object obj : list) {
resultList.add(toMapByObj(colMap, obj));
}
}
return resultList;
}
/**
* 对象转Map
*/
private Map<String, Object> toMapByObj(Map<String, HubXmlColumn> colMap, Object obj) {
Map<String, Object> resultMap = new LinkedHashMap<>();
List<HubXmlColumn> columnHandlers = new ArrayList<>();
for (Entry<String, HubXmlColumn> entry : colMap.entrySet()) {
resultMap.put(entry.getKey(), getAttrValue(obj, entry.getValue().getMapper()));
if (StringUtils.isNotBlank(entry.getValue().getHandler())) {
columnHandlers.add(entry.getValue());
}
}
//数据处理器
for (HubXmlColumn hubXmlColumn : columnHandlers) {
HubDataHandlerProcess.getInstance().handle(hubXmlColumn, resultMap);
}
return resultMap;
}
/***************************************************dto 转 xml***************************************************/
/**
* 例如：sysUserDtox.sysUserVo.sysUserPk
*/
private Object getAttrValue(Object obj, String mapper) {
if (StringUtils.isBlank(mapper)) {
return null;
}
String[] attrs = StringUtils.split(mapper, Symbol.DOT);
//先获取属性之前的对象值，比如 sysUserVo.usNm， 就是先获取sysUserVo对象
for (int i = 0; i < attrs.length - 1; i++) {
obj = getObjByAttr(obj, attrs[i]);
}
String attrName = attrs[attrs.length - 1];
String methodName = null;
try {
Class<?> clazz = obj.getClass();
Field field = clazz.getDeclaredField(attrName);
//如果是boolean类型, method名称前缀是is, 比如child, 该类型是boolean, 那么获取该属性值的方法是 isChild
if (StringUtils.equals(field.getType().getName(), HubJavaType.TYPE_BASE_BOOLEAN.getName())) {
methodName = HubStringUtils.getIsMethodName(attrName);
} else {
methodName = HubStringUtils.getGetMethodName(attrName);
}
Method method = clazz.getMethod(methodName);
return method.invoke(obj);
} catch (Exception e) {
String errMsg = "获取方法值失败, attrName=" + attrName + ", methodName=" + methodName;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
/**
* 通过反射执行得到对象
*/
private Object getObjByAttr(Object obj, String attrName) {
try {
Class<?> clazz = obj.getClass();
Method method = clazz.getMethod(HubStringUtils.getGetMethodName(attrName));
return method.invoke(obj);
} catch (Exception e) {
String errMsg = "获取方法值失败, methodName=" + HubStringUtils.getGetMethodName(attrName);
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
}
4. excel上传对象转化为对象列表，HubDataToDtoParser.java, 该对象工具类HubDataToDtoUtils.java
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import yui.comn.hub.utils.HubDataToDtoUtils;
import yui.comn.hub.utils.HubStringUtils;
import yui.comn.utils.Symbol;
/**
* 把map对象解析成dto对象
* @author yuyi
*/
public class HubDataToDtoParser {
private Logger logger = LoggerFactory.getLogger(HubDataToDtoParser.class);
private static HubDataToDtoParser parser = new HubDataToDtoParser();
public static HubDataToDtoParser getInstance() {
return parser;
}
/**
* 通过反射机制，实例化对象，并且给对象属性赋值
*/
public void toObjSetVal(Object obj, String mapper, Object val) {
String[] attrs = StringUtils.split(mapper, Symbol.DOT);
try {
//实例化对象中的对象
Object defObj = obj;
for (int i = 0; i < attrs.length - 1; i++) {
defObj = toDefObjByAttr(defObj, attrs[i]);
}
//给对象属性赋值
Field field = defObj.getClass().getDeclaredField(attrs[attrs.length - 1]);
String methodName = HubStringUtils.getSetMethodName(field.getName());
Method method = defObj.getClass().getMethod(methodName, field.getType());
method.invoke(defObj, HubDataToDtoUtils.toDistTypeVal(field.getType(), val));
} catch (Exception e) {
String errMsg = "实例化对象，并且给对象属性赋值, mapper=" + mapper;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
/**
* 通过反射机制，通过属性名称，实例化对象中的对象(该对象不是基本类型，一般是自定义对象)
*/
public Object toDefObjByAttr(Object pObj, String attrName) {
try {
Class<?> clazz = pObj.getClass();
Method getMethod = clazz.getMethod(HubStringUtils.getGetMethodName(attrName));
Object obj = getMethod.invoke(pObj);
//对象中的对象，通过反射机制获取对象，如果该对象是null，实例化属性对象
if (null == obj) {
obj = getMethod.getReturnType().newInstance();
Method setMethod = clazz.getMethod(HubStringUtils.getSetMethodName(attrName), getMethod.getReturnType());
setMethod.invoke(pObj, obj);
}
return obj;
} catch (Exception e) {
String errMsg = "获取方法值失败, attrName=" + attrName;
logger.error(errMsg, e);
throw new RuntimeException(errMsg, e);
}
}
/**
* 通过类反射，实例化对象
*/
public Object toObjByClass(Class<?> clazz) {
try {
return clazz.newInstance();
} catch (Exception e) {
return null;
}
}
}
import java.math.BigDecimal;
import java.sql.Date;
import java.sql.Timestamp;
import org.apache.commons.lang3.StringUtils;
import yui.comn.hub.model.HubJavaType;
import yui.comn.utils.DateUtils;
/**
* 把map对象解析成dto对象工具类
* @author yuyi
*/
public class HubDataToDtoUtils {
public static Object toDistTypeVal(Class<?> type, Object val) {
String clazzTypeName = type.getName();
String valTypeName = val.getClass().getTypeName();
if (StringUtils.equals(clazzTypeName, valTypeName)) {
return val;
}
switch (HubJavaType.getJavaTypeByName(clazzTypeName)) {
case TYPE_TIMESTAMP:
return toTimestampByString(val.toString());
case TYPE_DATE:
return toSqlDateByString(val.toString());
case TYPE_LONG:
case TYPE_BASE_LONG:
return Long.valueOf(val.toString());
case TYPE_INT:
case TYPE_BASE_INT:
return Integer.valueOf(val.toString());
case TYPE_DOUBLE:
case TYPE_BASE_DOUBLE:
return Double.valueOf(val.toString());
case TYPE_FLOAT:
case TYPE_BASE_FLOAT:
return Float.valueOf(val.toString());
case TYPE_BIGDECIMAL:
return new BigDecimal(val.toString());
default:
return val;
}
}
//转化为timestamp
public static Object toTimestampByString(String dateStr) {
Timestamp result = DateUtils.formatTimestamp(dateStr, DateUtils.FULL_ST_FORMAT);
if (null == result) {
result = DateUtils.formatTimestamp(dateStr, DateUtils.ST_FORMAT);
}
if (null == result) {
result = DateUtils.formatTimestamp(dateStr, DateUtils.CURRENCY_J_FORMAT);
}
return result;
}
//转化为sqlDate
public static Object toSqlDateByString(String dateStr) {
Date result = DateUtils.formatSqlDate(dateStr, DateUtils.DAY_FORMAT);
if (null == result) {
result = DateUtils.formatSqlDate(dateStr, DateUtils.SHORT_DATE_FORMAT);
}
return result;
}
}
5. xml中col元素属性对象类，HubXmlColumn.java，HubXmlHandlerConfig
import java.util.List;
import lombok.Data;
/**
* @author yuyi
*/
@Data
public class HubXmlColumn implements Comparable <HubXmlColumn> {
private String prefix; //name的前缀, 比如prefix=sysUser, name=nm, 输出就是 sysUserNm
private String name; //grid: map中的key; search: 查询的key
private String mapper; //grid: 对象.属性; search: 表名+字段
private String type; //通过解析对象属性，反射生成列
private String descr; //列描述
private Integer viewOrder; //列排序，如果写，默认按顺序排序，如果解析类对象，按照英文首字母排序
private String handler; //处理器，多个处理器用分号(";")隔开
private String toName; //如果通过处理器想生成另一个map属性
private String toDescr; //是新属性列排序描述
private List<HubXmlHandlerConfig> handlerConfigs;
public HubXmlColumn() {}
public HubXmlColumn(String name, String mapper) {
this.name = name;
this.mapper = mapper;
}
@Override
public int compareTo(HubXmlColumn obj) {
if (obj.getViewOrder() == null) {
return 1;
}
if (this.getViewOrder() == null) {
return -1;
}
return this.getViewOrder().compareTo(((HubXmlColumn) obj).getViewOrder());
}
}
import java.util.List;
import lombok.Data;
/**
* 处理定义类
* @author yuyi
*/
@Data
public class HubXmlHandlerConfig {
private String handler;
private List<String> params;
public HubXmlHandlerConfig() {
}
public HubXmlHandlerConfig(String handler) {
this.handler = handler;
}
public HubXmlHandlerConfig(String handler, List<String> params) {
this.handler = handler;
this.params = params;
}
}
6. hub数据处理类相关代码，AbstractHubDataHandler.java, HubDataHandlerRegister.java HubDataHandlerProcess.java
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import org.apache.commons.lang3.StringUtils;
/**
* 抽象数据中转处理
* @author yuyi
*/
public abstract class AbstractHubDataHandler implements IHubDataHandler{
protected abstract Object doHandle(List<String> params, Map<String, Object> dataMap);
@PostConstruct
public void init() {
if (StringUtils.isNotBlank(getRegisterName())) {
HubDataHandlerRegister.getInstance().registerHandler(getRegisterName(), this);
}
}
@Override
public Object handle(List<String> params, Map<String, Object> dataMap) {
if (null == params) {
return null;
}
return doHandle(params, dataMap);
}
//也可以在类中直接注册
protected String getRegisterName() {
return null;
}
}
import java.util.HashMap;
import java.util.Map;
import yui.comn.hub.data.handler.impl.TestHubDataHandler;
import yui.comn.hub.data.handler.impl.TransHubDataHandler;
/**
* 抽象数据中转处理注册类
* @author yuyi
*/
public class HubDataHandlerRegister {
private Map<String, IHubDataHandler> handlers = new HashMap<>();
private static HubDataHandlerRegister register;
public static HubDataHandlerRegister getInstance() {
if (null == register) {
register = new HubDataHandlerRegister();
}
return register;
}
//公共handler注册器建议使用显性注入注册方式
public HubDataHandlerRegister() {
handlers.put("test", new TestHubDataHandler());
handlers.put("trans", new TransHubDataHandler());
}
public void registerHandler(String name, IHubDataHandler handler) {
if (handlers.containsKey(name)) {
throw new RuntimeException("xml数据处理器已经存在, name=" + name + ", handler=" + handlers.get(name));
}
handlers.put(name, handler);
}
public IHubDataHandler getHandler(String key) {
return handlers.get(key);
}
}
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import yui.comn.hub.model.HubXmlColumn;
import yui.comn.hub.model.HubXmlHandlerConfig;
/**
* 数据加工
* @author yuyi
*/
public class HubDataHandlerProcess {
private static HubDataHandlerProcess hubDataProcess;
public static HubDataHandlerProcess getInstance() {
if (null == hubDataProcess) {
hubDataProcess = new HubDataHandlerProcess();
}
return hubDataProcess;
}
public void handle(HubXmlColumn col, Map<String, Object> dataMap) {
List<HubXmlHandlerConfig> configs = col.getHandlerConfigs();
//原始的值
Object origVal = dataMap.get(col.getName());
for (HubXmlHandlerConfig dataConfig : configs) {
IHubDataHandler hubDataHandler = HubDataHandlerRegister.getInstance().getHandler(dataConfig.getHandler());
Object resultVal = hubDataHandler.handle(dataConfig.getParams(), dataMap);
dataMap.put(col.getName(), resultVal);
}
if (StringUtils.isBlank(col.getToName())) {
dataMap.put(col.getName(), dataMap.get(col.getName()));
} else {
dataMap.put(col.getToName(), dataMap.get(col.getName()));
dataMap.put(col.getName(), origVal);
}
}
}
7. hub的springboot配置 HubConfig.java, HubProperties.java
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import yui.comn.hub.xml.parser.HubXmlCache;
/**
* @author yuyi
*/
@Configuration
@EnableConfigurationProperties(HubProperties.class)
public class HubConfig {
@Bean("hubXmlCache")
public HubXmlCache hubXmlCache(HubProperties hubProperties) {
if (null != hubProperties.getCache()) {
HubXmlCache.getInstance().setCache(hubProperties.getCache());
}
return HubXmlCache.getInstance();
}
}
import org.springframework.boot.context.properties.ConfigurationProperties;
import lombok.Data;
/**
* hub 配置属性
* @author yuyi
*/
@Data
@ConfigurationProperties(HubProperties.targetName)
public class HubProperties {
public static final String targetName = "spring.hub";
//HubXmlCache是否开启缓存，开发阶段建议关闭缓存，默认是开启
private Boolean cache;
}