自定义注解_切面_反射_策略模式进行入参比较校验

忆嫚

已于 2024-09-08 04:12:11 修改

阅读量792

点赞数 9

分类专栏：自定义注解+切面+策略模式+反射的综合使用文章标签：策略模式 java 架构 log4j 程序人生

于 2024-09-08 03:41:05 首次发布

本文链接：https://blog.csdn.net/leishangdangqiq/article/details/142007614

版权

自定义注解+切面+策略模式+反射的综合使用专栏收录该内容

1 篇文章 0 订阅

订阅专栏

自定义复合注解|切面|反射|策略模式校验入参 <a表中x字段单价之和是否大于b表中的y字段总金额>大于就进行拦截并且返回提示 (后续可以增加其他校验格式如：加减乘除），使用了策略模式后面可以增加校验类型：加减乘除等类型的校验，使用策略工厂模式在有很多表需要校验时减少if结构，使用自定义可以指定主表要校验的字段与关联表要校验的字段与使用切面在方法执行前拦截

0. 基础配置-工具类|异常|字典

0.1. 通过反射获取要比较的字段值

/**
 * 比较的工具类
 *
 * @Author LiZhiMin
 * @Date 2024/9/3 10:59
 */

public class CompareUtil {
    /**
     * 获取指定对象的字段值。
     * <p>
     * 根据给定的字段名称，从对象中提取字段值。
     * </p>
     *
     * @param clazz     对象的类类型。
     * @param instance  对象实例。
     * @param fieldName 字段名称。
     * @return 字段的值。
     * @throws NoSuchFieldException   如果指定字段不存在。
     * @throws IllegalAccessException 如果无法访问字段。
     */
    public static BigDecimal getFieldValue(Class<?> clazz, Object instance, String fieldName) throws NoSuchFieldException, IllegalAccessException {
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        return (BigDecimal) field.get(instance);
    }
}

0.2.异常的常量

/**
 * scrm 错误码枚举类
 *
 * scrm 系统，使用 1_099_000_000 段
 * @Author LiZhiMin
 * @Date 2024/5/15 18:23
 */

public interface ErrorCodeConstants {
    //比较报错信息
    ErrorCode COMPARE_ORDER_RECEIVABLE = new ErrorCode(2_099_666_001, "已经存在的回款金额：【{}】 + 你填写的金额：【{}】 = 【{}】，不能大于订单总金额：【{}】，你最大能填写的金额为：【{}】");

    ErrorCode COMPARE_ORDER_INVOICES = new ErrorCode(2_099_666_002, "已经存在的发票金额：【{}】 + 你填写的金额：【{}】= 【{}】，不能大于订单总金额：【{}】，你最大能填写的金额为：【{}】");

    ErrorCode COMPARE_STRATEGY_TYPE = new ErrorCode(2_099_666_003, "找不到这个策略类型：{}");

    ErrorCode COMPARE_STRATEGY_TYPE_NOT_NULL = new ErrorCode(2_099_666_004, "策略类型不能为空，请联系管理员");


}

0.3.字典类

/**
 * CRM 业务类型枚举
 *
 * @author HUIHUI
 */
@RequiredArgsConstructor
@Getter
public enum CrmBizTypeEnum implements IntArrayValuable {

    CRM_CLUE(1, "线索"),
    CRM_CUSTOMER(2, "客户"),
    CRM_CONTACT(3, "联系人"),
    CRM_BUSINESS(4, "商机"),
    CRM_CONTRACT(5, "合同"),
    CRM_PRODUCT(6, "产品"),
    CRM_RECEIVABLE(7, "回款"),
    CRM_RECEIVABLE_PLAN(8, "回款计划"),
    CRM_ORDER(9, "订单"),
    CRM_INVOICE(10, "发票"),
    CRM_REFUND(11, "退款"),
    ;

    public static final int[] ARRAYS = Arrays.stream(values()).mapToInt(CrmBizTypeEnum::getType).toArray();

    /**
     * 类型
     */
    private final Integer type;
    /**
     * 名称
     */
    private final String name;

    public static String getNameByType(Integer type) {
        CrmBizTypeEnum typeEnum = CollUtil.findOne(CollUtil.newArrayList(CrmBizTypeEnum.values()),
                item -> ObjUtil.equal(item.type, type));
        return typeEnum == null ? null : typeEnum.getName();
    }

    @Override
    public int[] array() {
        return ARRAYS;
    }

}

0.4、异常工具类

/**
 * {@link ServiceException} 工具类
 *
 * 目的在于，格式化异常信息提示。
 * 考虑到 String.format 在参数不正确时会报错，因此使用 {} 作为占位符，并使用 {@link #doFormat(int, String, Object...)} 方法来格式化
 *
 * 因为 {@link #MESSAGES} 里面默认是没有异常信息提示的模板的，所以需要使用方自己初始化进去。目前想到的有几种方式：
 *
 * 1. 异常提示信息，写在枚举类中，例如说，cn.iocoder.oceans.user.api.constants.ErrorCodeEnum 类 + ServiceExceptionConfiguration
 * 2. 异常提示信息，写在 .properties 等等配置文件
 * 3. 异常提示信息，写在 Apollo 等等配置中心中，从而实现可动态刷新
 * 4. 异常提示信息，存储在 db 等等数据库中，从而实现可动态刷新
 */
@Slf4j
public class ServiceExceptionUtil {

    /**
     * 错误码提示模板
     */
    private static final ConcurrentMap<Integer, String> MESSAGES = new ConcurrentHashMap<>();

    public static void putAll(Map<Integer, String> messages) {
        ServiceExceptionUtil.MESSAGES.putAll(messages);
    }

    public static void put(Integer code, String message) {
        ServiceExceptionUtil.MESSAGES.put(code, message);
    }

    public static void delete(Integer code, String message) {
        ServiceExceptionUtil.MESSAGES.remove(code, message);
    }

    // ========== 和 ServiceException 的集成 ==========

    public static ServiceException exception(ErrorCode errorCode) {
        String messagePattern = MESSAGES.getOrDefault(errorCode.getCode(), errorCode.getMsg());
        return exception0(errorCode.getCode(), messagePattern);
    }

    public static ServiceException exception(ErrorCode errorCode, Object... params) {
        String messagePattern = MESSAGES.getOrDefault(errorCode.getCode(), errorCode.getMsg());
        return exception0(errorCode.getCode(), messagePattern, params);
    }

    /**
     * 创建指定编号的 ServiceException 的异常
     *
     * @param code 编号
     * @return 异常
     */
    public static ServiceException exception(Integer code) {
        return exception0(code, MESSAGES.get(code));
    }

    /**
     * 创建指定编号的 ServiceException 的异常
     *
     * @param code 编号
     * @param params 消息提示的占位符对应的参数
     * @return 异常
     */
    public static ServiceException exception(Integer code, Object... params) {
        return exception0(code, MESSAGES.get(code), params);
    }

    public static ServiceException exception0(Integer code, String messagePattern, Object... params) {
        String message = doFormat(code, messagePattern, params);
        return new ServiceException(code, message);
    }

    public static ServiceException invalidParamException(String messagePattern, Object... params) {
        return exception0(GlobalErrorCodeConstants.BAD_REQUEST.getCode(), messagePattern, params);
    }

    // ========== 格式化方法 ==========

    /**
     * 将错误编号对应的消息使用 params 进行格式化。
     *
     * @param code           错误编号
     * @param messagePattern 消息模版
     * @param params         参数
     * @return 格式化后的提示
     */
    @VisibleForTesting
    public static String doFormat(int code, String messagePattern, Object... params) {
        StringBuilder sbuf = new StringBuilder(messagePattern.length() + 50);
        int i = 0;
        int j;
        int l;
        for (l = 0; l < params.length; l++) {
            j = messagePattern.indexOf("{}", i);
            if (j == -1) {
                log.error("[doFormat][参数过多：错误码({})|错误内容({})|参数({})", code, messagePattern, params);
                if (i == 0) {
                    return messagePattern;
                } else {
                    sbuf.append(messagePattern.substring(i));
                    return sbuf.toString();
                }
            } else {
                sbuf.append(messagePattern, i, j);
                sbuf.append(params[l]);
                i = j + 2;
            }
        }
        if (messagePattern.indexOf("{}", i) != -1) {
            log.error("[doFormat][参数过少：错误码({})|错误内容({})|参数({})", code, messagePattern, params);
        }
        sbuf.append(messagePattern.substring(i));
        return sbuf.toString();
    }

}

0.5、错误码对象

/**
 * 错误码对象
 *
 * 全局错误码，占用 [0, 999], 参见 {@link GlobalErrorCodeConstants}
 * 业务异常错误码，占用 [1 000 000 000, +∞)，参见 {@link ServiceErrorCodeRange}
 *
 * TODO 错误码设计成对象的原因，为未来的 i18 国际化做准备
 */
@Data
public class ErrorCode {

    /**
     * 错误码
     */
    private final Integer code;
    /**
     * 错误提示
     */
    private final String msg;

    public ErrorCode(Integer code, String message) {
        this.code = code;
        this.msg = message;
    }

}

0.6、全局错误码枚举

**
 * 全局错误码枚举
 * 0-999 系统异常编码保留
 *
 * 一般情况下，使用 HTTP 响应状态码 https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status
 * 虽然说，HTTP 响应状态码作为业务使用表达能力偏弱，但是使用在系统层面还是非常不错的
 * 比较特殊的是，因为之前一直使用 0 作为成功，就不使用 200 啦。
 *
 * @author 芋道源码
 */
public interface GlobalErrorCodeConstants {

    ErrorCode SUCCESS = new ErrorCode(0, "成功");

    // ========== 客户端错误段 ==========

    ErrorCode BAD_REQUEST = new ErrorCode(400, "请求参数不正确");
    ErrorCode UNAUTHORIZED = new ErrorCode(401, "账号未登录");
    ErrorCode FORBIDDEN = new ErrorCode(403, "没有该操作权限");
    ErrorCode NOT_FOUND = new ErrorCode(404, "请求未找到");
    ErrorCode METHOD_NOT_ALLOWED = new ErrorCode(405, "请求方法不正确");
    ErrorCode LOCKED = new ErrorCode(423, "请求失败，请稍后重试"); // 并发请求，不允许
    ErrorCode TOO_MANY_REQUESTS = new ErrorCode(429, "请求过于频繁，请稍后重试");

    // ========== 服务端错误段 ==========

    ErrorCode INTERNAL_SERVER_ERROR = new ErrorCode(500, "系统异常");
    ErrorCode NOT_IMPLEMENTED = new ErrorCode(501, "功能未实现/未开启");
    ErrorCode ERROR_CONFIGURATION = new ErrorCode(502, "错误的配置项");

    // ========== 自定义错误段 ==========
    ErrorCode REPEATED_REQUESTS = new ErrorCode(900, "重复请求，请稍后重试"); // 重复请求
    ErrorCode DEMO_DENY = new ErrorCode(901, "演示模式，禁止写操作");

    ErrorCode UNKNOWN = new ErrorCode(999, "未知错误");

}

1.定义复合注解

/**
 * 自定义注解类处理器复合注解
 * 比较a表中x字段值是否大于b表中y字段值
 *
 * @Author LiZhiMin
 * @Date 2024/8/31 17:34
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldCompareValidators {

    /**
     * 要查询的主表的类型 {@link CrmBizTypeEnum#getType()}
     */
    CrmBizTypeEnum foreignKeyType() default CrmBizTypeEnum.CRM_RECEIVABLE;

    /**
     * 要查询的主表的字段名字
     */
    FieldNameType foreignKeyFieldName() default FieldNameType.SCRM_PRICE;


    //要校验的注解多个
    FieldCompareValidator[] fieldCompareValidator();

    String message() default "";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

1.1.定义子注解

/**
 * 自定义注解类处理器
 * 比较a表中x字段值是否大于b表中y字段值
 *
 * @Author LiZhiMin
 * @Date 2024/8/21 12:18
 */

@Retention(RetentionPolicy.RUNTIME)// 指定注解的生命周期是运行时
@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})// 指定注解可以使用的位置
public @interface FieldCompareValidator {

