使用@Query注解的时候，常常需要写sql来映射非域类的实例，通常的做法就是 实现 RowMapper接口，然后new实例一个一个的设置值进去。。。为此。出世了自动映射工具类
注意事项：此抽象类只是结果集 一条记录到行 的映射，添加了额外的方法；比如就是把一个字段的值拆分成Map或List，然后会自动组装成类实例
这是抽象类，也是主要的，你的域类继承这个抽象类即可，无需任何实现，@Query(....,rowMapperClass=域类.class) 即可
package cn.dmahz.dao.repo.model; import cn.dmahz.dao.repo.model.article.ArticleInfoRepoModel; import cn.dmahz.utils.MyReflectUtils; import com.sun.rowset.JdbcRowSetImpl; import lombok.*; import lombok.extern.slf4j.Slf4j; import org.apache.commons.beanutils.ConvertUtils; import org.springframework.jdbc.core.RowMapper; import java.lang.reflect.*; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.SQLSyntaxErrorException; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 自动映射 RowMapping * @author Dream */ @Slf4j public abstract class RowMapperAutoMapping<T> implements RowMapper<T> { private static final Set<Class<?>> BASE_TYPE_SET = new HashSet<>(); private static final Set<Class<?>> ARRAY_BASE_TYPE_SET = new HashSet<>(); static { BASE_TYPE_SET.add(String.class); BASE_TYPE_SET.add(Byte.class); BASE_TYPE_SET.add(Byte.TYPE); BASE_TYPE_SET.add(Double.class); BASE_TYPE_SET.add(Double.TYPE); BASE_TYPE_SET.add(Float.class); BASE_TYPE_SET.add(Float.TYPE); BASE_TYPE_SET.add(Integer.class); BASE_TYPE_SET.add(Integer.TYPE); BASE_TYPE_SET.add(Long.class); BASE_TYPE_SET.add(Long.TYPE); BASE_TYPE_SET.add(Short.class); BASE_TYPE_SET.add(Short.TYPE); BASE_TYPE_SET.add(Boolean.class); BASE_TYPE_SET.add(Boolean.TYPE); ARRAY_BASE_TYPE_SET.add(String[].class); ARRAY_BASE_TYPE_SET.add(Byte[].class); ARRAY_BASE_TYPE_SET.add(byte[].class); ARRAY_BASE_TYPE_SET.add(Double[].class); ARRAY_BASE_TYPE_SET.add(double[].class); ARRAY_BASE_TYPE_SET.add(Float[].class); ARRAY_BASE_TYPE_SET.add(float[].class); ARRAY_BASE_TYPE_SET.add(Integer[].class); ARRAY_BASE_TYPE_SET.add(int[].class); ARRAY_BASE_TYPE_SET.add(Long[].class); ARRAY_BASE_TYPE_SET.add(long[].class); ARRAY_BASE_TYPE_SET.add(Short[].class); ARRAY_BASE_TYPE_SET.add(short[].class); ARRAY_BASE_TYPE_SET.add(Boolean[].class); ARRAY_BASE_TYPE_SET.add(boolean[].class); } private static final Pattern COMPILE = Pattern.compile("([A-Z])+"); /** * 解析处理值，将值解析为数组形式并返回 * @param fieldName * @param value */ protected List<Object> parsedValueIsArray(String fieldName,Object value){ return new ArrayList<>(); } /** * 将字段值转换成 List Map对象，其中List中的每个Map元素对应一个类实例 * @param fieldName * @param value * @return */ protected List<Map<String,Object>> parsedValueIsArrayMap(String fieldName,Object value){ return new ArrayList<>(); } public T autoMapping(ResultSet rs,Class<T> tClass) throws SQLException, IllegalAccessException, InstantiationException { T t = tClass.newInstance(); Field[] allFields = MyReflectUtils.getAllFields(tClass); for (Field field : allFields) { int modifiers = field.getModifiers(); if(Modifier.isStatic(modifiers) || Modifier.isFinal(modifiers)){ continue; } switchIf(t,field,rs,null); } return t; } /** * 获取集合的实例 * @return */ protected Collection<?> getCollectionInstance(){ return new ArrayList<>(); } @SuppressWarnings("DuplicatedCode") private void switchIf(Object o, Field field, ResultSet rs, Map<String,Object> valueMap) throws IllegalAccessException, SQLException, InstantiationException { Object extractValue = extractValue(rs, valueMap, field.getName()); Type genericType = field.getGenericType(); if(genericType instanceof ParameterizedType){ // 泛型类型 ParameterizedType parameterizedType = (ParameterizedType)genericType; Type rawType = parameterizedType.getRawType(); if(Collection.class.isAssignableFrom((Class<?>) rawType)){ Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); if(actualTypeArguments.length > 1){ throw new RuntimeException("仅支持单泛型Copy"); } Class<?> argumentCls = (Class<?>) actualTypeArguments[0]; boolean b = copyMappingField(o, field, argumentCls, extractValue); if(!b){ List<Map<String, Object>> maps = parsedValueIsArrayMap(field.getName(), extractValue); Object instance; if(!((Class<?>) rawType).isInterface()){ instance = ((Class<?>) rawType).newInstance(); }else{ instance = getCollectionInstance(); } @SuppressWarnings("unchecked") Collection<Object> coll = (Collection<Object>) instance; Object argInstance; for (Map<String, Object> map : maps) { argInstance = argumentCls.newInstance(); Field[] allFields = MyReflectUtils.getAllFields(argumentCls); for (Field f : allFields) { switchIf(argInstance,f,null,map); } coll.add(argInstance); } field.set(o,coll); } } }else{ // 基本数组类型 Class<?> componentType = ((Class<?>) genericType).getComponentType(); if (componentType != null){ // 数组类型，例如：int[] string[] entity[] copyMappingArray(o,field,componentType,extractValue); }else { // 基本类型，不包含泛型的类型 ;基本类型或单类型 boolean b = copyMappingField(o, field, (Class<?>) genericType, extractValue); if(!b){ log.error("不是基本类型，准备再次进行解刨 {}",genericType); // 不是基本类型，则进行再次解抛 Class<?> genericCls = ((Class<?>) genericType); Object instance = genericCls.newInstance(); Field[] allFields = MyReflectUtils.getAllFields(genericCls); for (Field f : allFields) { switchIf(instance,f,null,valueMap); } } } } } /** * 处理基本数组形式的copy映射，例如：int[],String[],Long[],实体类[],POJO[]； * 粗略的说明就是：将 expectValue经过解析，返回数组形式的值对象，设置到o对象里的field字段中 * @param o 需要设置对象的实例 * @param field 当前处理的字段 * @param typeCls 字段的类型 * @param expectValue 期望的值 * @throws IllegalAccessException * @throws SQLException * @throws InstantiationException */ @SuppressWarnings("DuplicatedCode") private void copyMappingArray(Object o, Field field, Class<?> typeCls, Object expectValue) throws IllegalAccessException, SQLException, InstantiationException { Object[] oS = (Object[]) Array.newInstance(typeCls,0); if(BASE_TYPE_SET.contains(typeCls)){ List<Object> objects = parsedValueIsArray(field.getName(), expectValue); field.set(o,objects.toArray(oS)); }else{ List<Map<String, Object>> maps = parsedValueIsArrayMap(field.getName(), expectValue); ArrayList<Object> objects = new ArrayList<>(); Object instance; for (Map<String, Object> map : maps) { instance = typeCls.newInstance(); Field[] allFields = MyReflectUtils.getAllFields(typeCls); for (Field f : allFields) { switchIf(instance,f,null,map); } objects.add(instance); } field.set(o,objects.toArray(oS)); } } /** * 赋值映射普通字段 */ private boolean copyMappingField(Object o,Field field,Class<?> fieldTypeCls,Object value) throws IllegalAccessException { if(BASE_TYPE_SET.contains(fieldTypeCls)){ if(value != null){ value = ConvertUtils.convert(value, fieldTypeCls); } field.set(o,value); return true; } return false; } /** * 提取ResultSet 或 valueMap中的值(二选一)，根据字段名称进行获取 * @param rs 结果集 (二选一) * @param valueMap 值Map，保存字段的名称和值 (二选一) * @param fieldName 字段名称 * @return * @throws SQLException */ @SuppressWarnings({"DuplicatedCode"}) private Object extractValue(ResultSet rs,Map<String,Object> valueMap,String fieldName) throws SQLException { String underscoreName = fieldName; Matcher matcher = COMPILE.matcher(underscoreName); while (matcher.find()){ underscoreName = underscoreName.replace(matcher.group(1),"_" + matcher.group(1).toLowerCase()); } String[] keys = new String[]{fieldName,underscoreName}; for (String key : keys) { try{ return rs != null ? rs.getObject(key) : valueMap !=null && valueMap.containsKey(key) ? valueMap.get(key) : null; }catch (SQLSyntaxErrorException e) { // 什么也不做，继续遍历key获取字典 if (e.getErrorCode() != 1054){ throw e; } } } log.debug("字段 {}从ResultSet中无法获取到值，请注意是否是设计如此", fieldName); return null; } public void test(){ System.out.println(this.getClass()); } @SuppressWarnings("unchecked") @Override public T mapRow(ResultSet rs, int rowNum) throws SQLException { try { Type genericSuperclass = this.getClass().getGenericSuperclass(); if(genericSuperclass instanceof ParameterizedType){ ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass; return autoMapping(rs, (Class<T>) parameterizedType.getActualTypeArguments()[0]); }else { log.warn("泛型未声明，使用 this.getClass() 获取注入的Class对象"); return autoMapping(rs, (Class<T>) this.getClass()); } } catch (IllegalAccessException | InstantiationException e) { e.printStackTrace(); } return null; } public static void main(String[] args) throws IllegalAccessException, SQLException, InstantiationException { // Matcher virtualUserName = compile.matcher("virtualUserName"); // System.out.println(virtualUserName.find()); // System.out.println(virtualUserName.find()); // System.out.println(virtualUserName.find()); // System.out.println(virtualUserName.find()); // // String name = "virtualUserName"; // String underscoreName = name; // Matcher matcher = compile.matcher(name); // while (matcher.find()){ // underscoreName = underscoreName.replace(matcher.group(1),"_" + matcher.group(1).toLowerCase()); // } // System.out.println("underscoreName:" + underscoreName); // TestResultSet testResultSet = new TestResultSet(); // TestEntity testEntity = new TestEntity(); // TestEntity testEntity1 = testEntity.autoMapping(testResultSet, TestEntity.class); // System.out.println("testEntity1: " + testEntity1); System.err.println(boolean.class); System.err.println(Boolean.class); System.err.println(Boolean.TYPE); System.err.println(Integer.TYPE); System.err.println(Integer.class); System.err.println(Integer[].class); System.err.println(int[].class); System.err.println(float[].class); System.err.println(Float[].class); ArticleInfoRepoModel articleInfoRepoModel = new ArticleInfoRepoModel(); articleInfoRepoModel.mapRow(null,1); } @Getter @Setter @ToString static class TestEntity extends RowMapperAutoMapping<TestEntity> { private String id; private String name; private Integer age; private Long createTime; private String[] authors; private TestCategoryEntity[] testCategoryEntities; private List<TestCategoryEntity> testCategoryEntityList; @Override protected List<Object> parsedValueIsArray(String fieldName, Object value) { ArrayList<Object> objects = new ArrayList<>(); if("authors".equals(fieldName)){ String[] split = value.toString().split(","); for (String s : split) { objects.add(s); } } return objects; } @Override protected List<Map<String, Object>> parsedValueIsArrayMap(String fieldName, Object value) { ArrayList<Map<String, Object>> maps = new ArrayList<>(); HashMap<String, Object> hashMap = new HashMap<>(); hashMap.put("id","小飞机_id"); hashMap.put("name","小飞机撞大象"); maps.add(hashMap); hashMap = new HashMap<>(); hashMap.put("id","小火车_id"); hashMap.put("name","小火车开飞机"); maps.add(hashMap); return maps; } } @Data static class TestCategoryEntity{ private String id; private String name; } static class TestResultSet extends JdbcRowSetImpl { private Map<String,Object> map = new HashMap<>(); public TestResultSet() { map.put("id","001_id"); map.put("name","我是iemo"); map.put("age",25); map.put("createTime",System.currentTimeMillis()); map.put("authors","小王作者,小恶魔作者"); map.put("testCategoryEntities","001:喜哦,002:小王"); } @Override public Object getObject(String columnLabel) throws SQLException { return map.get(columnLabel); } } }
这是反射工具类，可以获取范围内的方法的字段列表，没有加锁，当并发高的情况下，可能会有问题吧，后期优化即可，每个类的反射出的字段都会进行缓存下来，方便下次直接返回
package cn.dmahz.utils; import cn.dmahz.anno.IgnoreField; import cn.dmahz.anno.ManyChild; import cn.dmahz.anno.OneParent; import cn.dmahz.anno.PrimaryId; import cn.dmahz.excep.*; import lombok.Getter; import lombok.Setter; import lombok.SneakyThrows; import lombok.ToString; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.ObjectUtils; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.data.annotation.*; import org.springframework.util.ReflectionUtils; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; @Slf4j public class MyReflectUtils { private static final Field[] ARRAY_FIELDS = new Field[0]; private static final Map<String, Map<String, Field>> CACHE_FIELD = new ConcurrentHashMap<>(); private static final Map<String, Map<String, Field>> CACHE_AUDIT_FIELD = new ConcurrentHashMap<>(); /*锁对象实例*/ private static final Object CACHE_LOCK = new Object(); private static final Object CACHE_AUDIT_LOCK = new Object(); private static final Map<String, Map<String, Method>> CACHE_METHOD = new ConcurrentHashMap<>(); public static void main(String[] args) { Method createBy = getMethodInMapper("cn.dmahz.dao.mapper.RelatedBookCategoryMapper.test_save"); System.out.println(createBy); System.out.println(Boolean.class.getSimpleName()); } /** * 获取映射器的中的方法，仅适用于Mapper接口中的方法 * @param mapperId 例如：cn.dmahz.dao.mapper.RelatedBookCategoryMapper.test_save * @return */ public static Method getMethodInMapper(String mapperId){ int lastIndexOf = mapperId.lastIndexOf("."); // 包名.类名 String classFullName = mapperId.substring(0,lastIndexOf); // 方法名 String methodName = mapperId.substring(lastIndexOf + 1); return getMethodInInterface(classFullName,methodName); } /** * 获取指定接口的方法对象 * @param className 类全路径字符串;例如:class.getName() * @param methodName 方法名称 * @return */ @SneakyThrows public static Method getMethodInInterface(String className, String methodName){ Class<?> cls = Class.forName(className); String clsName = cls.getName(); if(!CACHE_METHOD.containsKey(clsName)){ CACHE_METHOD.put(clsName,new ConcurrentHashMap<>()); } Map<String, Method> methodMap = CACHE_METHOD.get(clsName); if(!methodMap.isEmpty()){ return methodMap.get(methodName); }else { Class<?> targetCls = cls; Method targetMethod = null; do { Method[] declaredMethods = targetCls.getDeclaredMethods(); for (Method method:declaredMethods){ String name = method.getName(); if(!methodMap.containsKey(name)){ if(name.equals(methodName)) targetMethod = method; methodMap.put(name,method); } } } while (targetCls.getInterfaces().length> 0 && (targetCls = targetCls.getInterfaces()[0]) != null); return targetMethod; } } /** * 获取cls中的全部的审计字段 * * @param cls * @return */ public static Field[] getAllAuditFields(Class<?> cls){ String auditClsKey = cls.getName(); if(!CACHE_AUDIT_FIELD.containsKey(auditClsKey)) { synchronized (CACHE_AUDIT_LOCK) { if(CACHE_AUDIT_FIELD.containsKey(auditClsKey)){ return CACHE_AUDIT_FIELD.get(auditClsKey).values().toArray(ARRAY_FIELDS); } else { ConcurrentHashMap<String, Field> fieldMap = new ConcurrentHashMap<>(7); Field[] allFields = getAllFields(cls); for (Field field : allFields) { if (field.isAnnotationPresent(CreatedBy.class) || field.isAnnotationPresent(CreatedDate.class) || field.isAnnotationPresent(LastModifiedBy.class) || field.isAnnotationPresent(LastModifiedDate.class) || field.isAnnotationPresent(Id.class)) { fieldMap.put(field.getName(), field); } } CACHE_AUDIT_FIELD.put(auditClsKey, fieldMap); } } } return CACHE_AUDIT_FIELD.get(auditClsKey).values().toArray(ARRAY_FIELDS); } /** * 获取除Object以外的所有字段数组 * @param cls * @return */ public static Field[] getAllFields(Class<?> cls){ return getAllFields(cls, null); } /** * 获取截至endClass的所有字段列表,忽略Object的所有字段 * @param cls 实体类对象 * @param endClass 停止类，包含当前类所属字段 * @return */ public static Field[] getAllFields(Class<?> cls,Class<?> endClass){ Class<?> targetClass = cls; Map<String, Field> cacheField = getCacheField(targetClass.getName()); if(cacheField.isEmpty()){ do { Field[] declaredFields = targetClass.getDeclaredFields(); for(Field field:declaredFields){ field.setAccessible(true); cacheField.put(field.getName(),field); } }while ((targetClass = targetClass.getSuperclass()) != null && (!(endClass != null && targetClass.isAssignableFrom(endClass)) && !targetClass.isAssignableFrom(Object.class)) ); } return cacheField.values().toArray(ARRAY_FIELDS); } /** * 获取当前类中指定字段名称的对象 * @param cls * @param fieldName * @return */ public static Field getDeclaredFields(Class<?> cls,String fieldName){ Class<?> targetClass = cls; Map<String, Field> cacheField = getCacheField(targetClass.getName()); if(cacheField.containsKey(fieldName)){ return cacheField.get(fieldName); } do { Field declaredField = null; try { declaredField = targetClass.getDeclaredField(fieldName); } catch (NoSuchFieldException e) { // 这里不处理异常 } if(declaredField != null){ ReflectionUtils.makeAccessible(declaredField); putCacheField(cls.getName(),fieldName,declaredField); return declaredField; } }while ((targetClass = targetClass.getSuperclass()) != null && !targetClass.isAssignableFrom(Object.class)); return null; } private static void putCache(String clsName,Map<String,Field> fieldMap){ Map<String, Field> cacheField = getCacheField(clsName); cacheField.putAll(fieldMap); } private static void putCacheField(String clsName,String fieldName,Field field){ Map<String, Field> cacheField = getCacheField(clsName); cacheField.put(fieldName,field); } private static Map<String,Field> getCacheField(String clsName){ Map<String, Field> stringFieldMap = CACHE_FIELD.get(clsName); if(ObjectUtils.isEmpty(stringFieldMap)){ stringFieldMap = new ConcurrentHashMap<>(7); CACHE_FIELD.put(clsName,stringFieldMap); } return stringFieldMap; } public static String convertGetMethodName(Field field){ char[] chars = field.getName().toCharArray(); chars[0] = String.valueOf(chars[0]).toUpperCase().toCharArray()[0]; if(boolean.class.isAssignableFrom(field.getType())){ return "is".concat(String.valueOf(chars)); } return "get".concat(String.valueOf(chars)); } public static String convertSetMethodName(Field field){ char[] chars = field.getName().toCharArray(); chars[0] = String.valueOf(chars[0]).toUpperCase().toCharArray()[0]; return "set".concat(String.valueOf(chars)); } public static <T,VO> VO convertToVO(T source,Class<VO> target){ if(source == null){ return null; } return doConvertToVO(source,target,null); } /** * 转换为VO对象 * @param sourceList * @param target * @return */ public static <T,VO> List<VO> convertToVO(List<T> sourceList,Class<VO> target){ final Field[] allFields = getAllFields(target); List<VO> voList = sourceList.parallelStream().map(source -> doConvertToVO(source,target,allFields)).filter(Objects::nonNull).sequential().collect(Collectors.toList()); return voList; } /** * 将源源对象转换成VO实体对象,相同字段则进行赋值 * @param source * @param target * @param targetFields * @param <T> * @param <VO> * @return */ private static <T,VO> VO doConvertToVO(T source,Class<VO> target,Field[] targetFields){ Field[] allFields = targetFields; if(allFields == null){ allFields = getAllFields(target); } VO vo = null; try { vo = target.newInstance(); for (Field field : allFields) { ReflectionUtils.makeAccessible(field); if (!writePrimaryIdField(source, vo, field) && !writeOneParentField(source, vo, field) && !writeManyChildField(source, vo, field)) { writeOrdinaryField(source,source.getClass(), vo, field); } } } catch (InstantiationException | IllegalAccessException e) { e.printStackTrace(); } return vo; } /** * 将目标实体以父子关系链接起来 * @param <T> * @param sourceList 源对象列表 * @param targetCls 目标Class * @throws IllegalAccessException * @throws InstantiationException * @return */ public static <T> List<T> linkRelationshipTree(List<?> sourceList, Class<T> targetCls) { List<CombinationData> combinationDataList = new ArrayList<>(); HashMap<String, T> resultMap = new HashMap<>(sourceList.size()); HashMap<String, CombinationData.Child> childHashMap = new HashMap<>(sourceList.size()); boolean parentMode = false; boolean childMode = false; Set<String> cacheFieldSignature = new HashSet<>(); for (Object source : sourceList) { cacheFieldSignature.clear(); Class<?> sourceClass = source.getClass(); T newInstance; try { newInstance = targetCls.newInstance(); } catch (InstantiationException | IllegalAccessException e) { CannotInstantiationException cannotInstantiationException = new CannotInstantiationException("不能实例化此对象:" + targetCls.getName()); cannotInstantiationException.addSuppressed(e); throw cannotInstantiationException; } CombinationData combinationData = new CombinationData(); combinationData.setSource(source); combinationData.setTarget(newInstance); ReflectionUtils.doWithFields(targetCls,field -> { ReflectionUtils.makeAccessible(field); String fieldSignature = field.getType().getTypeName().concat("->").concat(field.getName()); if(cacheFieldSignature.contains(fieldSignature)){ return; } /** * 当字段不是被 @PrimaryId、@OneParent、@MaryChild 标注的话，会抛出异常 */ if (!writePrimaryIdField(sourceClass, combinationData, field) && !writeOneParentField(source, sourceClass, combinationData, field) && !writeManyChildField(combinationData, source, sourceClass, field)) { writeOrdinaryField(source, sourceClass, newInstance, field); } cacheFieldSignature.add(fieldSignature); }, ReflectionUtils.COPYABLE_FIELDS); String primaryIdValue = combinationData.getIdValue(); resultMap.put(primaryIdValue,newInstance); CombinationData.Child child = combinationData.getChild(); if(ObjectUtils.isNotEmpty(child)){ childHashMap.put(primaryIdValue,child); } //判断模式 if(ObjectUtils.isNotEmpty(combinationData.getParent())){ parentMode = true; } if(ObjectUtils.isNotEmpty(combinationData.getChild())){ childMode = true; } combinationDataList.add(combinationData); } if(parentMode && childMode){ throw new CircularReferenceException(targetCls.getSimpleName().concat("循环引用异常,请使用 {@OneParent|@ManyChild} 其中一个注解进行标识")); } Collection<T> collection = processParseConstituteTree(parentMode, childMode, combinationDataList, resultMap, childHashMap); return Collections.unmodifiableList(new ArrayList<>(collection)); } @ToString private static class CombinationData { /** * 提取数据的源对象 */ @Getter @Setter private Object source; /** * 设置数据的目标对象 */ @Getter @Setter private Object target; /** * 源对象的主键ID */ @Getter private Field sourcePrimaryIdField; @Getter private Field targetPrimaryIdField; /** * 当前target和source对应的主键id值 */ private Object idValue; public <T> T getIdValue(){ return (T) idValue; } /** * 设置主键ID字段 * @param sourceField 源主键ID字段 * @param targetField 目标主键ID字段 */ public void setPrimaryIdField(Field sourceField,Field targetField){ this.sourcePrimaryIdField = sourceField; this.targetPrimaryIdField = targetField; try { Object o = CombinationData.this.sourcePrimaryIdField.get(source); CombinationData.this.targetPrimaryIdField.set(target,o); this.idValue = o; } catch (IllegalAccessException e) { throw new IllegalAccessObjectException("非法访问对象字段"); }catch (NullPointerException e){ throw new NullPointerException("未提供 @PrimaryId 标注主键ID字段"); } } @Getter private Parent parent; public Parent newInstanceParent(){ if(ObjectUtils.isEmpty(this.parent)){ this.parent = new Parent(); } return parent; } private class Parent { /** * 目标对象的父字段对象 */ @Getter @Setter private Field targetParentField; @Getter private Type targetTypes; /** * 源对象的父ID值 */ @Getter @Setter private Object parentId; public void setTargetParentField(Field targetParentField) { this.targetParentField = targetParentField; this.targetTypes = targetParentField.getGenericType(); } public void setTargetParentField(Object value) throws IllegalAccessException { targetParentField.set(CombinationData.this.target,value); } } @Getter private Child child; public Child newInstanceChild(){ if(ObjectUtils.isEmpty(this.child)){ this.child = new Child(); } return child; } private class Child { /** * 当前子属性集合对象的字段，最终要往这里添加值 */ @Getter private Field targetField; /** * 父ID值，后期进行计算 */ @Getter @Setter private Object parentId; /** * 当前对象对应的子ID集合, * 需要反向思考父子关系 */ @Getter private List<String> childIdList = new ArrayList<>(); public void addChildId(String childId){ childIdList.add(childId); } public void setTargetField(Field targetField) throws IllegalAccessException { this.targetField = targetField; //设置泛型的参数化类型 Type genericType = targetField.getGenericType(); ParameterizedType parameterizedType = (ParameterizedType) genericType; Type typeArgument = parameterizedType.getActualTypeArguments()[0]; this.genericType = typeArgument; //获取目标对象的子集合对象 Object o = null; try { o = targetField.get(CombinationData.this.target); } catch (IllegalAccessException e) { e.printStackTrace(); } if(ObjectUtils.isEmpty(o)){ o = new ArrayList<>(); this.targetField.set(CombinationData.this.target,o); } this.list = (List<Object>) o; } /** * 目标对象的子集合属性引用 */ private List<Object> list; /** * 泛型的类型 */ private Type genericType; public void addChild(Object value){ Class<?> genericType = (Class<?>) this.genericType; if(genericType.isAssignableFrom(value.getClass())){ list.add(value); } else { throw new TypeNotMatchException(String.format("提供的数据类型为:%s;需要的类型:%s",value.getClass(),this.genericType.getClass())); } } } } /** * 写入普通字段 */ private static boolean writeOrdinaryField(Object source,Class<?> sourceClass,Object target ,Field field) throws IllegalAccessException { //是否需要忽略当前字段，只有目标字段作为普通字段时才具备此效果 if(field.isAnnotationPresent(IgnoreField.class)){ return true; } String fieldName = field.getName(); Field f = getDeclaredFields(sourceClass,fieldName); if(ObjectUtils.isEmpty(f)){ log.debug("源对象[{}] -> 字段[{}] 不存在",sourceClass.getName(),fieldName); // throw new UnableProcessThis("无法处理当前字段(如果需要忽略,请使用@IgnoreField注解在 ["+target.getClass().getName()+"] 中进行标注):"+field.toGenericString()); return false; }else { Object srcValue = f.get(source); field.set(target, srcValue); return true; } } private static boolean writePrimaryIdField(Class<?> sourceClass,CombinationData combinationData,Field field){ if (field.isAnnotationPresent(PrimaryId.class)){ Field f = getDeclaredFields(sourceClass, field.getName()); combinationData.setPrimaryIdField(f,field); return true; } return false; } private static boolean writePrimaryIdField(Object source,Object target ,Field targetField) throws IllegalAccessException { if (targetField.isAnnotationPresent(PrimaryId.class)){ Field f = getDeclaredFields(source.getClass(), targetField.getName()); targetField.set(target,f.get(source)); return true; } return false; } private static boolean writeOneParentField(Object source,Class<?> sourceClass,CombinationData combinationData,Field field){ OneParent oneParent = AnnotationUtils.getAnnotation(field, OneParent.class); if(ObjectUtils.isNotEmpty(oneParent)){ Field f = MyReflectUtils.getDeclaredFields(sourceClass,oneParent.parentIdValueFieldName()); Object value = ReflectionUtils.getField(f, source); CombinationData.Parent parent = combinationData.newInstanceParent(); parent.setParentId(value); parent.setTargetParentField(field); return true; } return false; } private static boolean writeOneParentField(Object source,Object target ,Field targetField) throws IllegalAccessException { OneParent oneParent = AnnotationUtils.getAnnotation(targetField, OneParent.class); if(ObjectUtils.isNotEmpty(oneParent)){ Field f = MyReflectUtils.getDeclaredFields(source.getClass(),oneParent.parentIdValueFieldName()); Object value = ReflectionUtils.getField(f, source); targetField.set(target,value); return true; } return false; } private static boolean writeManyChildField(CombinationData combinationData,Object source,Class<?> sourceClass,Field field) throws IllegalAccessException { ManyChild manyChild = AnnotationUtils.getAnnotation(field, ManyChild.class); if(ObjectUtils.isNotEmpty(manyChild)){ //从源对象获取父ID Field f = MyReflectUtils.getDeclaredFields(sourceClass,manyChild.parentIdValueFieldName()); Object value = ReflectionUtils.getField(f, source); CombinationData.Child child = combinationData.newInstanceChild(); child.setTargetField(field); child.setParentId(value); return true; } return false; } private static boolean writeManyChildField(Object source,Object target ,Field targetField) throws IllegalAccessException { ManyChild manyChild = AnnotationUtils.getAnnotation(targetField, ManyChild.class); if(ObjectUtils.isNotEmpty(manyChild)){ //从源对象获取父ID Field f = MyReflectUtils.getDeclaredFields(source.getClass(),manyChild.parentIdValueFieldName()); Object value = ReflectionUtils.getField(f, source); targetField.set(target,value); return true; } return false; } /** * 将列表数据构成树 * @param finalParentMode * @param finalChildMode * @param combinationDataList * @param rootMap * @param childHashMap * @param <T> * @return */ private static <T> Collection<T> processParseConstituteTree(final boolean finalParentMode,final boolean finalChildMode, List<CombinationData> combinationDataList, HashMap<String, T> rootMap, HashMap<String, CombinationData.Child> childHashMap ){ //排除的ID集合,从resultMap中根据key进行删除 final List<Object> excludeIdList = new ArrayList<>(); combinationDataList.forEach(combinationData -> { //处理父级关系 CombinationData.Parent parent = combinationData.getParent(); if(ObjectUtils.isNotEmpty(parent)){ Object parentId = parent.getParentId(); T t = rootMap.get(parentId); if(ObjectUtils.isNotEmpty(t)){ try { combinationData.getParent().setTargetParentField(t); if(finalParentMode && !finalChildMode){ excludeIdList.add(parentId); } } catch (IllegalAccessException e) { e.printStackTrace(); } } } }); if(finalChildMode){ excludeIdList.clear(); } //解析子级列表关系 childHashMap.forEach((id, child) -> { Object parentId = child.getParentId(); if(ObjectUtils.isNotEmpty(parentId)){ CombinationData.Child c = childHashMap.get(parentId); if(ObjectUtils.isNotEmpty(c)){ T currentT = rootMap.get(id); if(ObjectUtils.isEmpty(currentT)){ throw new InvalidPrimaryIdValueException("无效主键ID值异常;不能找到指定主键值对应的实体;主键ID值为:".concat(id)); } c.addChild(currentT); //这里需要记录排除的ID列表 if(finalChildMode){ excludeIdList.add(id); } } } }); //移除 resultMap 里的指定ID键对象 // 如果有子级列表关系存在，则只返回首层，否则，返回最后一个子集 excludeIdList.forEach(rootMap::remove); return rootMap.values(); } }
特殊的就是
org.apache.commons.beanutils.ConvertUtils; 这个是commons包中的，来源去maven repo查询即可
如果有问题留言讨论