Go Test 单元测试简明教程

模板方法模式（Template Method Pattern）学习笔记

1. 模式定义

行为型设计模式，在抽象类中定义算法的骨架，将某些步骤延迟到子类实现。允许子类在不改变算法结构的情况下重新定义特定步骤。

2. 适用场景

✅ 存在多个相似算法流程但部分步骤不同的场景
✅ 需要固定算法执行顺序的场景
✅ 需要扩展算法特定步骤的场景
✅ 框架设计（父类控制流程，子类实现具体逻辑）
✅ 需要消除重复代码（多个子类有相同结构）

3. 模式结构

4. 核心角色

5. 代码示例

5.1 饮料制作示例

// 抽象类
abstract class BeverageTemplate {
    
    // 模板方法（final防止子类覆盖）
    public final void prepareBeverage() {
        boilWater();
        brew();
        pourInCup();
        if (needCondiments()) {
            addCondiments();
        }
    }
    
    // 通用步骤实现
    private void boilWater() {
        System.out.println("煮沸水");
    }
    
    private void pourInCup() {
        System.out.println("倒入杯子");
    }
    
    // 抽象方法（必须实现）
    protected abstract void brew();
    
    protected abstract void addCondiments();
    
    // 钩子方法（可选覆盖）
    protected boolean needCondiments() {
        return true;
    }
}

// 具体子类
class Coffee extends BeverageTemplate {
    @Override
    protected void brew() {
        System.out.println("冲泡咖啡粉");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入糖和牛奶");
    }
    
    @Override
    protected boolean needCondiments() {
        return false; // 示例：咖啡不要调料
    }
}

class Tea extends BeverageTemplate {
    @Override
    protected void brew() {
        System.out.println("浸泡茶叶");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入柠檬");
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        BeverageTemplate coffee = new Coffee();
        coffee.prepareBeverage();
        
        System.out.println("\n===============\n");
        
        BeverageTemplate tea = new Tea();
        tea.prepareBeverage();
    }
}

6. 模式变种

1. 钩子方法（Hook Methods）：
   在抽象类中提供空实现或默认返回true的方法，子类可选择覆盖来控制流程

   protected boolean validate() {
       return true; // 默认验证通过
   }
   

2. 模板方法重载：
   提供多个版本的模板方法应对不同场景

   public final void process(boolean isQuickMode) {
       if (isQuickMode) {
           step1();
           step3();
       } else {
           templateMethod();
       }
   }
   

7. 优缺点分析

✔️ 优点：

• 封装不变部分，扩展可变部分
• 父类控制算法结构，子类专注细节实现
• 代码复用率高，减少重复代码
• 符合开闭原则（通过扩展增加新实现）

❌ 缺点：

• 每增加一个实现需要新建子类，可能增加系统复杂度
• 父类修改可能影响所有子类
• 继承关系限制了灵活性（可通过组合+策略模式优化）

8. 相关模式对比

9. 实际应用案例

• Java Servlet的service()方法
• Spring框架的JdbcTemplate
• Hibernate的HibernateTemplate
• Java集合框架的AbstractList/AbstractSet
• AWT的WindowAdapter（适配器模式+模板方法）
• Junit的TestCase生命周期方法（setUp()/tearDown()）

10. 最佳实践建议

1. 模板方法声明为final：防止子类重写算法结构
2. 合理使用钩子方法：在关键扩展点提供可控覆盖
3. 控制抽象方法数量：避免过多步骤导致子类实现困难
4. 结合其他模式使用：
   • 与工厂方法模式结合创建步骤所需对象
   • 与策略模式结合替换特定算法步骤
5. 优先使用组合：当需要突破单继承限制时，改用策略模式
6. 文档注释：明确说明每个步骤的作用和调用顺序

11. 扩展应用示例（Spring JdbcTemplate）

public abstract class JdbcTemplate {
    
    public final Object execute(String sql) {
        Connection con = null;
        try {
            con = getConnection();
            PreparedStatement ps = con.prepareStatement(sql);
            setParameters(ps); // 抽象方法
            ps.execute();
            return handleResult(ps); // 抽象方法
        } finally {
            releaseConnection(con);
        }
    }
    
    protected abstract void setParameters(PreparedStatement ps) throws SQLException;
    
    protected abstract Object handleResult(Statement stmt) throws SQLException;
    
    // ...其他通用方法...
}

// 使用示例
new JdbcTemplate() {
    @Override
    protected void setParameters(PreparedStatement ps) {
        ps.setString(1, "paramValue");
    }
    
    @Override
    protected Object handleResult(Statement stmt) {
        return ((PreparedStatement)stmt).getResultSet();
    }
}.execute("SELECT * FROM table WHERE col = ?");

通过模板方法模式，可以有效管理复杂流程的标准化实现，特别适合框架开发和企业级应用中的通用流程控制场景。