当前位置：首页 > news >正文

你写的代码一半都是重复逻辑，模板方法能帮你省掉

news 2026/6/3 17:43:38

你写的代码一半都是重复逻辑，模板方法能帮你省掉

写过 JDBC 的人应该都有这段记忆：

Connection conn = null;PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
ps = conn.prepareStatement(sql);
ps.setString(1, name);
rs = ps.executeQuery();
while (rs.next()) {
// 处理结果
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (rs != null) rs.close();
if (ps != null) ps.close();
if (conn != null) conn.close();
}

这段代码你写一次，第二次写另一个查询的时候，结构几乎一模一样，只有 SQL 和结果处理不同。

这种"骨架相同、细节不同"的代码，就是模板方法模式要干掉的。

---

什么意思

模板方法的思路是：**把不变的流程固化在父类里，把变化的部分留给子类去实现。**

"获取连接→准备语句→执行→处理结果→关闭资源"这个流程是不变的，变化的是 SQL 和结果处理。

public abstract class JdbcTemplate {public final T execute(String sql) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
ps = conn.prepareStatement(sql);
setParameters(ps); // 子类实现：设置参数
rs = ps.executeQuery();
return handleResult(rs); // 子类实现：处理结果
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
closeQuietly(rs, ps, conn);
}
}
protected abstract void setParameters(PreparedStatement ps) throws SQLException;
protected abstract T handleResult(ResultSet rs) throws SQLException;
}

子类只需要关注自己的那部分：

public class FindUserById extends JdbcTemplate {private final Long userId;
public FindUserById(DataSource ds, Long userId) {
super(ds);
this.userId = userId;
}
@Override
protected void setParameters(PreparedStatement ps) throws SQLException {
ps.setLong(1, userId);
}
@Override
protected User handleResult(ResultSet rs) throws SQLException {
if (rs.next()) {
return new User(rs.getLong("id"), rs.getString("name"));
}
return null;
}
}

其实 Spring 的JdbcTemplate就是这个思路的工业级实现。只不过 Spring 用回调函数代替了继承，更灵活一些。

---

Spring 里的模板方法

你可能没意识到，你每天都在用模板方法模式。Spring 的大量基类设计都基于这个模式。

AbstractTransactionalDataSourcePlatformTransactionManager——光看名字就知道它是个抽象基类，里面的doBegin()、doCommit()、doRollback()都是留给子类实现的钩子方法。DataSourceTransactionManager和JtaTransactionManager分别继承了它，实现了不同的资源管理方式。

Spring Batch 里更明显：

public abstract class ItemProcessor {public final O process(I item) throws Exception {
O result = doProcess(item); // 子类实现
if (result == null) {
throw new SkipItemException("处理结果为空，跳过");
}
return result;
}
protected abstract O doProcess(I item) throws Exception;
}

process是模板方法，doProcess是钩子。模板方法用final修饰，防止子类覆盖流程，保证骨架不被破坏。

---

用回调替代继承

继承是模板方法的经典实现，但继承有硬限制——Java 只能单继承，你的类如果已经有父类了，就没法再用模板方法。

更灵活的方式是用回调（函数式接口），本质上还是模板方法的思路——固定骨架，变化部分注入：

public class TemplateRunner {public T runWithTransaction(ConnectionCallback action) {
Connection conn = null;
try {
conn = dataSource.getConnection();
conn.setAutoCommit(false);
T result = action.doInConnection(conn); // 回调：变化的部分
conn.commit();
return result;
} catch (Exception e) {
conn.rollback();
throw new RuntimeException(e);
} finally {
conn.close();
}
}
}
@FunctionalInterface
public interface ConnectionCallback {
T doInConnection(Connection conn) throws Exception;
}

用的时候：

User user = runner.runWithTransaction(conn -> {PreparedStatement ps = conn.prepareStatement("SELECT * FROM user WHERE id = ?");
ps.setLong(1, userId);
ResultSet rs = ps.executeQuery();
return rs.next() ? new User(rs.getLong("id"), rs.getString("name")) : null;
});

这其实就是 SpringJdbcTemplate.query()的思路。回调 + 模板方法，比继承更灵活，Lambda 写起来也比子类清爽。

---