用设计模式重构核心业务代码的一次实战

引言

在软件开发中，我们经常遇到这样的代码：一个方法包含了大量的业务逻辑，代码冗长、难以维护、难以扩展。特别是对于核心业务模块，如果经常需要改动，那么代码的组织和设计就显得尤为重要。

本文通过一个真实的业务场景，展示了如何运用设计模式来重构复杂的业务代码，同时保持100%的功能一致性。

业务场景介绍

在大多数的连锁店店里，店里的店员都需要做一个动作，就是【订货】。而订货是需要通过订货模版的，比如水果订货模版，小器具订货模版，临时订货模版等等。 但你也不能每时每刻都让店员去订货，背后里需要有一套规则去展示订货模版列表的信息。以便让订货模版在适当的时候出现，又在适当的时候消失。

订货模版列表展示这个模块，经常需要变动。原因只有一个，订货是门店最重要的步骤，订多了或者订少了，给企业带来的都是亏损。因此跟订货模块有关的相关模块， 就一直有业务需求。

这个模块从24年2月就做好了，到现在25年9月了，还一直在迭代需求。

下面是订货模版列表的重构细节，具体的类和方法，我做了一些脱敏和抽象化处理了，不过不影响了解里面的设计思路。

问题分析

原始代码的复杂性

在某个业务管理系统中，有一个核心方法 getBusinessItemList，负责获取业务项目列表。让我们先看看这个方法的复杂性：

private List<BusinessItemVO> getBusinessItemList(GetBusinessItemQuery query) {
    // 1. 基础信息获取与验证 (5行)
    BusinessInfoDTO businessInfo = businessInfoClient.getBusinessInfo(query.getBusinessId());
    if (businessInfo == null) {
        throw BusinessException.of(ErrorEnum.NOT_FOUND.getCode(), "根据业务id:"+query.getBusinessId()+",获取不到业务信息");
    }
    
    // 2. 权限验证 (3行)
    if (businessHelper.isCurrentUserCanAccess(query.getUserId()) == false) {
        return Collections.emptyList();
    }
    
    // 3. 基础数据获取 (15行)
    List<BusinessRuleEntity> ruleList = businessRuleDomainService.getBusinessRuleByBusinessId(query.getBusinessId());
    // ... 更多数据获取逻辑
    
    // 4. 主循环处理 (100+行)
    for (BusinessItemEntity businessItem : businessItemList) {
        // 4.1 数据转换逻辑 (8行)
        // 4.2 空数据检查 (3行)
        // 4.3 业务规则过滤 (8行)
        // 4.4 特殊类型过滤 (12行)
        // 4.5 过期项目过滤 (15行)
        // 4.6 特殊场景处理 (12行)
        // 4.7 VO构建 (20行)
        // 4.8 特殊业务处理 (25行)
    }
}

问题深度分析

1. 单一职责原则违反

这个方法承担了太多职责：

• 数据获取：业务信息、规则数据、项目数据
• 权限控制：用户权限验证
• 业务过滤：多种业务规则过滤
• 数据处理：数据转换、VO构建
• 特殊处理：各种业务场景的特殊逻辑

2. 开闭原则违反

每次新增业务规则都需要修改主方法：

// 新增业务规则需要在这里添加
if (newBusinessRule.isApplicable(businessItem)) {
    if (!newBusinessRule.shouldShow(businessItem, query)) {
        continue;
    }
}

3. 代码可读性差

代码混合了多种业务逻辑，阅读和理解困难：

• 业务逻辑分散
• 条件判断嵌套复杂
• 变量命名不够清晰
• 注释不足

4. 测试困难

无法单独测试某个业务逻辑：

@Test
public void testGetBusinessItemList() {
    // 需要准备所有依赖，测试整个流程
    // 无法单独测试业务规则过滤逻辑
    // 无法单独测试特殊场景处理逻辑
}

设计模式选择：是否过度设计？

设计模式的使用原则

使用设计模式，会不会是过度设计呢？这个要看场景的。如果某个业务模块是属于核心模块，又经常需要改动，那么你就需要保证这段代码是经过设计和组织的，以确保它是稳定清晰的，易改易扩展。在这种情况下，就需要利用一些设计模式来组织一下代码。