    /**
     * 默认错误提示信息
     */
    String message() default "金额不能大于订单总金额！";


    /**
     * 要查询的外键表的类型  {@link CrmBizTypeEnum#getType()}
     */
    CrmBizTypeEnum majorJeyType() default CrmBizTypeEnum.CRM_ORDER;

    /**
     * 要查询的外键表的字段名字
     */
    FieldNameType majorJeyFieldName() default FieldNameType.SCRM_ORDER_TOTAL_MONEY;


}

1.2.使用复合注解在接口上面

@PostMapping("/create")
    @Operation(summary = "创建发票")
    @PreAuthorize("@ss.hasPermission('scrm:invoice:create')")
    @FieldCompareValidators( foreignKeyType = CrmBizTypeEnum.CRM_INVOICE,foreignKeyFieldName = FieldNameType.SCRM_PRICE,fieldCompareValidator = {
            @FieldCompareValidator(majorJeyType = CrmBizTypeEnum.CRM_ORDER,majorJeyFieldName = FieldNameType.SCRM_ORDER_TOTAL_MONEY,message = "金额限制")
    })
    public CommonResult<Long> createInvoice(@Valid @RequestBody InvoiceSaveReqVO createReqVO) {
        return success(invoiceService.createInvoice(createReqVO));
    }

