1. 什么是模板方法模式
模板方法模式（Template Method Pattern）是一种行为设计模式，它在操作中定义算法的框架，将一些步骤推迟到子类中。模板方法让子类在不改变算法结构的情况下重新定义算法的某些步骤。
模板方法模式的定义：
在操作中定义算法的框架，并将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下重新定义算法的某些步骤。
模板方法中的算法可以理解为广义上的业务逻辑，并不是特指某一个实际的算法。定义中所说的算法的框架就是模板，包含算法框架的方法就是模板方法。
模板方法模式包含以下主要角色：
- 抽象父类：定义一个算法所包含的所有步骤，并提供一些通用的方法逻辑。
- 具体子类：继承自抽象父类，根据需要重写父类提供的算法步骤中的某些步骤。
抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。
-
模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
-
基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：
- 抽象方法（Abstract Method）：一个抽象方法由抽象类声明、由其具体子类实现。
- 具体方法（Concrete Method）：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。
- 钩子方法（Hook Method）：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。
钩子：在模板方法的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。钩子方法一般是空的或者有默认实现。钩子的存在，可以让子类有能力对算法的不同点进行挂钩。而要不要挂钩，又由子类去决定。
2. 代码示例
/**
* 抽象父类
*/
public abstract class AbstractClassTemplate {
void step1(String key) {
System.out.println("在模板类中 -> 执行步骤1");
if (step2(key)) {
step3();
} else {
step4();
}
step5();
}
boolean step2(String key) {
System.out.println("在模板类中 -> 执行步骤2");
return "x".equals(key);
}
abstract void step3();
abstract void step4();
void step5() {
System.out.println("在模板类中 -> 执行步骤5");
}
void run(String key) {
step1(key);
}
}
public class ConcreteClassA extends AbstractClassTemplate {
@Override
void step3() {
System.out.println("在子类A中 -> 执行步骤 3");
}
@Override
void step4() {
System.out.println("在子类A中 -> 执行步骤 4");
}
}
public class ConcreteClassB extends AbstractClassTemplate {
@Override
void step3() {
System.out.println("在子类B中 -> 执行步骤 3");
}
@Override
void step4() {
System.out.println("在子类B中 -> 执行步骤 4");
}
}
public class Test01 {
public static void main(String[] args) {
AbstractClassTemplate concreteClassA = new ConcreteClassA();
concreteClassA.run("");
System.out.println("===========");
AbstractClassTemplate concreteClassB = new ConcreteClassB();
concreteClassB.run("x");
}
}
// 输出结果
在模板类中 -> 执行步骤1
在模板类中 -> 执行步骤2
在子类A中 -> 执行步骤 4
在模板类中 -> 执行步骤5
===========
在模板类中 -> 执行步骤1
在模板类中 -> 执行步骤2
在子类B中 -> 执行步骤 3
在模板类中 -> 执行步骤5
3. JdbcTemplate应用模板方法模式
在原生JDBC操作中，需要执行以下步骤：
- 获取connection
- 获取statement
- 获取resultset
- 遍历resultset并封装成集合
- 依次关闭connection, statement, resultset，并考虑各种异常
上面步骤中大多数都是重复的、可复用的，只有在遍历ResultSet并封装成集合的步骤是可定制的。每张表都映射不同的Java bean，这部分代码是没有办法复用的，只能定制。
// 模板方法，用来执行 JDBC 操作，返回结果集或受影响的行数
protected <T> T execute(ConnectionCallback<T> action, boolean enforceReadOnly) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Connection con = DataSourceUtils.getConnection(obtainDataSource());
try {
boolean readOnly = enforceReadOnly || isReadOnly();
// 设置是否为只读连接
prepareConnection(con, readOnly);
// 执行具体的 JDBC 操作，该方法为子类实现
T result = action.doInConnection(con);
// 提交事务
DataSourceUtils.commitIfNecessary(con, getDataSource());
// 返回结果集或受影响的行数
return result;
} catch (SQLException ex) {
// 回滚事务
DataSourceUtils.rollbackIfNecessary(con, getDataSource());
throw translateException("Callback", getSql(action), ex);
} finally {
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
// 执行给定的 SQL 语句和参数，返回查询结果
public <T> T query(final String sql, final ResultSetExtractor<T> rse, Object... args) throws DataAccessException {
Assert.notNull(sql, "SQL must not be null");
Assert.notNull(rse, "ResultSetExtractor must not be null");
// 匿名内部类，实现 ConnectionCallback 接口
return execute(new ConnectionCallback<T>() {
@Override
public T doInConnection(Connection con) throws SQLException {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 创建 PreparedStatement 对象
ps = createPreparedStatement(con, sql);
// 设置 PreparedStatement 的参数
setValues(ps, args);
// 执行查询，返回结果集
rs = ps.executeQuery();
// 对结果集进行处理，返回查询结果
return rse.extractData(rs);
} finally {
JdbcUtils.closeResultSet(rs);
JdbcUtils.closeStatement(ps);
}
}
}, true);
}
4. 运用模板方法手写简单版JdbcTemplate
- 定义
DefineJcbcTemplate自定义jdbcTemplate接口
public interface DefineJcbcTemplate {
<T> T queryForObject(String sql, DefineRowMapper<T> defineRowMapper);
}
- 定义
DefineRowMapper函数式接口，回调作用，处理jdbc查询结果ResultSet，返回泛型T对象
@FunctionalInterface
public interface DefineRowMapper<T> {
T mapRow(ResultSet rs) throws SQLException;
}
DefineJcbcTemplateImpl实现类，该实现类的连接数据库、释放资源等操作都是从步骤一复制粘贴进来的，唯一不同的是把处理结果解耦出来了，定义好处理结果的接口DefineRowMapper，交由调用者去实现对结果的处理，最后回调该接口的方法mapRow并返回结果，其他的把连接数据库、释放资源封装起来，这样一来不用每次进行数据库查询都需要连接数据库、释放资源。
@Service
public class DefineJcbcTemplateImpl implements DefineJcbcTemplate {
@Autowired
private DataSource dataSource;
@Override
public <T> T queryForObject(String sql, DefineRowMapper<T> defineRowMapper) {
// 一部分是准备和释放资源以及执行 SQL 语句，另一部分则是处理 SQL 执行结果
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
// 创建dataSource,获取连接
connection = dataSource.getConnection();
// 执行查询
preparedStatement = connection.prepareStatement(sql);
// 获取执行结果
resultSet = preparedStatement.executeQuery();
// 交由调用者去实现对结果的处理
return defineRowMapper.mapRow(resultSet);
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭资源
if (preparedStatement != null) {
try {
preparedStatement.close
();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return null;
}
}
- 调用自定义模板方法进行数据库查询
@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestSpringTemplateApplication.class)
public class TestSpringTemplateApplicationTests {
@Autowired
private DefineJcbcTemplate defineJcbcTemplate;
@Test
public void testQueryForObject() {
// 定义sql
String sql = "SELECT * FROM user";
// 通过模版方法进行查询
List<User> users = defineJcbcTemplate.queryForObject(sql, (rs) -> {
List<User> result = new ArrayList<>();
while (rs.next()) {
// 遍历ResultSet并封装成集合
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
user.setEmail(rs.getString("email"));
result.add(user);
}
return result;
});
System.out.println(users);
}
}
通过上面的代码，您可以看到模板方法模式可以很容易地将重复的部分代码提取到父类中，而将可变的部分代码放入子类中，从而实现代码的复用和扩展。
![[译] Rust标准库有些特殊，让我们改它](https://img-blog.csdnimg.cn/img_convert/15bf5e6a9b94f510de66855e256595c7.png)