另外，使用了设计模式后，它可以确保你的主流程是不变的。变化的东西，都由其他类或者方法来完成。

为什么选择这些设计模式？

基于业务特点，我们选择了以下设计模式：

1. Builder模式 - 解决VO构建复杂性问题
2. Chain of Responsibility模式 - 解决业务规则扩展性问题
3. Strategy模式 - 解决特殊处理逻辑扩展性问题

设计模式选择的思考过程

1. 识别问题模式

问题1：VO构建逻辑分散

// 原始代码：VO构建逻辑分散在主方法中
vo.setItemId(itemId);
vo.setItemName(...);
vo.setItemType(...);
vo.setItemStatus(...);
vo.setItemCategory(...);
// ... 20多个字段设置

问题2：过滤逻辑混乱

// 原始代码：所有过滤逻辑混在一起
if (businessItem.isSpecialType()) {
    if (!businessHelper.isShowSpecialTypeForToday(...)) {
        continue;
    }
}
if (businessHelper.isTemporaryItem(itemId)) {
    if (!businessHelper.isShowTemporaryItemForToday(...)) {
        continue;
    }
}

问题3：处理逻辑复杂

// 原始代码：特殊处理逻辑混在一起
if (businessItem.isSpecialType()) {
    // 特殊类型处理
    if (isSpecialConditionMet(...)) {
        vo.setSpecialFlag(...);
    }
}
if (businessHelper.isSpecialScenario(...) && expired) {
    // 特殊场景处理
    vo.setCanOperateFlag(false);
    vo.setSpecialStatus(...);
}

2. 选择合适的设计模式

Builder模式选择理由：

• VO构建逻辑复杂，有20多个字段需要设置
• 构建逻辑经常变动（新增字段、修改字段逻辑）
• 需要保证构建逻辑的一致性和可维护性

Chain of Responsibility模式选择理由：

• 业务规则经常变动（新增过滤条件、修改过滤逻辑）
• 不同业务规则之间相对独立
• 需要支持动态添加/移除业务规则
• 需要保证规则执行的优先级

Strategy模式选择理由：

• 特殊处理逻辑复杂且经常变动
• 不同处理逻辑之间相对独立
• 需要支持动态添加/移除处理逻辑
• 需要保证处理逻辑的可测试性

重构方案设计

整体架构设计

┌─────────────────────────────────────────┐
│              BusinessItemHandler         │  ← 主控制器
│          (协调各组件，控制流程)            │
└─────────────────┬───────────────────────┘
                  │
    ┌─────────────┼─────────────┐
    │             │             │
    ▼             ▼             ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Builder │ │ Filter  │ │Processor│  ← 职责单一
│  构建器  │ │ 过滤器   │ │ 处理器   │
└─────────┘ └─────────┘ └─────────┘

职责分离原则

• Handler: 只负责流程控制，不处理具体业务逻辑
• Builder: 只负责VO构建，不处理业务判断
• Filter: 只负责过滤逻辑，不处理VO构建
• Processor: 只负责特殊处理，不处理过滤逻辑

设计原则应用

1. 单一职责原则 (SRP)

每个类只负责一个职责，便于理解和修改

2. 开闭原则 (OCP)

对扩展开放，对修改关闭

• 新增业务规则：添加新的Filter/Processor
• 修改业务规则：修改对应的Filter/Processor
• 主流程：无需修改

3. 依赖倒置原则 (DIP)

依赖抽象而不是具体实现

• Handler依赖Filter和Processor接口
• 便于替换和扩展

具体实现

1. Builder模式 - VO构建器

问题分析

原始代码中VO构建逻辑分散，有20多个字段需要设置，构建逻辑复杂且经常变动。

解决方案

@Component
@RequiredArgsConstructor
public class BusinessItemBuilder {
    
    private final BusinessHelper businessHelper;
    private final BusinessItemHelper businessItemHelper;