2.定义一个切面在切面中拦截注解在方法执行之前执行，并且编写功能

/**
 * 处理字段比较验证的切面类。
 * <p>
 * 该类是一个切面类，用于在方法执行之前，基于自定义注解 {@link FieldCompareValidators} 提供的配置信息，
 * 执行字段比较验证逻辑。通过切面技术，实现了在运行时动态地插入验证逻辑，从而增强系统的灵活性和可维护性。
 * </p>
 *
 * @Author LiZhiMin
 * @Date 2024/8/31 17:38
 */
@Aspect
@Component
@Slf4j
public class FieldCompareValidatorAspect {

    @Autowired
    private CompareStrategyFactory compareStrategyFactory;

    /**
     * 切点方法，用于在被 {@link FieldCompareValidators} 注解标记的方法执行之前触发。
     * <p>
     * 从注解中提取字段比较配置，并根据这些配置选择并执行相应的比较策略。
     * 该方法获取方法参数，提取比较需要的字段信息，并通过 {@link CompareStrategyFactory} 获取对应的比较策略进行验证。
     * </p>
     *
     * @param joinPoint              连接点，提供了方法执行的信息和上下文。
     * @param fieldCompareValidators 自定义注解 {@link FieldCompareValidators}，提供字段比较的配置信息。
     */
    @Before("@annotation(fieldCompareValidators)")
    public void pointcut(JoinPoint joinPoint, FieldCompareValidators fieldCompareValidators) {
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        // 从注解中提取主表枚举类型
        CrmBizTypeEnum crmBizTypeEnumForeignKey = fieldCompareValidators.foreignKeyType();
        // 获取要查询的主表字段名
        String foreignKeyFieldName = fieldCompareValidators.foreignKeyFieldName().getFieldName();

        // 遍历所有字段比较验证配置
        for (FieldCompareValidator compareValidator : fieldCompareValidators.fieldCompareValidator()) {
            // 获取比较字段名和关联表枚举类型
            String majorKeyFieldName = compareValidator.majorJeyFieldName().getFieldName();
            CrmBizTypeEnum crmBizTypeEnumMajorKey = compareValidator.majorJeyType();

            // 从工厂获取对应的比较策略
            CompareStrategy strategy = compareStrategyFactory.getStrategy(crmBizTypeEnumForeignKey, crmBizTypeEnumMajorKey);

            if (strategy != null) {
                // 执行策略进行字段比较验证
                strategy.handle(args[0], foreignKeyFieldName, majorKeyFieldName);
            } else {
                // 如果未找到对应的策略，则抛出异常
                throw exception(COMPARE_STRATEGY_TYPE_NOT_NULL);
            }
        }
    }
}

