package cc.mrbird.febs.common.utils;
|
|
import cc.mrbird.febs.common.exception.FebsException;
|
import cn.hutool.core.util.StrUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Objects;
|
|
/**
|
* 实体验证工具类
|
*/
|
public class ValidateEntityUtils {
|
|
/**
|
* 确保指定列的有效性，并返回相应的实体对象
|
* selectOne方法
|
* 此方法用于验证数据库中某列的值是否存在，并返回包含该值的实体对象
|
* 如果指定的值不存在或为null，将抛出异常
|
*
|
* @param valueToCheck 需要验证的值
|
* @param columnExtractor 列值提取器，用于指定需要验证的列
|
* @param queryWrapperExtractor 查询包装器提取器，用于执行数据库查询
|
* @param errMsg 错误消息格式字符串
|
* @param columnExtractors 可变参数（varargs）查询字段，可选，如果没有就是查询全部
|
* @param <T> 实体类类型
|
* @param <R> 列值类型
|
* @param <V> 需要验证的值的类型
|
* @return 返回包含指定列值的实体对象
|
* @throws IllegalArgumentException 如果需要验证的值为null
|
* @throws FebsException 如果查询结果为空或列值为null，或查询过程中发生异常
|
*/
|
public static <T, R, V> T ensureColumnReturnEntity(
|
V valueToCheck,
|
SFunction<T, R> columnExtractor,
|
SFunction<LambdaQueryWrapper<T>, T> queryWrapperExtractor,
|
String errMsg,
|
SFunction<T, R>... columnExtractors) {
|
|
// 检查输入参数是否为null
|
if (valueToCheck == null) {
|
throw new IllegalArgumentException("The value to check cannot be null while ensureColumnReturnEntity column");
|
}
|
if (columnExtractor == null || queryWrapperExtractor == null) {
|
throw new IllegalArgumentException("Column extractor and query wrapper extractor cannot be null while ensureColumnReturnEntity column");
|
}
|
|
T entity = null;
|
try {
|
// 创建LambdaQueryWrapper并配置查询条件
|
LambdaQueryWrapper<T> wrapper = Wrappers.lambdaQuery();
|
if (columnExtractors != null && columnExtractors.length > 0) {
|
wrapper.select(columnExtractors);
|
}
|
wrapper.eq(columnExtractor, valueToCheck)
|
.last("limit 1");
|
|
// 执行查询并获取结果实体
|
entity = queryWrapperExtractor.apply(wrapper);
|
|
// 如果查询结果为空，则抛出异常
|
if (entity == null) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
|
// 提取查询结果中的列值
|
R columnValue = columnExtractor.apply(entity);
|
// 如果列值为null，则抛出异常
|
if (columnValue == null) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
|
} catch (FebsException e) {
|
// 记录异常日志
|
throw e;
|
} catch (Exception e) {
|
// 记录异常日志
|
throw new FebsException(StrUtil.format("An error occurred while ensuring column return entity: {}", valueToCheck));
|
}
|
|
// 返回查询到的实体类对象
|
return entity;
|
}
|
|
/**
|
* 确保指定列的有效性，并返回相应的实体对象列表
|
* selectList方法
|
* 此方法用于验证数据库中某列的值是否存在，并返回包含该值的实体对象列表
|
* 如果指定的值不存在或为null，将抛出异常
|
*
|
* @param valueToCheck 需要验证的值
|
* @param columnExtractor 列值提取器，用于指定需要验证的列
|
* @param queryWrapperExtractor 查询包装器提取器，用于执行数据库查询
|
* @param errMsg 错误消息格式字符串
|
* @param columnExtractors 可变参数（varargs）查询字段，可选，如果没有就是查询全部
|
* @param <T> 实体类类型
|
* @param <R> 列值类型
|
* @param <V> 需要验证的值的类型
|
* @return 返回包含指定列值的实体对象列表
|
* @throws IllegalArgumentException 如果需要验证的值为null
|
* @throws FebsException 如果查询结果为空或列值为null，或查询过程中发生异常
|
*/
|
public static <T, R, V> List<T> ensureColumnReturnEntityList(
|
V valueToCheck,
|
SFunction<T, R> columnExtractor,
|
SFunction<LambdaQueryWrapper<T>, List<T>> queryWrapperExtractor,
|
String errMsg,
|
SFunction<T, R>... columnExtractors) {
|
// 检查需要验证的值是否为null
|
if (valueToCheck == null) {
|
throw new IllegalArgumentException("The value to check cannot be null while ensureColumnReturnEntityList column");
|
}
|
List<T> entities = new ArrayList<>();
|
try {
|
// 创建LambdaQueryWrapper并配置查询条件
|
LambdaQueryWrapper<T> wrapper = Wrappers.lambdaQuery();
|
if (columnExtractors != null && columnExtractors.length > 0) {
|
wrapper.select(columnExtractors);
|
}
|
wrapper.eq(columnExtractor, valueToCheck);
|
|
// 执行查询并获取结果实体列表
|
entities = queryWrapperExtractor.apply(wrapper);
|
} catch (Exception e) {
|
// 记录异常日志
|
throw new FebsException(StrUtil.format("An error occurred while ensureColumnReturnEntityList column: {}", valueToCheck));
|
}
|
// 如果查询结果为空，则抛出异常
|
if (entities == null || entities.isEmpty()) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
|
// 返回查询到的实体类对象列表
|
return entities;
|
}
|
|
/**
|
* 确保指定列的值在数据库中是存在的
|
* selectOne方法
|
* 该方法通过查询数据库来验证给定的列值是否存在如果不存在，则抛出异常
|
*
|
* @param valueToCheck 需要验证的列值
|
* @param columnExtractor 用于提取实体类中列值的函数式接口
|
* @param queryWrapperExtractor 用于构建查询条件并返回实体类的函数式接口
|
* @param errMsg 当列值无效时抛出的异常消息格式字符串
|
* @throws IllegalArgumentException 如果需要验证的值为null
|
* @throws FebsException 如果在数据库中找不到指定的列值或列值为null，或者在查询过程中发生异常
|
*/
|
public static <T, R, V> void ensureColumnValid(
|
V valueToCheck,
|
SFunction<T, R> columnExtractor,
|
SFunction<LambdaQueryWrapper<T>, T> queryWrapperExtractor,
|
String errMsg) {
|
// 检查需要验证的值是否为null
|
if (valueToCheck == null) {
|
throw new IllegalArgumentException("The value to check cannot be null while ensureColumnValid column");
|
}
|
|
try {
|
// 创建LambdaQueryWrapper并配置查询条件
|
LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
|
wrapper.select(columnExtractor)
|
.eq(columnExtractor, valueToCheck)
|
.last("limit 1");
|
|
// 执行查询并获取结果实体
|
T entity = queryWrapperExtractor.apply(wrapper);
|
// 如果查询结果为空，则抛出异常
|
if (entity == null) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
|
// 提取查询结果中的列值
|
R columnValue = columnExtractor.apply(entity);
|
// 如果列值为null，则抛出异常
|
if (columnValue == null) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
} catch (Exception e) {
|
// 记录异常日志
|
throw new FebsException(e.getMessage());
|
}
|
}
|
|
/**
|
* 确保指定值在数据库中是唯一的
|
* selectCount方法
|
* 该方法通过查询数据库来验证给定的列值是否已经存在,如果存在，则抛出异常，以确保数据的唯一性
|
*
|
* @param valueToCheck 需要检查的值
|
* @param columnExtractor 用于提取实体类字段的函数式接口
|
* @param countWrapperExtractor 用于获取查询条件包装器中记录数的函数式接口
|
* @param errMsg 错误消息模板，当值不唯一时使用
|
* @param <T> 实体类类型
|
* @param <R> 字段类型
|
* @param <V> 需要检查的值的类型
|
* @throws IllegalArgumentException 如果需要检查的值为null，则抛出此异常
|
* @throws FebsException 如果值已存在或在检查过程中发生错误，则抛出此异常
|
*/
|
public static <T, R, V> void ensureUnique(
|
V valueToCheck,
|
SFunction<T, R> columnExtractor,
|
SFunction<LambdaQueryWrapper<T>, Integer> countWrapperExtractor,
|
String errMsg) {
|
// 检查输入值是否为null，如果为null，则抛出IllegalArgumentException异常
|
if (valueToCheck == null) {
|
throw new IllegalArgumentException("The value to check cannot be null while ensureUnique column");
|
}
|
if (columnExtractor == null) {
|
throw new IllegalArgumentException("The columnExtractor cannot be null while ensureUnique column");
|
}
|
if (countWrapperExtractor == null) {
|
throw new IllegalArgumentException("The countWrapperExtractor cannot be null while ensureUnique column");
|
}
|
|
int count = 0;
|
try {
|
// 创建LambdaQueryWrapper对象，用于构建查询条件
|
LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
|
// 添加等于条件，检查的字段=需要检查的值
|
wrapper.eq(columnExtractor, valueToCheck);
|
// 执行查询并获取结果数量
|
count = countWrapperExtractor.apply(wrapper);
|
|
} catch (Exception e) {
|
// 记录异常日志
|
throw new FebsException(StrUtil.format("An error occurred while ensureUnique column: {}", valueToCheck));
|
}
|
|
// 如果结果数量大于0，说明值已存在，抛出FebsException异常
|
if (count > 0) {
|
throw new FebsException(StrUtil.format(errMsg, valueToCheck));
|
}
|
}
|
|
|
/**
|
* 确保两个参数相等，如果不相等则抛出异常
|
*
|
* @param value1 第一个参数
|
* @param value2 第二个参数
|
* @param errMsg 当两个参数不相等时抛出的异常消息格式字符串
|
* @throws FebsException 如果两个参数不相等
|
*/
|
public static <T> void ensureEqual(
|
T value1,
|
T value2,
|
String errMsg) {
|
// 使用 Objects.equals 处理 null 值，避免显式 null 检查
|
if (!Objects.equals(value1, value2)) {
|
// 延迟字符串格式化，只在需要抛出异常时进行
|
throw new FebsException(StrUtil.format(errMsg, value1, value2));
|
}
|
}
|
|
|
/**
|
* 确保两个参数不相等，如果相等则抛出异常
|
*
|
* @param value1 第一个参数
|
* @param value2 第二个参数
|
* @param errMsg 当两个参数相等时抛出的异常消息格式字符串
|
* @throws FebsException 如果两个参数相等
|
*/
|
public static <T> void ensureNotEqual(
|
T value1,
|
T value2,
|
String errMsg) {
|
// 使用 Objects.equals 处理 null 值，避免显式 null 检查
|
if (Objects.equals(value1, value2)) {
|
// 延迟字符串格式化，只在需要抛出异常时进行
|
throw new FebsException(StrUtil.format(errMsg, value1, value2));
|
}
|
}
|
|
|
}
|