    /**
     * 构建基础业务项目VO
     * 集中管理VO构建逻辑，保证构建逻辑的一致性
     */
    public BusinessItemVO buildBasicVO(BusinessItemEntity businessItem,
                                      BusinessRuleEntity businessRule,
                                      boolean isSpecialScenario) {
        BusinessItemVO vo = new BusinessItemVO();
        
        // 设置基础信息
        vo.setItemId(businessItem.getId());
        vo.setItemName(buildItemName(businessItem, isSpecialScenario));
        vo.setItemType(businessItem.getItemType());
        vo.setItemStatus(buildItemStatus(businessItem.getId()));
        vo.setItemCategory(isSpecialScenario ? BusinessConstant.SPECIAL_CATEGORY : BusinessConstant.NORMAL_CATEGORY);
        
        // 设置规则信息
        vo.setRuleId(businessRule.getId());
        vo.setRuleCategoryId(businessItem.getRuleCategoryId());
        vo.setRuleCondition(businessRule.getRuleCondition());
        
        // 设置时间信息
        vo.setProcessTime(buildProcessTime(businessRule));
        
        return vo;
    }
    
    /**
     * 设置数据项数量
     */
    public void setDataItemCount(BusinessItemVO vo, int count) {
        vo.setDataItemCount(count);
    }
    
    /**
     * 设置今日操作信息
     */
    public void setTodayOperationInfo(BusinessItemVO vo, String todayOperatorName) {
        if (StringUtils.isNotBlank(todayOperatorName)) {
            vo.setTodayOperatorName(todayOperatorName);
            vo.setIsOperatedToday(true);
        }
    }
    
    // 私有方法：构建项目名称
    private String buildItemName(BusinessItemEntity businessItem, boolean isSpecialScenario) {
        if (isTemporaryItem(businessItem.getId()) && isSpecialScenario) {
            return BusinessConstant.TEMPORARY_ITEM_NAME;
        }
        return businessItem.getItemName();
    }
    
    // 私有方法：构建项目状态
    private String buildItemStatus(Long itemId) {
        return businessHelper.isTemporaryItem(itemId) ? 
            BusinessConstant.TEMPORARY_STATUS : 
            BusinessConstant.NORMAL_STATUS;
    }
    
    // 私有方法：构建处理时间
    private String buildProcessTime(BusinessRuleEntity businessRule) {
        Date targetTime = DateUtils.plusDays(new Date(), Long.parseLong(businessRule.getProcessDays()));
        return DateUtils.formatDate(targetTime);
    }
}

设计思考

• 集中管理：所有VO构建逻辑集中在一个类中
• 方法分离：不同字段的构建逻辑分离到不同方法
• 依赖注入：通过构造函数注入必要的依赖
• 私有方法：复杂的构建逻辑封装为私有方法

2. Chain of Responsibility模式 - 过滤器链

问题分析

原始代码中过滤逻辑混乱，所有过滤条件都混在主方法中，难以维护和扩展。

解决方案

过滤器接口设计：

public interface BusinessItemFilter {
    /**
     * 判断是否应该过滤掉该项目
     * @param businessItem 业务项目实体
     * @param businessRule 业务规则实体
     * @param query 查询参数
     * @param businessInfo 业务信息
     * @return true-过滤掉，false-不过滤
     */
    boolean shouldFilter(BusinessItemEntity businessItem,
                        BusinessRuleEntity businessRule,
                        GetBusinessItemQuery query,
                        BusinessInfoDTO businessInfo);
    
    /**
     * 获取过滤器优先级，数字越小优先级越高
     */
    default int getPriority() {
        return 100;
    }
}

特殊类型过滤器：

@Component
@RequiredArgsConstructor
public class SpecialTypeFilter implements BusinessItemFilter {
    
    private final BusinessHelper businessHelper;

    @Override
    public boolean shouldFilter(BusinessItemEntity businessItem,
                               BusinessRuleEntity businessRule,
                               GetBusinessItemQuery query,
                               BusinessInfoDTO businessInfo) {
        // 只处理特殊类型项目
        if (!businessItem.isSpecialType()) {
            return false;
        }

        // 如果当前业务当天已处理成功了，则不再展示特殊类型项目
        return !businessHelper.isShowSpecialTypeForToday(query.getBusinessId());
    }