3.定义一个策略接口

/**
 * 比较策略接口，定义了所有比较策略的通用行为。
 * <p>
 * 实现这个接口的策略类将具体定义如何处理给定的请求对象。
 * 未来可以扩展该接口，以支持更多类型的运算，如加减乘除等..。
 * </p>
 *
 * @Author LiZhiMin
 * @Date 2024/9/3 10:44
 */

public interface CompareStrategy {

    /**
     * 处理比较策略的核心方法。
     * <p>
     * 实现该方法的策略类需要根据具体的业务逻辑来处理请求对象。
     * </p>
     *
     * @param request             请求对象，通常是需要进行比较或校验的数据。
     * @param foreignKeyFieldName 外部业务类型字段名称，用于标识外部系统的数据字段。
     * @param majorKeyFieldName   主要业务类型字段名称，用于标识主要系统的数据字段。
     */
    void handle(Object request, String foreignKeyFieldName, String majorKeyFieldName);
}

4.实现策略类实现不同类型对应不同功能

4.1.策略实现方式一

/**
 * 实现了 CompareStrategy 接口，用于处理订单和发票金额比较的逻辑。
 * 主要功能包括验证发票总金额是否超过订单金额，以及计算现有发票总金额。
 *
 * @Author LiZhiMin
 * @Date 2024/9/3 12:15
 */
