模板方法模式：优化重复代码的设计模式实践

1. 模板方法模式的核心价值

在软件开发中，我们经常会遇到这样的情况：多个子类中存在着大量重复的代码逻辑，这些代码虽然具体实现可能略有差异，但整体执行流程却高度相似。这种场景下，模板方法模式就能大显身手了。

模板方法模式是一种行为设计模式，它定义了一个操作中的算法骨架，将某些步骤延迟到子类中实现。这样可以在不改变算法结构的情况下，让子类重新定义算法中的某些特定步骤。简单来说，就是把公共的代码逻辑抽取到父类中，把变化的代码留给子类去实现。

提示：模板方法模式特别适合那些具有固定流程但某些步骤需要灵活变化的场景，比如订单处理流程、数据导入导出流程等。

2. 模式结构与实现原理

2.1 基本结构解析

模板方法模式通常由以下几个核心部分组成：

1. 抽象父类(AbstractClass)：定义算法骨架，包含模板方法和基本方法
2. 具体子类(ConcreteClass)：实现父类中定义的抽象方法，完成特定步骤的实现

在Java中，一个典型的模板方法模式实现如下：

java复制public abstract class AbstractClass {
    // 模板方法，定义了算法骨架
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }
    
    // 基本方法，已经实现
    private void step1() {
        System.out.println("执行步骤1");
    }
    
    // 基本方法，由子类实现
    protected abstract void step2();
    
    // 基本方法，已经实现
    private void step3() {
        System.out.println("执行步骤3");
    }
}

public class ConcreteClass extends AbstractClass {
    @Override
    protected void step2() {
        System.out.println("子类实现的步骤2");
    }
}

2.2 设计要点解析

1. 模板方法：通常是final的，防止子类重写算法骨架
2. 基本方法：
   • 抽象方法：必须由子类实现
   • 具体方法：父类已经实现，子类可以选择性覆盖
   • 钩子方法：父类提供默认实现，子类可选择覆盖

注意：模板方法模式的关键在于合理划分不变部分和可变部分。不变的部分由父类实现，可变的部分交给子类实现。

3. 实战应用：订单处理系统

3.1 场景分析

假设我们正在开发一个电商系统，需要处理不同类型的订单（普通订单、团购订单、秒杀订单等）。这些订单的处理流程大致相同，但某些步骤的实现细节不同。

3.2 代码实现

首先定义抽象订单处理类：

java复制public abstract class OrderProcessor {
    // 模板方法
    public final void processOrder(Order order) {
        validateOrder(order);
        calculatePrice(order);
        applyDiscount(order);
        generateInvoice(order);
        notifyCustomer(order);
    }
    
    // 公共方法，所有订单类型都相同
    private void validateOrder(Order order) {
        // 验证订单基本信息
    }
    
    // 抽象方法，由子类实现
    protected abstract void calculatePrice(Order order);
    
    // 钩子方法，默认不应用折扣
    protected void applyDiscount(Order order) {
        // 默认实现
    }
    
    // 公共方法
    private void generateInvoice(Order order) {
        // 生成发票
    }
    
    // 公共方法
    private void notifyCustomer(Order order) {
        // 通知客户
    }
}

然后实现具体的订单处理器：

java复制public class GroupOrderProcessor extends OrderProcessor {
    @Override
    protected void calculatePrice(Order order) {
        // 团购价格计算逻辑
    }
    
    @Override
    protected void applyDiscount(Order order) {
        // 团购折扣逻辑
    }
}

public class FlashSaleOrderProcessor extends OrderProcessor {
    @Override
    protected void calculatePrice(Order order) {
        // 秒杀价格计算逻辑
    }
}

3.3 设计优势

1. 代码复用：公共逻辑只写一次，避免重复
2. 扩展灵活：新增订单类型只需继承父类，实现差异部分
3. 维护方便：修改公共逻辑只需修改父类一处

4. 模式变体与高级技巧

4.1 钩子方法的使用

钩子方法是一种特殊的基本方法，它在父类中提供默认实现，子类可以选择是否覆盖。这为模板方法提供了更大的灵活性。

java复制public abstract class ReportGenerator {
    public final void generateReport() {
        collectData();
        formatData();
        if (needSummary()) {
            addSummary();
        }
        exportReport();
    }
    
    protected boolean needSummary() {
        return false; // 默认不生成摘要
    }
    
    protected void addSummary() {
        // 默认摘要实现
    }
    
    // 其他抽象方法...
}

4.2 模板方法与策略模式结合

有时我们可以将模板方法模式与策略模式结合使用，将某些步骤的实现委托给策略对象，进一步提高灵活性。

java复制public abstract class DataExporter {
    private ExportStrategy exportStrategy;
    
    public final void exportData() {
        prepareData();
        validateData();
        exportStrategy.export(getExportData());
        postExport();
    }
    
    // 其他方法...
}

5. 常见问题与解决方案

5.1 模板方法模式与继承滥用

虽然模板方法模式使用了继承，但它与继承滥用是不同的。关键在于：

1. 模板方法模式中，父类控制流程，子类只负责实现特定步骤
2. 继承层次通常较浅（一般只有一层）
3. 子类与父类是"is-a"关系，符合里氏替换原则

5.2 何时使用模板方法模式

适合使用模板方法模式的场景包括：

1. 多个类有相同的行为，但具体实现不同
2. 需要控制子类的扩展点
3. 希望避免代码重复，将公共行为集中在父类中

5.3 性能考虑

模板方法模式通常不会引入明显的性能开销，因为：

1. 方法调用是直接的，没有额外的间接层
2. JVM对虚方法调用有优化
3. 模式本身不涉及复杂的数据结构

6. 实际项目中的经验分享

在实际项目中应用模板方法模式时，有几点经验值得分享：

1. 合理划分步骤粒度：步骤划分太粗会导致灵活性不足，太细则会增加复杂度。通常每个步骤应该完成一个明确的子任务。

2. 谨慎使用钩子方法：过多的钩子方法会让流程变得难以理解和维护。只有当某些步骤确实是可选的时候才使用钩子方法。

3. 文档化流程：在父类中清晰地文档化整个模板方法的执行流程和各步骤的职责，方便其他开发人员理解和使用。

4. 单元测试策略：

   • 为父类的模板方法编写测试用例，验证整体流程
   • 为每个子类编写测试用例，验证特定步骤的实现
   • 使用Mock对象测试步骤间的交互

5. 与工厂方法模式结合：有时可以在模板方法中使用工厂方法来创建对象，这样既控制了流程，又灵活地创建了所需对象。

java复制public abstract class DocumentProcessor {
    public final void processDocument() {
        Document doc = createDocument();
        parseDocument(doc);
        validateDocument(doc);
        saveDocument(doc);
    }
    
    protected abstract Document createDocument();
    // 其他方法...
}

在大型项目中，模板方法模式可以帮助我们建立清晰的代码结构，减少重复代码，提高可维护性。但也要注意不要过度设计，只有当确实存在多个相似流程时才考虑使用这个模式。