    @Override
    public int getPriority() {
        return 20; // 高优先级
    }
}

临时项目过滤器：

@Component
@RequiredArgsConstructor
public class TemporaryItemFilter implements BusinessItemFilter {
    
    private final BusinessHelper businessHelper;
    private final BusinessProperties businessProperties;

    @Override
    public boolean shouldFilter(BusinessItemEntity businessItem,
                               BusinessRuleEntity businessRule,
                               GetBusinessItemQuery query,
                               BusinessInfoDTO businessInfo) {
        // 只处理临时项目
        if (!businessHelper.isTemporaryItem(businessItem.getId())) {
            return false;
        }

        // 根据版本标志选择不同的判断逻辑
        if (businessProperties.isUseTemporaryItemV2Flag()) {
            return !businessHelper.isShowTemporaryItemForTodayV2(
                query.getBusinessId(),
                businessItem.getId(),
                businessRule
            );
        } else {
            return !businessHelper.isShowTemporaryItemForToday(
                query.getBusinessId(),
                businessItem.getId(),
                businessRule
            );
        }
    }

    @Override
    public int getPriority() {
        return 30;
    }
}

过滤器链管理：

@Component
@RequiredArgsConstructor
public class BusinessItemFilterChain {
    
    private final List<BusinessItemFilter> filters;

    /**
     * 执行过滤链
     * 按优先级排序，依次执行过滤器
     */
    public boolean shouldFilter(BusinessItemEntity businessItem,
                               BusinessRuleEntity businessRule,
                               GetBusinessItemQuery query,
                               BusinessInfoDTO businessInfo) {
        // 按优先级排序
        List<BusinessItemFilter> sortedFilters = filters.stream()
            .sorted((f1, f2) -> Integer.compare(f1.getPriority(), f2.getPriority()))
            .toList();

        // 依次执行过滤器
        for (BusinessItemFilter filter : sortedFilters) {
            if (filter.shouldFilter(businessItem, businessRule, query, businessInfo)) {
                return true; // 被过滤掉
            }
        }
        
        return false; // 通过所有过滤
    }
}

3. Strategy模式 - 处理器链

问题分析

原始代码中特殊处理逻辑复杂且经常变动，不同处理逻辑之间相互独立。

解决方案

处理器接口设计：

public interface BusinessItemProcessor {
    /**
     * 处理业务项目的特殊业务逻辑
     * @param vo 业务项目VO
     * @param businessItem 业务项目实体
     * @param businessRule 业务规则实体
     * @param query 查询参数
     * @param businessInfo 业务信息
     */
    void process(BusinessItemVO vo,
                 BusinessItemEntity businessItem,
                 BusinessRuleEntity businessRule,
                 GetBusinessItemQuery query,
                 BusinessInfoDTO businessInfo);
    
    /**
     * 判断是否支持处理该项目
     * @param businessItem 业务项目实体
     * @param businessRule 业务规则实体
     * @param query 查询参数
     * @return true-支持处理，false-不支持
     */
    boolean supports(BusinessItemEntity businessItem,
                    BusinessRuleEntity businessRule,
                    GetBusinessItemQuery query);
    
    /**
     * 获取处理器优先级，数字越小优先级越高
     */
    default int getPriority() {
        return 100;
    }
}

特殊类型处理器：

@Slf4j
@Component
@RequiredArgsConstructor
public class SpecialTypeProcessor implements BusinessItemProcessor {
    
    private final SpecialConditionService specialConditionService;

    @Override
    public void process(BusinessItemVO vo,
                       BusinessItemEntity businessItem,
                       BusinessRuleEntity businessRule,
                       GetBusinessItemQuery query,
                       BusinessInfoDTO businessInfo) {
        // 处理特殊条件信息
        if (isSpecialConditionMet(query.getBusinessId().longValue()) &&
            BusinessStatusEnum.ENABLE.getCode().equals(businessInfo.getSpecialConditionForItem())) {
            vo.setSpecialFlag(BusinessConstant.SPECIAL_FLAG_YES);
        }
    }

    @Override
    public boolean supports(BusinessItemEntity businessItem,
                           BusinessRuleEntity businessRule,
                           GetBusinessItemQuery query) {
        return businessItem.isSpecialType();
    }

