Java设计模式之模板方法模式：从入门到架构级实践

1. 模板方法模式核心思想

模板方法模式（Template Method Pattern）是行为型设计模式中最具工业化特征的模式之一。其核心在于定义算法骨架，允许子类重写特定步骤，完美体现了"好莱坞原则"（Don't call us, we'll call you）。该模式通过将不变行为搬到超类，去除子类中的重复代码，是框架设计中控制扩展点的常用手段。

2. 模式结构深度解析

2.1 抽象模板类（Abstract Class）

public abstract class DataProcessor {
    // 模板方法（final防止子类覆盖）
    public final void process() {
        validateInput();
        connectToDataSource();
        processData();
        closeConnection();
        sendNotification();
    }

    // 抽象方法：必须由子类实现
    protected abstract void processData();

    // 具体方法：通用实现
    private void validateInput() {
        System.out.println("Validating input parameters...");
    }

    // 钩子方法（Hook Method）：可选重写
    protected void sendNotification() {
        System.out.println("Sending default email notification");
    }

    // 必须实现但允许不同方式
    protected abstract void connectToDataSource();
    
    private void closeConnection() {
        System.out.println("Closing database connection");
    }
}

2.2 具体实现类

public class MySQLProcessor extends DataProcessor {
    @Override
    protected void connectToDataSource() {
        System.out.println("Connecting to MySQL via JDBC...");
    }

    @Override
    protected void processData() {
        System.out.println("Executing complex SQL queries");
    }

    @Override
    protected void sendNotification() {
        System.out.println("Sending Slack notification");
    }
}

3. 模式要素深入剖析

3.1 模板方法（Template Method）

• 使用final修饰确保算法结构不可变

• 定义执行步骤的顺序和流程控制

• 包含三种类型的方法调用：

  • 抽象方法（必须实现）

  • 具体方法（直接继承）

  • 钩子方法（可选覆盖）

3.2 钩子方法设计技巧

• 命名通常以"before"/"after"开头

• 返回boolean值控制流程走向

• 示例：支持跳过通知的改进设计

protected boolean shouldSendNotification() {
    return true;
}

public final void process() {
    // ...其他步骤
    if(shouldSendNotification()){
        sendNotification();
    }
}

4. 工业级应用场景

4.1 框架扩展点设计

Spring框架中的经典应用：

public abstract class JdbcTemplate {
    public final  T query(String sql, RowMapper rowMapper) {
        Connection con = null;
        try {
            con = getConnection();
            PreparedStatement ps = con.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            return rowMapper.mapRow(rs);
        } catch (SQLException e) {
            throw new DataAccessException(e);
        } finally {
            closeConnection(con);
        }
    }
    
    protected abstract Connection getConnection();
}

4.2 复杂业务流程标准化

电商订单处理模板：

public abstract class OrderProcessor {
    public final void handleOrder() {
        validateOrder();
        deductInventory();
        calculatePayment();
        if(needLogistics()) {
            arrangeDelivery();
        }
        generateInvoice();
        afterProcessingHook();
    }

    protected boolean needLogistics() { return true; }
    protected void afterProcessingHook() {}
    // 其他抽象方法...
}

5. 架构实践中的模式变体

5.1 模板回调模式

结合策略模式的改进实现：

public class PaymentTemplate {
    public void processPayment(PaymentCallback callback) {
        initPaymentGateway();
        validateParameters();
        callback.executePayment();
        recordTransactionLog();
        sendPaymentResult();
    }
    
    // 具体方法实现...
}

// 使用方式
new PaymentTemplate().processPayment(() -> {
    System.out.println("Processing credit card payment");
});

5.2 组合式模板

多个模板类的嵌套使用：

public abstract class ReportGenerator {
    protected DataProcessor dataProcessor;
    
    public final void generate() {
        dataProcessor.process();
        formatData();
        exportReport();
    }
    
    protected abstract void formatData();
    protected abstract void exportReport();
}

6. 模式对比与选择策略

模式	关注点	灵活性	典型场景
模板方法模式	算法步骤扩展	较低	固定流程，不同实现
策略模式	算法整体替换	高	完全不同的算法实现
工厂方法模式	对象创建	中等	对象创建过程标准化

选择原则：

• 当需要保持算法结构稳定，但允许特定步骤变化时选择模板方法

• 当需要完全替换整个算法实现时选择策略模式

• 二者可以结合使用，在模板方法中使用策略对象

7. 生产环境中的最佳实践

7.1 模板方法模式优化技巧

1. 层次化模板：创建多级抽象类，形成模板继承体系

2. 模板参数化：通过构造函数注入差异部分

3. 模板方法拆分：将大型模板分解为多个协作的小模板

4. 模板组合模式：将模板作为组件嵌入其他模式

7.2 Spring框架中的高级应用

AOP与模板方法的结合：

public abstract class TransactionTemplate {
    public final  T execute(TransactionCallback action) {
        TransactionStatus status = beginTransaction();
        try {
            T result = action.doInTransaction(status);
            commitTransaction(status);
            return result;
        } catch (Exception e) {
            rollbackTransaction(status);
            throw e;
        }
    }
    
    protected abstract void beginTransaction();
    // 其他事务方法...
}

8. 典型应用误区及规避

8.1 常见反模式

1. 模板膨胀：单个模板类包含过多方法

   • 解决方案：应用接口隔离原则，拆分为多个模板

2. 过度重写：子类覆盖过多父类方法

   • 正确做法：通过钩子方法控制扩展点

3. 流程碎片化：模板方法步骤过于零散

   • 优化方案：合并相关步骤，保持合理粒度

8.2 设计原则平衡

• 开闭原则：通过模板扩展而非修改

• 单一职责：每个模板类聚焦一个流程

• 里氏替换：子类必须保持模板行为一致性

9. 模式演进与未来趋势

9.1 响应式编程中的模板方法

WebFlux中的模板应用：

public abstract class ReactiveTemplate {
    public Mono execute() {
        return validate()
            .then(loadData())
            .flatMap(this::process)
            .doOnSuccess(this::sendNotification);
    }
    
    protected abstract Mono loadData();
    protected abstract Mono process(Data data);
}

9.2 Serverless架构中的模板模式

FaaS函数模板示例：

public abstract class CloudFunctionTemplate {
    public void handleRequest(Request request) {
        initContext();
        validateRequest(request);
        processCore(request);
        logExecution();
        releaseResources();
    }
    
    protected abstract void processCore(Request request);
}

10. 架构师视角的思考

1. 流程治理：通过模板方法实现标准流程的强制管控

2. 技术规范：制定团队模板方法开发规范

3. 性能优化：模板方法带来的JIT优化机会

4. 监控埋点：在模板方法中统一添加监控逻辑

5. 文档生成：基于模板结构自动生成API文档

架构级应用建议：

• 在基础框架层定义核心流程模板

• 业务中台层实现领域模板

• 前台应用层进行具体实现

• 通过模板方法实现跨系统流程对齐

总结

模板方法模式是构建可扩展架构的基础设施级模式。从简单的算法封装到复杂的系统流程控制，该模式展现了强大的适应能力。在微服务架构、云原生应用等领域，模板方法模式通过与新技术栈的结合，持续焕发新的生命力。正确理解和应用该模式，可以帮助开发者构建出更健壮、更易维护的系统架构。