package com.ruoyi.framework.aspectj;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.IService;
|
import com.ruoyi.common.annotation.UniqueCheck;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.spring.SpringUtils;
|
import org.aspectj.lang.JoinPoint;
|
import org.aspectj.lang.annotation.Aspect;
|
import org.aspectj.lang.annotation.Before;
|
import org.aspectj.lang.annotation.Pointcut;
|
import org.aspectj.lang.reflect.MethodSignature;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.core.annotation.Order;
|
import org.springframework.stereotype.Component;
|
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Method;
|
import java.util.List;
|
|
/**
|
* 唯一性校验切面
|
* 用于在新增操作前进行字段唯一性检查
|
*
|
* @author ruoyi
|
*/
|
@Aspect
|
@Order(2)
|
@Component
|
public class UniqueCheckAspect
|
{
|
protected Logger logger = LoggerFactory.getLogger(getClass());
|
|
@Pointcut("@annotation(com.ruoyi.common.annotation.UniqueCheck)")
|
public void uniqueCheckPointCut()
|
{
|
}
|
|
@Before("uniqueCheckPointCut()")
|
public void doBefore(JoinPoint point) throws Throwable
|
{
|
handleUniqueCheck(point);
|
}
|
|
protected void handleUniqueCheck(JoinPoint joinPoint) throws Exception
|
{
|
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
|
Method method = signature.getMethod();
|
UniqueCheck uniqueCheck = method.getAnnotation(UniqueCheck.class);
|
|
if (uniqueCheck == null)
|
{
|
return;
|
}
|
|
// 获取方法参数
|
Object[] args = joinPoint.getArgs();
|
if (args == null || args.length == 0)
|
{
|
return;
|
}
|
|
// 获取第一个参数(通常是实体对象)
|
Object entity = args[0];
|
if (entity == null)
|
{
|
return;
|
}
|
|
// 校验实体类型
|
Class<?> entityClass = uniqueCheck.entityClass();
|
if (!entityClass.isInstance(entity))
|
{
|
logger.warn("实体类型不匹配, 期望: {}, 实际: {}", entityClass.getName(), entity.getClass().getName());
|
return;
|
}
|
|
// 获取Service实例
|
Class<?> serviceClass = uniqueCheck.serviceClass();
|
IService service = (IService) SpringUtils.getBean(serviceClass);
|
|
// 获取需要检查的字段
|
String[] fields = uniqueCheck.fields();
|
if (fields == null || fields.length == 0)
|
{
|
throw new ServiceException("UniqueCheck注解的fields属性不能为空");
|
}
|
|
// 构建查询条件
|
QueryWrapper queryWrapper = Wrappers.query();
|
StringBuilder messageBuilder = new StringBuilder();
|
boolean hasCondition = false;
|
|
for (int i = 0; i < fields.length; i++)
|
{
|
String fieldName = fields[i];
|
Object fieldValue = getFieldValue(entity, fieldName);
|
|
// 只有字段值不为空时才添加查询条件
|
if (fieldValue != null && !"".equals(fieldValue))
|
{
|
// 使用字符串字段名,MyBatis-Plus会自动转换为数据库列名
|
queryWrapper.eq(StringUtils.toUnderScoreCase(fieldName), fieldValue);
|
hasCondition = true;
|
|
if (messageBuilder.length() > 0)
|
{
|
messageBuilder.append(",");
|
}
|
messageBuilder.append(fieldValue);
|
}
|
}
|
|
// 如果没有有效的查询条件,直接返回
|
if (!hasCondition)
|
{
|
return;
|
}
|
|
// 执行查询
|
List list = service.list(queryWrapper);
|
if (list != null && !list.isEmpty())
|
{
|
String message = uniqueCheck.message();
|
// 简单的消息格式化
|
if (message.contains("{value0}"))
|
{
|
message = message.replace("{value0}", messageBuilder.toString());
|
}
|
|
logger.warn("唯一性校验失败: {}", message);
|
throw new ServiceException(message);
|
}
|
}
|
|
/**
|
* 通过反射获取实体字段值
|
*/
|
private Object getFieldValue(Object entity, String fieldName) throws Exception
|
{
|
Class<?> clazz = entity.getClass();
|
|
// 尝试获取字段
|
Field field = null;
|
while (clazz != null && field == null)
|
{
|
try
|
{
|
field = clazz.getDeclaredField(fieldName);
|
}
|
catch (NoSuchFieldException e)
|
{
|
clazz = clazz.getSuperclass();
|
}
|
}
|
|
if (field == null)
|
{
|
throw new ServiceException("实体类中不存在字段: " + fieldName);
|
}
|
|
field.setAccessible(true);
|
return field.get(entity);
|
}
|
}
|