    @Override
    public int getPriority() {
        return 10; // 高优先级
    }

    /**
     * 判断是否满足特殊条件
     */
    private boolean isSpecialConditionMet(Long businessId) {
        try {
            return specialConditionService.checkConditionMet(businessId, SpecialConditionTypeEnum.DAY);
        } catch (Exception e) {
            log.error("检查业务特殊条件状态异常，业务ID：{}，异常信息：{}", businessId, e.getMessage(), e);
            // 出异常时返回true，表示已满足条件，避免影响正常业务流程
            return true;
        }
    }
}

特殊场景处理器：

@Component
@RequiredArgsConstructor
public class SpecialScenarioProcessor implements BusinessItemProcessor {
    
    private final BusinessHelper businessHelper;

    @Override
    public void process(BusinessItemVO vo,
                       BusinessItemEntity businessItem,
                       BusinessRuleEntity businessRule,
                       GetBusinessItemQuery query,
                       BusinessInfoDTO businessInfo) {
        // 设置特殊场景项目的特殊状态
        vo.setCanOperateFlag(false);
        vo.setSpecialStatus(SpecialStatusEnum.NOT_OPERABLE.getCode());

        // 设置显示状态
        if (businessRule.isNotBegin()) {
            vo.setShowStatus("未开始");
        } else if (businessRule.isOverEndTime()) {
            vo.setShowStatus("已过期");
        }
    }

    @Override
    public boolean supports(BusinessItemEntity businessItem,
                           BusinessRuleEntity businessRule,
                           GetBusinessItemQuery query) {
        // 只处理特殊场景的过期项目
        return businessHelper.isSpecialScenario(query.getBusinessId()) &&
               businessRule.isExpired() &&
               (businessHelper.isSpecialTypeItem(businessItem.getId()) ||
                businessHelper.isTemporaryItem(businessItem.getId()));
    }

    @Override
    public int getPriority() {
        return 20;
    }
}

处理器链管理：

@Component
@RequiredArgsConstructor
public class BusinessItemProcessorChain {
    
    private final List<BusinessItemProcessor> processors;

    /**
     * 执行处理链
     * 按优先级排序，依次执行处理器
     */
    public void process(BusinessItemVO vo,
                       BusinessItemEntity businessItem,
                       BusinessRuleEntity businessRule,
                       GetBusinessItemQuery query,
                       BusinessInfoDTO businessInfo) {
        // 按优先级排序
        List<BusinessItemProcessor> sortedProcessors = processors.stream()
            .sorted((p1, p2) -> Integer.compare(p1.getPriority(), p2.getPriority()))
            .toList();

        // 依次执行处理器
        for (BusinessItemProcessor processor : sortedProcessors) {
            if (processor.supports(businessItem, businessRule, query)) {
                processor.process(vo, businessItem, businessRule, query, businessInfo);
            }
        }
    }
}

重构后的主流程

重构后的主方法

@Slf4j
@Service
@RequiredArgsConstructor
public class BusinessItemHandler {
    
    private final BusinessItemBuilder businessItemBuilder;
    private final BusinessItemFilterChain filterChain;
    private final BusinessItemProcessorChain processorChain;
    private final BusinessHelper businessHelper;
    private final BusinessRuleDomainService businessRuleDomainService;
    private final BusinessItemDomainService businessItemDomainService;
    private final BusinessOperationDomainService businessOperationDomainService;
    private final BusinessInfoClient businessInfoClient;
    private final BusinessItemHelper businessItemHelper;
    private final BusinessItemDataTransformHandler businessItemDataTransformHandler;

