模板方法设计模式在JDBC中的应用
Posted 老程序员老关
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了模板方法设计模式在JDBC中的应用相关的知识，希望对你有一定的参考价值。
设计模式是在特定场景下对特定问题的解决方案，这些解决方案是经过反复论证和测试总结出来的。实际上，除了软件设计，设计模式也被广泛应用于其他领域，比如UI设计和建筑设计等。Java软件设计模式大都来源于GoF1的23种设计模式。
这段时间一直在录制Java EE视频课程，其中在JDBC（Java数据库连接）中使用了模板方法设计（Template Method），下面给大家分享一下。
1. 什么是模板方法设计模式？
在生活中完成一些“任务”有着固定的步骤，例如，我要完成“喝茶”任务，需要的步骤如下：
①烧水→②沏茶→③喝茶
而很多任务也有类似的步骤，例如，我要完成“喝咖啡”任务，当然是速溶咖啡那种。需要的步骤如下：
①烧水→②冲咖啡→③喝咖啡
对应两个任务他们有类似的3个步骤，步骤①和③是相同的，而步骤②是不同的。这样可以设计一个父类TaskTemplate代码如下：
public abstract class TaskTemplate
public final void 任务()
// 步骤①
烧水();
// 步骤②
冲泡();
// 步骤③
喝();
private void 烧水()
System.out.println("烧水...");
protected abstract void 冲泡();
private void 喝()
System.out.println("喝...");
TaskTemplate是一个抽象类，其中“任务()”方法中定义了执行“任务”的流程，其中“烧水()”和“喝()”是两个具体方法，由于父类中无法确定冲泡什么，因此“冲泡()”方法是抽象方法，留给子类实现。“任务()”就是模板方法。
“喝茶”任务实现类TeaTask代码如下：
public class TeaTask extends TaskTemplate
@Override
protected void 冲泡()
System.out.println("来壶铁观音。");
“喝咖啡”任务实现类CoffeeTask代码如下：
public class CoffeeTask extends TaskTemplate
@Override
protected void 冲泡()
System.out.println("冲卡布奇诺咖啡+糖+奶。");
他们的类图如图1所示。
这就是模板方法设计模式了，那么如何使用呢？示例代码如下：
public class Main
public static void main(String[] args)
System.out.println("------喝茶任务------");
TaskTemplate template = new TeaTask();
template.任务();
System.out.println("------喝咖啡任务------");
template = new CoffeeTask();
template.任务();
输出结果如下：
------喝茶任务------
烧水...
来壶铁观音。
喝...
------喝咖啡任务------
烧水...
冲卡布奇诺咖啡+糖+奶。
喝...
上述代码模板子类是有名类，而有时候子类个数太多，也可以采用匿名内部类作为模板子类。修改Main调用代码如下：
public class Main
public static void main(String[] args)
System.out.println("------喝茶任务------");
TaskTemplate template = new TaskTemplate() ①
@Override
protected void 冲泡()
System.out.println("来壶铁观音。");
;
template.任务();
System.out.println("------喝咖啡任务------");
template = new TaskTemplate() ②
@Override
protected void 冲泡()
System.out.println("冲卡布奇诺咖啡+糖+奶。");
;
template.任务();
上述代码第①行是实现了喝茶任务子类功能，代码第②行是实现了喝咖啡任务子类功能。
2. 糟糕的JDBC代码
上面的介绍的设计模式或许很容易理解，但是又有什么用途呢？使用设计模式是学习的难点。下面先来看看糟糕的JDBC代码：
public class Main
public static void main(String[] args)
//查询数据
read();
//数据插入
create();
//数据更新
update();
//删除数据
delete();
/**
* 查数据
*/
private static void read()
// 载数据库驱动
loadDBDriver();
String sql = "select name, userid from user where userid > ? order by userid";
Connection connection = null;
PreparedStatement ps = null;
try
// 创建数据库连接
connection = getConnection();
// 创建语句对象
ps = connection.prepareStatement(sql);
// 绑定参数
ps.setInt(1, 0);
ResultSet rs = ps.executeQuery();
//遍历结果集
while (rs.next())
System.out.printf("name: %s id: %d \\n",
rs.getString("name"),
rs.getInt("userid"));
catch (SQLException e)
e.printStackTrace();
finally
if (connection != null)
try
connection.close();
catch (SQLException e)
e.printStackTrace();
if (ps != null)
try
ps.close();
catch (SQLException e)
e.printStackTrace();
/**
* 插入数据
*/
private static void create()
// 载数据库驱动
loadDBDriver();
String sql = "insert into user (userid, name) values (?, ?)";
Connection connection = null;
PreparedStatement ps = null;
try
// 建数据库连接
connection = getConnection();
// 创建语句对象
ps = connection.prepareStatement(sql);
// 绑定参数
ps.setInt(1, 999);
ps.setString(2, "Tony999");
// 执行SQL语句
int count = ps.executeUpdate();
System.out.printf("成功插入%d条数据.\\n", count);
catch (SQLException e)
e.printStackTrace();
finally
if (connection != null)
try
connection.close();
catch (SQLException e)
e.printStackTrace();
if (ps != null)
try
ps.close();
catch (SQLException e)
e.printStackTrace();
/**
* 更新数据
*/
private static void update()
// 载数据库驱动
loadDBDriver();
String sql = "update user set name=? where userid =?";
Connection connection = null;
PreparedStatement ps = null;
try
// 创建数据库连接
connection = getConnection();
// 创建语句对象
ps = connection.prepareStatement(sql);
// 绑定参数
ps.setString(1, "Tom999");
ps.setInt(2, 999);
// 执行SQL语句
int count = ps.executeUpdate();
System.out.printf("成功更新%d条数据.\\n", count);
catch (SQLException e)
e.printStackTrace();
finally
if (connection != null)
try
connection.close();
catch (SQLException e)
e.printStackTrace();
if (ps != null)
try
ps.close();
catch (SQLException e)
e.printStackTrace();
/**
* 删除数据
*/
private static void delete()
// 载数据库驱动
loadDBDriver();
String sql = "delete from user where userid = ?";
Connection connection = null;
PreparedStatement ps = null;
try
// 创建数据库连接
connection = getConnection();
// 创建语句对象
ps = connection.prepareStatement(sql);
// 绑定参数
ps.setInt(1, 999);
// 执行SQL语句
int count = ps.executeUpdate();
System.out.printf("成功删除%d条数据.\\n", count);
catch (SQLException e)
e.printStackTrace();
finally
if (connection != null)
try
connection.close();
catch (SQLException e)
e.printStackTrace();
if (ps != null)
try
ps.close();
catch (SQLException e)
e.printStackTrace();
/**
* 建立数据库连接
*
* @return 返回数据库连接对象
* @throws SQLException
*/
private static Connection getConnection() throws SQLException
String url = "jdbc:mysql://localhost:3306/mydb?verifyServerCertificate=false&useSSL=false";
String user = "root";
String password = "12345";
Connection connection = DriverManager.getConnection(url, user, password);
return connection;
/**
* 加载数据库驱动
*/
private static void loadDBDriver()
// 1.
try
Class.forName("com.mysql.jdbc.Driver");
catch (ClassNotFoundException e)
e.printStackTrace();
上述代码中访问数据的方法有4个read()、create()、update()和delete()。其中create()、update()和delete()三个方法代码非常相似，只是SQL语句和绑定参数不同而已。虽然read()方法与create()、update()和delete()方法不同，但是差别也不大。
JDBC代码主要的问题是：大量的重复代码！！！
3. 在JDBC中使用模板设计方法模式
从上一节代码总结数据库编程一般过程，如图2所示。
从图3中可见查询（Read）过程最多需要7个步骤。修改（C插入、U更新、D删除）过程最多需要6个步骤。其中有些步骤是不变的，而有些步骤是可变的。如图3所示，查询过程中1、2、5和7步是不可变的所有查询都是一样的，而3、4和6步不同，第3步在“创建语句对象”时需要指定SQL语句，这是“此查询”与“彼查询”的不同之处；由于SQL语句的不同绑定参数也可能不同，所以第4步也是不同的；另外，第6步是“遍历结果集”也会根据查询的不同字段，以及字段提取后处理的方式不同而有所不同。
使用代码模板方法模式，可以将1、2、5和7步定义在父类在，将3、4和6步定义在子类中。代码如下：
public abstract class JdbcTemplate
public final void query()
// 1、载数据库驱动
loadDBDriver();
Connection connection = null;
PreparedStatement ps = null;
try
// 2、创建数据库连接
connection = getConnection();
// 3、创建语句对象 4、绑定参数
ps = createPreparedStatement(connection);
// 5、执行查询
ResultSet rs = ps.executeQuery();
// 6、遍历结果集
while (rs.next())
processRow(rs);
catch (SQLException e)
e.printStackTrace();
finally
// 7、释放资源
if (connection != null)
try
connection.close();
catch (SQLException e)
e.printStackTrace();
if (ps != null)
try
ps.close();
catch (SQLException e)
e.printStackTrace();
/**
* 遍历结果集时，处理结果集
* @param rs 结果集
* @throws SQLException
*/
public abstract void processRow(ResultSet rs) throws SQLException; ③
/**
* 创建语句对象，其中包括指定SQL语句，绑定参数。
* @param conn 连接对象
* @return 语句对象
* @throws SQLException
*/
public abstract PreparedStatement
createPreparedStatement(Connection conn) throws SQLException; ④
/**
* 建立数据库连接
*
* @return 返回数据库连接对象
* @throws SQLException
*/
private static Connection getConnection() throws SQLException
String url = "jdbc:mysql://localhost:3306/mydb?verifyServerCertificate=false&useSSL=false";
String user = "root";
String password = "12345";
Connection connection = DriverManager.getConnection(url, user, password);
return connection;
/**
* 加载数据库驱动
*/
private static void loadDBDriver()
try
Class.forName("com.mysql.jdbc.Driver");
catch (ClassNotFoundException e)
e.printStackTrace();
在查询方法中代码第①行调用抽象方法createPreparedStatement(connection)创建预处理的语句对象，事实上在创建语句对象时，还可以为其绑定参数，所以代码第①行调用createPreparedStatement(connection)过程中实现“3、创建语句对象”和“4、绑定参数”。
代码第②行是在遍历结果集过程中调用抽象方法processRow(rs)处理结果集。一般而言所有遍历结果集都是while (rs.next()) …循环语句实现的，只是提取的字段不同，提取之后的处理过程不同。
那么调用read()方法代码如下：
/**
* 查数据
*/
private static void read()
String sql = "select name, userid from user where userid > ? order by userid";
JdbcTemplate template = new JdbcTemplate() ①
@Override
public PreparedStatement createPreparedStatement(Connection conn) throws SQLException
// 绑定参数
PreparedStatement ps = conn.prepareStatement(sql);
// 绑定参数
ps.setInt(1, 0);
return ps;
@Override
public void processRow(ResultSet rs) throws SQLException
System.out.printf("name: %s id: %d \\n",
rs.getString("name"),
rs.getInt("userid"));
; ②
template.query(); ③
上述代码第①行~第②行采用匿名内部类子类化JdbcTemplate类，并且实例化它，而没有采用有名类子类化JdbcTemplate类，这是因为每一次查询都需要一个JdbcTemplate子类，以及该子类的实例。这样会需要创建很多个JdbcTemplate子类。代码第③行调用模板方法query()执行查询。
图4所示是修改过程，其中1、2、5和6步是不可变的所有修改（插入、删除和更新）都是一样的，而3和4步是不同的。
使用代码模板方法模式，可以将1、2、5和7步定义在父类在，将3、4和6步定义在子类中。代码如下：
public abstract class JdbcTemplate
public final void update()
// 1、载数据库驱动
loadDBDriver();
Connection connection = null;
PreparedStatement ps = null;
try
// 2、创建数据库连接
connection = getConnection();
// 3、创建语句对象 4、绑定参数
ps = createPreparedStatement(connection); ①
// 5、执行SQL语句
int count = ps.executeUpdate();
System.out.printf("成功修改%d条数据.\\n", count);
catch (SQLException e)
e.printStackTrace();
finally Spring中的设计模式：模板模式