@Component
public class OrderInvoiceStrategyImpl implements CompareStrategy {
    @Resource
    private InvoiceMapper invoiceMapper;

    @Resource
    private OrderMapper orderMapper;

    /**
     * 处理 {@link InvoiceSaveReqVO} 类型的数据。
     * <p>
     * 获取订单信息、计算主键字段的值和外表字段的值，比较主表已存在的应收金额与新增的应收金额是否符合预期。
     * </p>
     *
     * @param request             请求对象，必须是 {@link InvoiceSaveReqVO} 类型。
     * @param foreignKeyFieldName 外部业务类型字段名称，用于标识应收表中的字段。
     * @param majorKeyFieldName   主要业务类型字段名称，用于标识订单表中的字段。
     */
    @Override
    public void handle(Object request, String foreignKeyFieldName, String majorKeyFieldName) {
        if (request instanceof InvoiceSaveReqVO) {
            // 处理 ReceivableSaveReqVO 类型的数据
            processSaveReqVoByType(request, foreignKeyFieldName, majorKeyFieldName);
        } else {
            throw exception(COMPARE_STRATEGY_TYPE, request.getClass().getName());
        }
    }

    /**
     * 处理 InvoiceSaveReqVO 类型的数据，进行金额比较和验证。
     *
     * @param objVo               请求对象，应为 InvoiceSaveReqVO 类型
     * @param foreignKeyFieldName 发票对象中的字段名
     * @param majorJeyFieldName   订单对象中的主要字段名
     */
    private void processSaveReqVoByType(Object objVo, String foreignKeyFieldName, String majorJeyFieldName) {
        try {
            InvoiceSaveReqVO vo = (InvoiceSaveReqVO) objVo;
            // 获取订单信息
            OrderDO orderDO = orderMapper.selectById(vo.getOrderId());

            // 计算主键字段的值
            BigDecimal foreignKeyFieldValue = getFieldValue(InvoiceSaveReqVO.class, vo, foreignKeyFieldName);

            // 计算外表字段的值-总金额
            BigDecimal totalMoneyMajorKeyFieldValue = getFieldValue(OrderDO.class, orderDO, majorJeyFieldName);

            // 计算主表已存在的应收金额
            BigDecimal totalPriceSum = getTotalInvoicePrice(vo.getOrderId(), foreignKeyFieldName);

            // 加上新增的应收金额
            BigDecimal totalPrice = totalPriceSum.add(foreignKeyFieldValue);

            // 比较总金额与订单金额，如果超出则抛出异常
            if (totalPrice.compareTo(totalMoneyMajorKeyFieldValue) > 0) {
                throw exception(COMPARE_ORDER_INVOICES, totalPriceSum, foreignKeyFieldValue, totalPrice, totalMoneyMajorKeyFieldValue, totalMoneyMajorKeyFieldValue.subtract(totalPriceSum));
            }

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 计算指定订单的总发票金额。
     *
     * @param orderId             订单 ID
     * @param foreignKeyFieldName 外键字段名
     * @return 总发票金额
     */
    private BigDecimal getTotalInvoicePrice(Long orderId, String foreignKeyFieldName) {
        List<InvoiceDO> list = invoiceMapper.selectList(InvoiceDO::getOrderId, orderId);
        return list.stream().map(invoiceDO -> {
            try {
                return getFieldValue(InvoiceDO.class, invoiceDO, foreignKeyFieldName);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
                return BigDecimal.ZERO; // 返回零值以避免异常中断流
            }
        }).reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

4.2.策略实现方式二

/**
 * 处理订单应收金额比较策略的实现类。
 * <p>
 * 该类实现了 {@link CompareStrategy} 接口，专门用于处理与应收金额相关的比较逻辑。
 * 在处理请求时，会检查请求对象的类型，并根据业务逻辑计算应收金额是否符合预期。
 * </p>
 *
 * @Author LiZhiMin
 * @Date 2024/9/3 10:47
 */
@Component
public class OrderReceivableStrategyImpl implements CompareStrategy {
    @Resource
    private ReceivableMapper receivableMapper;

    @Resource
    private OrderMapper orderMapper;

    /**
     * 处理比较策略的核心方法。
     * <p>
     * 检查请求对象的类型是否为 {@link ReceivableSaveReqVO}，并将其委托给相应的方法进行处理。
     * 如果请求对象类型不符合要求，则抛出异常。
     * </p>
     *
     * @param request             请求对象，通常是 {@link ReceivableSaveReqVO} 类型的数据。
     * @param foreignKeyFieldName 外部业务类型字段名称，用于标识应收表中的字段。
     * @param majorKeyFieldName   主要业务类型字段名称，用于标识订单表中的字段。
     */
    @Override
    public void handle(Object request, String foreignKeyFieldName, String majorKeyFieldName) {
        if (request instanceof ReceivableSaveReqVO) {
            // 处理 ReceivableSaveReqVO 类型的数据
            processSaveReqVoByType(request, foreignKeyFieldName, majorKeyFieldName);
        } else {
            throw exception(COMPARE_STRATEGY_TYPE, request.getClass().getName());
        }
    }

    /**
     * 处理 {@link ReceivableSaveReqVO} 类型的数据。
     * <p>
     * 获取订单信息、计算主键字段的值和外表字段的值，比较主表已存在的应收金额与新增的应收金额是否符合预期。
     * </p>
     *
     * @param objVo               请求对象，必须是 {@link ReceivableSaveReqVO} 类型。
     * @param foreignKeyFieldName 外部业务类型字段名称，用于标识应收表中的字段。
     * @param majorJeyFieldName   主要业务类型字段名称，用于标识订单表中的字段。
     */
    private void processSaveReqVoByType(Object objVo, String foreignKeyFieldName, String majorJeyFieldName) {
        try {
            ReceivableSaveReqVO vo = (ReceivableSaveReqVO) objVo;
            // 获取订单信息
            OrderDO orderDO = orderMapper.selectById(vo.getOrderId());

            // 计算主键字段的值
            BigDecimal foreignKeyFieldValue = getFieldValue(ReceivableSaveReqVO.class, vo, foreignKeyFieldName);

            // 计算外表字段的值-总金额
            BigDecimal totalMoneyMajorKeyFieldValue = getFieldValue(OrderDO.class, orderDO, majorJeyFieldName);

            // 计算主表已存在的应收金额
            BigDecimal totalPriceSum = getTotalReceivablePrice(vo.getOrderId(), foreignKeyFieldName);

            // 加上新增的应收金额
            BigDecimal totalPrice = totalPriceSum.add(foreignKeyFieldValue);

            // 比较金额，若总金额大于订单金额，则抛出异常
            if (totalPrice.compareTo(totalMoneyMajorKeyFieldValue) > 0) {
                throw exception(COMPARE_ORDER_RECEIVABLE, totalPriceSum, foreignKeyFieldValue, totalPrice, totalMoneyMajorKeyFieldValue, totalMoneyMajorKeyFieldValue.subtract(totalPriceSum));
            }

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 计算主表总的应收金额。
     * <p>
     * 查询所有与给定订单 ID 关联的应收记录，并计算所有记录中指定字段的总金额。
     * </p>
     *
     * @param orderId             订单 ID，用于查询应收记录。
     * @param foreignKeyFieldName 外部业务类型字段名称，用于标识应收表中的字段。
     * @return 主表总的应收金额。
     */
    private BigDecimal getTotalReceivablePrice(Long orderId, String foreignKeyFieldName) {
        List<ReceivableDO> list = receivableMapper.selectList(ReceivableDO::getOrderId, orderId);
        return list.stream().map(receivableDO -> {
            try {
                return getFieldValue(ReceivableDO.class, receivableDO, foreignKeyFieldName);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
                return BigDecimal.ZERO; // 返回零值以避免异常中断流
            }
        }).reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

5、定义策略工厂类编写方法在程序启动时注入不同的策略

/**
 * @Author LiZhiMin
 * 比较策略工厂类，用于管理和检索不同的 {@link CompareStrategy} 实例。
 * <p>
 * 该类作为一个策略注册中心，将不同的比较策略根据业务类型对进行存储和管理。
 * 通过这个工厂类，可以根据业务类型对获取对应的比较策略实例。
 * </p>
 * @Date 2024/9/3 10:50
 */
@Component
public class CompareStrategyFactory {

    /**
     * 存储比较策略的映射表。
     * <p>
     * 这个映射表的键是一个 {@link Pair} 对象，表示主要业务类型和外部业务类型的组合。
     * 值是对应的 {@link CompareStrategy} 实例。
     * </p>
     */
    private final Map<Pair<CrmBizTypeEnum, CrmBizTypeEnum>, CompareStrategy> strategyFactory = new HashMap<>();

    /**
     * 构造函数，初始化工厂并注册策略。
     * <p>
     * 通过传入的策略列表，遍历每一个策略实例，并将其注册到工厂中。
     * 策略的注册是基于其具体实现类型来进行的。
     * </p>
     *
     * @param strategyList 需要注册的 {@link CompareStrategy} 实例列表。
     */
    @Autowired
    public CompareStrategyFactory(List<CompareStrategy> strategyList) {
        for (CompareStrategy strategy : strategyList) {
            // 将处理器注册到工厂中（可以根据需要调整键的类型）
            if (strategy instanceof OrderReceivableStrategyImpl) {
                strategyFactory.put(Pair.of(CrmBizTypeEnum.CRM_RECEIVABLE, CrmBizTypeEnum.CRM_ORDER), strategy);
            } else if (strategy instanceof OrderInvoiceStrategyImpl) {
                strategyFactory.put(Pair.of(CrmBizTypeEnum.CRM_INVOICE, CrmBizTypeEnum.CRM_ORDER), strategy);
            }
        }
    }

    /**
     * 根据主要业务类型和外部业务类型获取对应的比较策略实例。
     * <p>
     * 根据提供的主要业务类型和外部业务类型从工厂中查找并返回相应的 {@link CompareStrategy} 实例。
     * </p>
     *
     * @param majorKey   主要业务类型。
     * @param foreignKey 外部业务类型。
     * @return 对应的 {@link CompareStrategy} 实例，如果未找到则返回 {@code null}。
     */
    public CompareStrategy getStrategy(CrmBizTypeEnum majorKey, CrmBizTypeEnum foreignKey) {
        return strategyFactory.get(Pair.of(majorKey, foreignKey));
    }
}

6.使用注意事项

6.1.注解使用注意事项

6.2.具体策略类中的mapper层换成自己的

6.3.策略工厂以及策略类与spring管理bean的注意事项

6.4.如果不适用芋道的springcloud框架，那项目得继承mabatis-plu或者将查询数据的方法改为自己项目使用的

个人博客园首页

7.编写时参考的博客

7.1.策略模式
https://www.cnblogs.com/satire/p/14620980.html
7.2.反射
https://juejin.cn/post/6987191491638591502
7.3.自定义复合注解
https://blog.csdn.net/qq_41378597/article/details/102934784
7.4.切面
https://www.cnblogs.com/wzh2010/p/15886644.html