    /**
     * 获取业务项目列表
     * 重构后的方法，使用责任链模式处理各种业务逻辑
     */
    public List<BusinessItemVO> getBusinessItemList(GetBusinessItemQuery query) {
        // 1. 获取业务信息
        BusinessInfoDTO businessInfo = getBusinessInfo(query.getBusinessId());

        // 2. 权限验证
        if (!businessHelper.isCurrentUserCanAccess(query.getUserId())) {
            return Collections.emptyList();
        }

        // 3. 获取基础数据
        List<BusinessRuleEntity> ruleList = businessRuleDomainService.getBusinessRuleByBusinessId(query.getBusinessId());
        if (CollectionUtil.isEmpty(ruleList)) {
            return Collections.emptyList();
        }

        List<Long> itemIdList = ruleList.stream()
            .map(BusinessRuleEntity::getBusinessItemId)
            .toList();

        List<BusinessItemEntity> businessItemList = businessItemDomainService.getBusinessItemListById(itemIdList);
        if (CollectionUtil.isEmpty(businessItemList)) {
            return Collections.emptyList();
        }

        // 4. 获取今日操作记录
        Map<Long, String> operationRecordMap = businessOperationDomainService.getCurrentDayOperationRecordsByItemIdList(
            query.getBusinessId(),
            businessItemList.stream().map(BusinessItemEntity::getId).toList()
        );

        // 5. 构建项目ID到规则的映射
        Map<Long, BusinessRuleEntity> itemIdRuleMap = ruleList.stream()
            .collect(Collectors.toMap(BusinessRuleEntity::getBusinessItemId, Function.identity()));

        // 6. 处理每个项目
        List<BusinessItemVO> result = new ArrayList<>();
        for (BusinessItemEntity businessItem : businessItemList) {
            BusinessRuleEntity businessRule = itemIdRuleMap.get(businessItem.getId());
            if (businessRule == null) {
                continue;
            }

            // 6.1 处理临时项目数据转换
            List<BusinessItemDataEntity> businessItemDataList =
                businessItem.getBusinessItemDataList();
            if (businessItemHelper.isTemporaryItem(businessItem.getId())) {
                businessItemDataList = businessItemDataTransformHandler
                    .transformTemporaryItemData(businessItem.getId());
            }

            // 6.2 空数据检查（必须在数据转换之后）
            if (CollectionUtil.isEmpty(businessItemDataList)) {
                continue;
            }

            // 6.3 其他业务过滤检查
            if (filterChain.shouldFilter(businessItem, businessRule, query, businessInfo)) {
                continue;
            }

            // 6.4 构建基础VO
            BusinessItemVO vo = businessItemBuilder.buildBasicVO(
                businessItem,
                businessRule,
                businessHelper.isSpecialScenario(query.getBusinessId())
            );

            // 6.5 设置数据项数量（使用转换后的数据列表）
            businessItemBuilder.setDataItemCount(vo, businessItemDataList.size());

            // 6.6 设置今日操作信息
            String todayOperatorName = operationRecordMap.get(businessItem.getId());
            businessItemBuilder.setTodayOperationInfo(vo, todayOperatorName);

            // 6.7 执行处理器链
            processorChain.process(vo, businessItem, businessRule, query, businessInfo);

            result.add(vo);
        }

        return result;
    }

    /**
     * 获取业务信息
     */
    private BusinessInfoDTO getBusinessInfo(Integer businessId) {
        BusinessInfoDTO businessInfo = businessInfoClient.getBusinessInfo(businessId);
        if (businessInfo == null) {
            throw BusinessException.of(ErrorEnum.NOT_FOUND.getCode(), "根据业务id:" + businessId + ",获取不到业务信息");
        }
        return businessInfo;
    }
}

主流程的清晰度

重构后的主流程非常清晰：

1. 数据获取阶段：业务信息、权限验证、基础数据
2. 项目处理阶段：数据转换、过滤检查、VO构建、特殊处理
3. 结果返回阶段：返回处理后的项目列表

每个阶段职责明确，易于理解和维护。

重构效果对比

代码量对比

功能对比

维护性提升

原始代码：

// 修改特殊类型逻辑需要在大方法中找
if (businessItem.isSpecialType()) {
    if (!businessHelper.isShowSpecialTypeForToday(...)) {
        continue;
    }
    // 特殊条件检查逻辑...
}

重构后：

// 修改特殊类型逻辑只需要修改对应类
@Component
public class SpecialTypeFilter implements BusinessItemFilter {
    // 所有特殊类型过滤逻辑都在这里
}

扩展性提升

新增业务规则：

