package com.dobbinsoft.fw.support.mapper;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.dobbinsoft.fw.core.util.ReflectUtil;
|
import com.dobbinsoft.fw.support.annotation.ForeignKey;
|
import com.dobbinsoft.fw.support.annotation.LeafTable;
|
import com.dobbinsoft.fw.support.annotation.enums.ListLeafType;
|
import com.dobbinsoft.fw.support.context.QueryContext;
|
import com.dobbinsoft.fw.support.domain.SuperDO;
|
import com.dobbinsoft.fw.support.model.Page;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.util.CollectionUtils;
|
|
import java.io.Serializable;
|
import java.lang.reflect.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* Description:
|
* User: rize
|
* Date: 2020/8/1
|
* Time: 10:54
|
*/
|
public interface IMapper<T> extends BaseMapper<T> {
|
|
/**
|
* 高效率批量插入 仅支持 MYSQL
|
*
|
* @param entityList
|
* @return
|
*/
|
Integer insertBatchSomeColumn(Collection<T> entityList);
|
|
/**
|
* 初始化表
|
*
|
* @return
|
*/
|
Integer tableInit();
|
|
/**
|
* 查询Dto，并获取子表数据
|
*
|
* @param id
|
* @param clazz
|
* @param <DTO>
|
* @return
|
*/
|
default <DTO> DTO selectByIdDto(Long id, Class<DTO> clazz) {
|
return selectByIdDto(id, clazz, getFieldList(clazz));
|
}
|
|
/**
|
* 查询Dto，并获取子表数据
|
*
|
* @param id
|
* @param clazz
|
* @param fieldList
|
* @param <DTO>
|
* @return
|
*/
|
default <DTO> DTO selectByIdDto(Long id, Class<DTO> clazz, String... fieldList) {
|
T t = this.selectById(id);
|
if (t == null) {
|
return null;
|
}
|
DTO dto = null;
|
try {
|
dto = clazz.newInstance();
|
BeanUtils.copyProperties(t, dto);
|
for (String fieldStr : fieldList) {
|
Field field = clazz.getDeclaredField(fieldStr);
|
if (Collection.class.isAssignableFrom(field.getType())) {
|
ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
|
Class itemClazz = (Class) parameterizedType.getActualTypeArguments()[0];
|
Field[] itemFields = itemClazz.getDeclaredFields();
|
String name = null;
|
for (Field itemField : itemFields) {
|
ForeignKey annotation = itemField.getAnnotation(ForeignKey.class);
|
if (annotation != null) {
|
name = StrUtil.toUnderlineCase(itemField.getName());
|
}
|
}
|
if (name != null) {
|
IMapper mapper = MapperManager.map.get(itemClazz);
|
if (mapper == null) {
|
throw new RuntimeException("请确认 " + itemClazz.toGenericString() + " 所对应Mapper存在");
|
}
|
List list = mapper.selectList(new QueryWrapper<Object>().eq(name, id));
|
Method method = clazz.getMethod(ReflectUtil.getMethodName(fieldStr, "set"), field.getType());
|
method.invoke(dto, list);
|
}
|
}
|
}
|
} catch (InstantiationException | IllegalAccessException | NoSuchFieldException | NoSuchMethodException | InvocationTargetException e) {
|
// 反射异常
|
e.printStackTrace();
|
}
|
return dto;
|
}
|
|
/**
|
* 插入DTO，并插入子表
|
*
|
* @param dto
|
* @return
|
*/
|
default Integer insertDto(Object dto) {
|
return insertDto(dto, getFieldList(dto.getClass()));
|
}
|
|
/**
|
* 插入DTO，并插入子表
|
*
|
* @param dto
|
* @param fieldList
|
* @return
|
*/
|
default Integer insertDto(Object dto, String... fieldList) {
|
int effect = 0;
|
Class<T> entityClass = this.getEntityClass();
|
if (entityClass != null) {
|
try {
|
T instance = (T) entityClass.newInstance();
|
BeanUtils.copyProperties(dto, instance);
|
effect = this.insert(instance);
|
Method getIdMethod = cn.hutool.core.util.ReflectUtil.getMethod(instance.getClass(), "getId");
|
Object primaryKey = getIdMethod.invoke(instance);
|
try {
|
Method method = dto.getClass().getMethod("setId", Long.class);
|
method.invoke(dto, primaryKey);
|
} catch (NoSuchMethodException e) {
|
|
}
|
// 子表
|
Class<?> dtoClass = dto.getClass();
|
for (String filedStr : fieldList) {
|
Method get = dtoClass.getMethod(ReflectUtil.getMethodName(filedStr, "get"));
|
if (get.invoke(dto) instanceof Collection) {
|
Collection subList = (Collection) get.invoke(dto);
|
if (!CollectionUtils.isEmpty(subList)) {
|
// 找到子表的Mapper
|
Class subClazz = null;
|
Method fKeyMethod = null;
|
for (Object subObj : subList) {
|
if (subClazz == null) {
|
subClazz = subObj.getClass();
|
// 找出子表外键，并将primaryKey设置进去
|
Field[] subClazzDeclaredFields = subClazz.getDeclaredFields();
|
for (Field subField : subClazzDeclaredFields) {
|
ForeignKey foreignKey = subField.getAnnotation(ForeignKey.class);
|
if (foreignKey != null) {
|
fKeyMethod = cn.hutool.core.util.ReflectUtil.getMethod(subClazz,
|
ReflectUtil.getMethodName(subField.getName(), "set"), primaryKey.getClass());
|
}
|
}
|
}
|
if (fKeyMethod == null) {
|
throw new RuntimeException("子表未设置外键:" + subClazz.getName());
|
}
|
// 设置外键
|
fKeyMethod.invoke(subObj, primaryKey);
|
}
|
IMapper mapper = MapperManager.map.get(subClazz);
|
if (mapper == null) {
|
throw new RuntimeException("请确认 " + subClazz.toGenericString() + " 所对应Mapper存在");
|
}
|
Field field = dtoClass.getDeclaredField(filedStr);
|
boolean batch = false;
|
LeafTable leafTable = field.getAnnotation(LeafTable.class);
|
if (leafTable != null) {
|
batch = leafTable.batch();
|
}
|
if (batch) {
|
// 若是批量插入
|
mapper.insertBatchSomeColumn(subList);
|
} else {
|
// 单个插入
|
for (Object subItem : subList) {
|
mapper.insert(subItem);
|
}
|
}
|
}
|
}
|
}
|
} catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException | NoSuchFieldException e) {
|
e.printStackTrace();
|
}
|
}
|
return effect;
|
}
|
|
default Integer deleteByIdDto(Serializable id, Class<?> clazz) {
|
return deleteByIdDto(id, clazz, getFieldList(clazz));
|
}
|
|
/**
|
* 删除DTO，并删除其子表数据
|
*
|
* @param id 主键
|
* @param clazz
|
* @param fieldList
|
* @return
|
*/
|
default Integer deleteByIdDto(Serializable id, Class<?> clazz, String... fieldList) {
|
// 1.删除主表
|
int effect = this.deleteById(id);
|
// 2.找到从表
|
if (effect > 0) {
|
for (String fieldStr : fieldList) {
|
try {
|
Field field = clazz.getDeclaredField(fieldStr);
|
Type genericType = field.getGenericType();
|
if (genericType instanceof ParameterizedType) {
|
ParameterizedType pt = (ParameterizedType) genericType;
|
Type actualTypeArgument = pt.getActualTypeArguments()[0];
|
if (actualTypeArgument instanceof Class) {
|
if (SuperDO.class.isAssignableFrom((Class<?>) actualTypeArgument)) {
|
// 若是DO派生类
|
Class subActualType = (Class) actualTypeArgument;
|
// 找到DO的外键
|
Field[] subActualTypeDeclaredFields = subActualType.getDeclaredFields();
|
for (Field subField : subActualTypeDeclaredFields) {
|
if (subField.getAnnotation(ForeignKey.class) != null) {
|
IMapper mapper = MapperManager.map.get(subActualType);
|
if (mapper == null) {
|
throw new RuntimeException("请确认 " + subActualType.toGenericString() + " 所对应Mapper存在");
|
}
|
mapper.delete(new QueryWrapper<Object>().eq(StrUtil.toUnderlineCase(subField.getName()), id));
|
}
|
}
|
}
|
|
}
|
}
|
} catch (NoSuchFieldException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
return effect;
|
}
|
|
|
/**
|
* 从查询上下文中获取条件，并且分页查询
|
*
|
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
|
*/
|
default <E extends IPage<T>> E selectPage(E page) {
|
return this.selectPage(page, (Wrapper<T>) QueryContext.get());
|
}
|
|
/**
|
* 从查询上下文中获取条件
|
*/
|
default List<T> selectList() {
|
return this.selectList(QueryContext.get());
|
}
|
|
/**
|
* 分页查取dto
|
*
|
* @param page
|
* @param queryWrapper
|
* @param clazz
|
* @param <DTO>
|
* @return
|
*/
|
default <DTO> Page<DTO> selectPageDto(Page<T> page, Wrapper<T> queryWrapper, Class<DTO> clazz) {
|
Page<T> domainPage = this.selectPage(page, queryWrapper);
|
Class<T> entityClass = this.getEntityClass();
|
if (entityClass != null) {
|
String[] fieldListInList = this.getFieldListInList(clazz);
|
Map<String, Map<Object, List>> paramsMap = new HashMap<>();
|
if (fieldListInList.length > 0) {
|
Method getId = cn.hutool.core.util.ReflectUtil.getMethod(entityClass, "getId");
|
Set<Object> ids = domainPage.getRecords().stream().map(item -> {
|
try {
|
Object id = getId.invoke(item);
|
return id;
|
} catch (IllegalAccessException | InvocationTargetException e) {
|
e.printStackTrace();
|
throw new RuntimeException("该对象未设置主键");
|
}
|
}).collect(Collectors.toSet());
|
if (!CollectionUtils.isEmpty(ids)) {
|
// 若不为空
|
try {
|
for (String fieldStr : fieldListInList) {
|
Field field = clazz.getDeclaredField(fieldStr);
|
if (Collection.class.isAssignableFrom(field.getType())) {
|
ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
|
// 列表内元素类
|
Class itemClazz = (Class) parameterizedType.getActualTypeArguments()[0];
|
// 获取外键
|
Field[] itemFields = itemClazz.getDeclaredFields();
|
inner:
|
for (Field itemField : itemFields) {
|
ForeignKey foreignKey = itemField.getAnnotation(ForeignKey.class);
|
if (foreignKey != null) {
|
String name = StrUtil.toUnderlineCase(itemField.getName());
|
IMapper itemMapper = MapperManager.map.get(itemClazz);
|
List childrenList = itemMapper.selectList((Wrapper) new QueryWrapper().in(name, ids));
|
// 以外键属性分组
|
Map<Object, List> map = (Map<Object, List>) childrenList.stream().collect(Collectors.groupingBy(item -> {
|
Object foreignKeyId = null;
|
try {
|
Method getForeignKeyMethod = itemClazz.getMethod(ReflectUtil.getMethodName(itemField.getName(), "get"));
|
foreignKeyId = getForeignKeyMethod.invoke(item);
|
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
|
e.printStackTrace();
|
}
|
return foreignKeyId;
|
}));
|
paramsMap.put(fieldStr, map);
|
break inner;
|
}
|
}
|
}
|
}
|
} catch (NoSuchFieldException e) {
|
e.printStackTrace();
|
}
|
// 循环将这个trans进去
|
|
}
|
}
|
return domainPage.trans(item -> {
|
DTO dto = null;
|
try {
|
dto = clazz.newInstance();
|
BeanUtils.copyProperties(item, dto);
|
Set<String> keys = paramsMap.keySet();
|
// key dto 中 Collection属性中的 field 字符串名字
|
for (String key : keys) {
|
Map<Object, List> paramMap = paramsMap.get(key);
|
if (!CollectionUtils.isEmpty(paramMap)) {
|
// 取出Item的主键
|
Method getIdMethod = item.getClass().getMethod("getId");
|
Object mainPk = getIdMethod.invoke(item);
|
List list = paramMap.get(mainPk);
|
Method setListMethod = clazz.getMethod(ReflectUtil.getMethodName(key, "set"), List.class);
|
setListMethod.invoke(dto, list);
|
}
|
}
|
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
|
e.printStackTrace();
|
}
|
return dto;
|
});
|
}
|
return null;
|
}
|
|
|
/********************** 以下可以理解为私有方法 *********************/
|
|
/**
|
* 通过注解获取属性，抽取方法
|
*
|
* @param clazz
|
* @param <DTO>
|
* @return
|
*/
|
default <DTO> String[] getFieldList(Class<DTO> clazz) {
|
Field[] declaredFields = clazz.getDeclaredFields();
|
List<String> list = new LinkedList<>();
|
for (Field field : declaredFields) {
|
if (field.getAnnotation(LeafTable.class) != null) {
|
list.add(field.getName());
|
}
|
}
|
return list.toArray(new String[0]);
|
}
|
|
/**
|
* 通过注解获取，需要被 selectPageDto 和 selectListDto 查询到的叶子子表
|
*
|
* @param clazz
|
* @param <DTO>
|
* @return
|
*/
|
default <DTO> String[] getFieldListInList(Class<DTO> clazz) {
|
Field[] declaredFields = clazz.getDeclaredFields();
|
List<String> list = new LinkedList<>();
|
for (Field field : declaredFields) {
|
LeafTable leafTable = field.getAnnotation(LeafTable.class);
|
if (leafTable != null) {
|
if (leafTable.containsList() == ListLeafType.WITH) {
|
list.add(field.getName());
|
}
|
}
|
}
|
return list.toArray(new String[0]);
|
}
|
|
|
default Class<T> getEntityClass() {
|
Class<? extends IMapper> clazz = this.getClass();
|
Type[] genericInterfaces = clazz.getGenericInterfaces();
|
for (Type type : genericInterfaces) {
|
if (type instanceof Class) {
|
Class mapperClazz = (Class) type;
|
Type[] iMapperTypes = mapperClazz.getGenericInterfaces();
|
if (iMapperTypes.length > 0) {
|
for (Type t : iMapperTypes) {
|
if (t instanceof ParameterizedType) {
|
ParameterizedType pt = (ParameterizedType) t;
|
if (IMapper.class.isAssignableFrom((Class) pt.getRawType())) {
|
// 若是IMapper的子类
|
Class entityClass = (Class) pt.getActualTypeArguments()[0];
|
return entityClass;
|
}
|
}
|
}
|
}
|
}
|
}
|
return null;
|
}
|
|
}
|