// 原始代码：需要修改主方法
if (newBusinessRule.isApplicable(businessItem)) {
    if (!newBusinessRule.shouldShow(businessItem, query)) {
        continue;
    }
}

// 重构后：只需要添加新的过滤器
@Component
public class NewBusinessRuleFilter implements BusinessItemFilter {
    @Override
    public boolean shouldFilter(...) {
        // 新业务规则逻辑
    }
}
// 无需修改主方法，自动生效

测试性提升

原始代码：

@Test
public void testGetBusinessItemList() {
    // 需要准备所有依赖，测试整个流程
    // 无法单独测试某个业务逻辑
}

重构后：

@Test
public void testSpecialTypeFilter() {
    // 只测试特殊类型过滤逻辑
    SpecialTypeFilter filter = new SpecialTypeFilter(businessHelper);
    boolean result = filter.shouldFilter(businessItem, businessRule, query, businessInfo);
    assertFalse(result);
}

两种设计模式的区别

Chain of Responsibility vs Strategy

为什么需要两种模式？

1. Chain of Responsibility → 解决**"过滤"**问题

   • 决定哪些项目需要被过滤掉
   • 每个过滤器负责一种过滤条件
   • 有一个返回true就停止

2. Strategy → 解决**"处理"**问题

   • 决定如何处理通过过滤的项目
   • 每个处理器负责一种处理逻辑
   • 找到匹配的就执行

两种模式的协作

// 主流程中的协作
for (BusinessItemEntity businessItem : businessItemList) {
    // 1. 过滤阶段：使用Chain of Responsibility
    if (filterChain.shouldFilter(businessItem, businessRule, query, businessInfo)) {
        continue; // 被过滤掉
    }
    
    // 2. 构建阶段：使用Builder
    BusinessItemVO vo = businessItemBuilder.buildBasicVO(...);
    
    // 3. 处理阶段：使用Strategy
    processorChain.process(vo, businessItem, businessRule, query, businessInfo);
}

重构过程中的思考

1. 设计模式的选择

在设计模式的选择过程中，我们考虑了以下因素：

• 业务复杂度：业务逻辑是否足够复杂，需要设计模式来组织
• 变动频率：代码是否经常变动，需要良好的扩展性
• 维护成本：维护成本是否过高，需要降低复杂度
• 团队能力：团队是否具备理解和维护设计模式的能力

2. 职责分离的思考

在职责分离的过程中，我们遵循了以下原则：

• 单一职责：每个类只负责一个职责
• 高内聚：相关的功能放在同一个类中
• 低耦合：类之间的依赖关系最小化
• 可测试性：每个类都可以独立测试

3. 扩展性的考虑

在考虑扩展性时，我们关注了以下方面：

• 新增功能：新增功能是否容易实现
• 修改功能：修改现有功能是否影响其他功能
• 删除功能：删除功能是否容易实现
• 配置管理：是否支持通过配置来管理功能

总结

重构的核心价值

通过合理运用设计模式，我们成功将复杂的业务代码重构为清晰、可维护、可扩展的代码：

1. 代码结构更清晰：主方法从128行减少到60行
2. 职责分离明确：构建器、过滤器、处理器各司其职
3. 易于扩展：新增业务规则只需添加新的组件
4. 易于测试：每个组件都可以独立测试
5. 易于维护：修改特定业务逻辑不会影响其他部分

设计模式的选择原则

使用设计模式不是过度设计，而是基于实际需求的选择：

• 核心业务模块 + 经常变动 = 需要设计模式
• 设计模式确保主流程不变，变化由其他类完成
• 职责分离、开闭原则、依赖倒置是核心思想

重构的思考过程

重构不是简单的代码重写，而是一个思考的过程：

1. 问题识别：识别代码中的问题
2. 模式选择：选择合适的设计模式
3. 架构设计：设计整体架构
4. 实现细节：实现具体的代码
5. 测试验证：验证重构的正确性
6. 持续改进：根据反馈持续改进

最终效果

重构后的代码在保持功能完整性的同时，提升了代码的可维护性、可扩展性和可测试性，为后续需求迭代开发奠定了坚实的基础。