Spring JdbcTemplate源码深度剖析

深藏阁楼爱情的钟 2022-05-27 05:05 156阅读 0赞

在Spring中，JdbcTemplate是经常被使用的类来帮助用户程序操作数据库，在JdbcTemplate为用户程序提供了许多便利的数据库操作方法，比如查询，更新等，而且在Spring中，有许多类似 JdbcTemplate的模板,比如HibernateTemplate等等 - 看来这是Rod.Johnson的惯用手法，

所谓模板板式，就是在父类中定义算法的主要流程，而把一些个性化的步骤延迟到子类中去实现，父类始终控制着整个流程的主动权，子类只是辅助父类实现某些可定制的步骤。

我们用代码来说话吧：   
首先，父类要是个抽象类：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **abstract** **class** TemplatePattern \{  
2.    
3.      //模板方法  
4.      **public** **final** **void** templateMethod()\{  
5.            
6.          method1();  
7.          method2();//勾子方法  
8.          method3();//抽象方法  
9.      \}  
10.     **private** **void** method1()\{  
11.         System.out.println("父类实现业务逻辑");  
12.     \}  
13.     **public** **void** method2()\{  
14.         System.out.println("父类默认实现，子类可覆盖");  
15.     \}  
16.     **protected** **abstract** **void** method3();//子类负责实现业务逻辑  
17. \}

父类中有三个方法，分别是method1()，method2()和method3()。   
method1()是私有方法，有且只能由父类实现逻辑，由于方法是private的，所以只能父类调用。   
method2()是所谓的勾子方法。父类提供默认实现，如果子类觉得有必要定制，则可以覆盖父类的默认实现。   
method3()是子类必须实现的方法，即制定的步骤。   
由此可看出，算法的流程执行顺序是由父类掌控的，子类只能配合。   
  
下面我们来写第一个子类：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **class** TemplatePatternImpl **extends** TemplatePattern \{  
2.    
3.      @Override  
4.      **protected** **void** method3() \{  
5.          System.out.println("method3()在子类TemplatePatternImpl中实现了！！");  
6.    
7.      \}  
8.    
9.  \}

这个子类只覆盖了必须覆盖的方法，我们来测试一下：

Java代码  ![收藏代码][icon_star.png]

1.  TemplatePattern t1 = **new** TemplatePatternImpl();  
2.  t1.templateMethod();

在控制台中我们可以看到：

Java代码  ![收藏代码][icon_star.png]

1.  父类实现业务逻辑  
2.  父类默认实现，子类可覆盖  
3.  method3()在子类TemplatePatternImpl中实现了！！

OK，我们来看看勾子方法的使用：   
定义第2个子类，实现勾子方法：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **class** TemplatePatternImpl2 **extends** TemplatePattern \{  
2.    
3.      @Override  
4.      **protected** **void** method3() \{  
5.          System.out.println("method3()在子类TemplatePatternImpl2中实现了！！");  
6.    
7.      \}  
8.    
9.      /\* (non-Javadoc) 
10.      \* @see com.jak.pattern.template.example.TemplatePattern\#method2() 
11.      \*/  
12.     @Override  
13.     **public** **void** method2() \{  
14.         System.out.println("子类TemplatePatternImpl2覆盖了父类的method2()方法！！");  
15.     \}  
16.       
17. \}

来测试一下：

Java代码  ![收藏代码][icon_star.png]

1.  TemplatePattern t2 = **new** TemplatePatternImpl2();  
2.  t2.templateMethod();

我们看控制台：

Java代码  ![收藏代码][icon_star.png]

1.  父类实现业务逻辑  
2.  子类TemplatePatternImpl2覆盖了父类的method2()方法！！  
3.  method3()在子类TemplatePatternImpl2中实现了！！

OK，经典的模板模式回顾完了（大家不要拍砖哦~~~~~~~~~~）   
  
接下来，我们回到正题，自己模仿spring动手写一个基于模板模式和回调的jdbcTemplate。   
  
回顾一下，spring为什么要封装JDBC API，对外提供jdbcTemplate呢（不要仍鸡蛋啊￥·%￥\#%）   
话说SUN的JDBC API也算是经典了，曾经在某个年代折服了一批人。但随着历史的发展，纯粹的JDBC API已经过于底层，而且不易控制，由开发人员直接接触JDBC API，会造成不可预知的风险。还有，数据连接缓存池的发展，也不可能让开发人员去手工获取JDBC了。   
  
好了，我们来看一段曾经堪称经典的JDBC API代码吧：

Java代码  ![收藏代码][icon_star.png]

1.  **public** List<User> query() \{  
2.    
3.      List<User> userList = **new** ArrayList<User>();  
4.      String sql = "select \* from User";  
5.    
6.      Connection con = **null**;  
7.      PreparedStatement pst = **null**;  
8.      ResultSet rs = **null**;  
9.      **try** \{  
10.         con = HsqldbUtil.getConnection();  
11.         pst = con.prepareStatement(sql);  
12.         rs = pst.executeQuery();  
13.   
14.         User user = **null**;  
15.         **while** (rs.next()) \{  
16.   
17.             user = **new** User();  
18.             user.setId(rs.getInt("id"));  
19.             user.setUserName(rs.getString("user\_name"));  
20.             user.setBirth(rs.getDate("birth"));  
21.             user.setCreateDate(rs.getDate("create\_date"));  
22.             userList.add(user);  
23.         \}  
24.   
25.   
26.     \} **catch** (SQLException e) \{  
27.         e.printStackTrace();  
28.     \}**finally**\{  
29.         **if**(rs != **null**)\{  
30.             **try** \{  
31.                 rs.close();  
32.             \} **catch** (SQLException e) \{  
33.                 e.printStackTrace();  
34.             \}  
35.         \}  
36.         **try** \{  
37.             pst.close();  
38.         \} **catch** (SQLException e) \{  
39.             e.printStackTrace();  
40.         \}  
41.         **try** \{  
42.             **if**(!con.isClosed())\{  
43.                 **try** \{  
44.                     con.close();  
45.                 \} **catch** (SQLException e) \{  
46.                     e.printStackTrace();  
47.                 \}  
48.             \}  
49.         \} **catch** (SQLException e) \{  
50.             e.printStackTrace();  
51.         \}  
52.           
53.     \}  
54.     **return** userList;  
55. \}

上面的代码要若干年前可能是一段十分经典的，还可能被作为example被推广。但时过境迁，倘若哪位程序员现在再在自己的程序中出现以上代码，不是说明该公司的开发框架管理混乱，就说明这位程序员水平太“高”了。   
我们试想，一个简单的查询，就要做这么一大堆事情，而且还要处理异常，我们不防来梳理一下：   
1、获取connection   
2、获取statement   
3、获取resultset   
4、遍历resultset并封装成集合   
5、依次关闭connection,statement,resultset，而且还要考虑各种异常   
6、.....   
啊~~~~ 我快要晕了，在面向对象编程的年代里，这样的代码简直不能上人容忍。试想，上面我们只是做了一张表的查询，如果我们要做第2张表，第3张表呢，又是一堆重复的代码：   
1、获取connection   
2、获取statement   
3、获取resultset   
4、遍历resultset并封装成集合   
5、依次关闭connection,statement,resultset，而且还要考虑各种异常   
6、.....   
  
这时候，使用模板模式的时机到了！！！   
  
通过观察我们发现上面步骤中大多数都是重复的，可复用的，只有在遍历ResultSet并封装成集合的这一步骤是可定制的，因为每张表都映射不同的java bean。这部分代码是没有办法复用的，只能定制。那就让我们用一个抽象的父类把它们封装一下吧：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **abstract** **class** JdbcTemplate \{  
2.    
3.      //template method  
4.      **public** **final** Object execute(String sql) **throws** SQLException\{  
5.            
6.          Connection con = HsqldbUtil.getConnection();  
7.          Statement stmt = **null**;  
8.          **try** \{  
9.     
10.             stmt = con.createStatement();  
11.             ResultSet rs = stmt.executeQuery(sql);  
12.             Object result = doInStatement(rs);//abstract method   
13.             **return** result;  
14.         \}  
15.         **catch** (SQLException ex) \{  
16.              ex.printStackTrace();  
17.              **throw** ex;  
18.         \}  
19.         **finally** \{  
20.    
21.             **try** \{  
22.                 stmt.close();  
23.             \} **catch** (SQLException e) \{  
24.                 e.printStackTrace();  
25.             \}  
26.             **try** \{  
27.                 **if**(!con.isClosed())\{  
28.                     **try** \{  
29.                         con.close();  
30.                     \} **catch** (SQLException e) \{  
31.                         e.printStackTrace();  
32.                     \}  
33.                 \}  
34.             \} **catch** (SQLException e) \{  
35.                 e.printStackTrace();  
36.             \}  
37.               
38.         \}  
39.     \}  
40.       
41.     //implements in subclass  
42.     **protected** **abstract** Object doInStatement(ResultSet rs);  
43. \}

在上面这个抽象类中，封装了SUN JDBC API的主要流程，而遍历ResultSet这一步骤则放到抽象方法doInStatement()中，由子类负责实现。   
好，我们来定义一个子类，并继承上面的父类：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **class** JdbcTemplateUserImpl **extends** JdbcTemplate \{  
2.    
3.      @Override  
4.      **protected** Object doInStatement(ResultSet rs) \{  
5.          List<User> userList = **new** ArrayList<User>();  
6.            
7.          **try** \{  
8.              User user = **null**;  
9.              **while** (rs.next()) \{  
10.   
11.                 user = **new** User();  
12.                 user.setId(rs.getInt("id"));  
13.                 user.setUserName(rs.getString("user\_name"));  
14.                 user.setBirth(rs.getDate("birth"));  
15.                 user.setCreateDate(rs.getDate("create\_date"));  
16.                 userList.add(user);  
17.             \}  
18.             **return** userList;  
19.         \} **catch** (SQLException e) \{  
20.             e.printStackTrace();  
21.             **return** **null**;  
22.         \}  
23.     \}  
24.   
25. \}

由代码可见，我们在doInStatement()方法中，对ResultSet进行了遍历，最后并返回。   
有人可能要问：我如何获取ResultSet 并传给doInStatement()方法啊？？呵呵，问这个问题的大多是新手。因为此方法不是由子类调用的，而是由父类调用，并把ResultSet传递给子类的。我们来看一下测试代码：

Java代码  ![收藏代码][icon_star.png]

1.  String sql = "select \* from User";  
2.  JdbcTemplate jt = **new** JdbcTemplateUserImpl();  
3.  List<User> userList = (List<User>) jt.execute(sql);

就是这么简单！！   
  
文章至此仿佛告一段落，莫急！不防让我们更深入一些...   
  
试想，如果我每次用jdbcTemplate时，都要继承一下上面的父类，是不是有些不方面呢？   
那就让我们甩掉abstract这顶帽子吧，这时，就该callback（回调）上场了   
  
  
所谓回调，就是方法参数中传递一个接口，父类在调用此方法时，必须调用方法中传递的接口的实现类。   
  
那我们就来把上面的代码改造一下，改用回调实现吧：   
  
首先，我们来定义一个回调接口：

Java代码  ![收藏代码][icon_star.png]

1.  **public** **interface** StatementCallback \{  
2.      Object doInStatement(Statement stmt) **throws** SQLException;  
3.  \}

这时候，我们就要方法的签名改一下了：

Java代码  ![收藏代码][icon_star.png]

1.  **private** **final** Object execute(StatementCallback action) **throws** SQLException

里面的获取数据方式也要做如下修改：

Java代码  ![收藏代码][icon_star.png]

1.  Object result = action.doInStatement(stmt);//abstract method

为了看着顺眼，我们来给他封装一层吧：

Java代码  ![收藏代码][icon_star.png]

1.  **public** Object query(StatementCallback stmt) **throws** SQLException\{  
2.      **return** execute(stmt);  
3.  \}

OK，大功告成！   
我们来写一个测试类Test.java测试一下吧：   
这时候，访问有两种方式，一种是内部类的方式，一种是匿名方式。   
  
先来看看内部类的方式：

Java代码  ![收藏代码][icon_star.png]

1.  //内部类方式  
2.      **public** Object query(**final** String sql) **throws** SQLException \{  
3.          **class** QueryStatementCallback **implements** StatementCallback \{  
4.    
5.              **public** Object doInStatement(Statement stmt) **throws** SQLException \{  
6.                  ResultSet rs = stmt.executeQuery(sql);  
7.                  List<User> userList = **new** ArrayList<User>();  
8.    
9.                  User user = **null**;  
10.                 **while** (rs.next()) \{  
11.   
12.                     user = **new** User();  
13.                     user.setId(rs.getInt("id"));  
14.                     user.setUserName(rs.getString("user\_name"));  
15.                     user.setBirth(rs.getDate("birth"));  
16.                     user.setCreateDate(rs.getDate("create\_date"));  
17.                     userList.add(user);  
18.                 \}  
19.                 **return** userList;  
20.   
21.             \}  
22.   
23.         \}  
24.   
25.         JdbcTemplate jt = **new** JdbcTemplate();  
26.         **return** jt.query(**new** QueryStatementCallback());  
27.     \}

在调用jdbcTemplate.query()方法时，传一个StatementCallBack()的实例过去，也就是我们的内部类。   
  
再来看看匿名方式：

Java代码  ![收藏代码][icon_star.png]

1.  //匿名类方式  
2.      **public** Object query2(**final** String sql) **throws** Exception\{  
3.            
4.          JdbcTemplate jt = **new** JdbcTemplate();  
5.          **return** jt.query(**new** StatementCallback() \{  
6.                
7.              **public** Object doInStatement(Statement stmt) **throws** SQLException \{  
8.                  ResultSet rs = stmt.executeQuery(sql);  
9.                  List<User> userList = **new** ArrayList<User>();  
10.   
11.                 User user = **null**;  
12.                 **while** (rs.next()) \{  
13.   
14.                     user = **new** User();  
15.                     user.setId(rs.getInt("id"));  
16.                     user.setUserName(rs.getString("user\_name"));  
17.                     user.setBirth(rs.getDate("birth"));  
18.                     user.setCreateDate(rs.getDate("create\_date"));  
19.                     userList.add(user);  
20.                 \}  
21.                 **return** userList;  
22.   
23.             \}  
24.         \});  
25.           
26.     \}

相比之下，这种方法更为简洁。   
为什么spring不用传统的模板方法，而加之以Callback进行配合呢？

试想，如果父类中有10个抽象方法，而继承它的所有子类则要将这10个抽象方法全部实现，子类显得非常臃肿。而有时候某个子类只需要定制父类中的某一个方法该怎么办呢？这个时候就要用到Callback回调了。

最后的源码为：

**\[java\]** [view plain][] [copy][view plain]

1.  **package** com.jak.pattern.template.callbacktemplate;  
2.  **import** java.sql.SQLException;  
3.  **import** java.sql.Statement;  
4.  //<span style="font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 25.200000762939453px;">回调接口</span>  
5.  **public** **interface** StatementCallback \{  
6.      Object doInStatement(Statement stmt) **throws** SQLException;  
7.  \}

**\[java\]** [view plain][] [copy][view plain]

1.  **public** **class** JdbcTemplate \{  
2.      //template method  
3.      **private** **final** Object execute(StatementCallback action) **throws** SQLException\{   
4.          Connection con = HsqldbUtil.getConnection();  
5.          Statement stmt = **null**;  
6.          **try** \{  
7.              stmt = con.createStatement();  
8.              Object result = action.doInStatement(stmt);//abstract method   
9.              **return** result;  
10.         \}  
11.         **catch** (SQLException ex) \{  
12.              ex.printStackTrace();  
13.              **throw** ex;  
14.         \}  
15.         **finally** \{  
16.             **try** \{  
17.                 stmt.close();  
18.             \} **catch** (SQLException e) \{  
19.                 e.printStackTrace();  
20.             \}  
21.             **try** \{  
22.                 **if**(!con.isClosed())\{  
23.                     **try** \{  
24.                         con.close();  
25.                     \} **catch** (SQLException e) \{  
26.                         e.printStackTrace();  
27.                     \}  
28.                 \}  
29.             \} **catch** (SQLException e) \{  
30.                 e.printStackTrace();  
31.             \}  
32.         \}  
33. \}  
34.    
35.     **public** Object query(StatementCallback stmt) **throws** SQLException\{  
36.           
37.            
38.         **return** execute(stmt);  
39.     \}  
40. \}

**\[java\]** [view plain][] [copy][view plain]

1.  //调用测试类

**\[java\]** [view plain][] [copy][view plain]

1.  **public** **class** Test \{  
2.        
3.      //内部类方式  
4.      **public** Object query(**final** String sql) **throws** SQLException \{  
5.          **class** QueryStatementCallback **implements** StatementCallback \{  
6.    
7.              **public** Object doInStatement(Statement stmt) **throws** SQLException \{  
8.                  ResultSet rs = stmt.executeQuery(sql);  
9.                  List<User> userList = **new** ArrayList<User>();  
10.   
11.                 User user = **null**;  
12.                 **while** (rs.next()) \{  
13.   
14.                     user = **new** User();  
15.                     user.setId(rs.getInt("id"));  
16.                     user.setUserName(rs.getString("user\_name"));  
17.                     user.setBirth(rs.getDate("birth"));  
18.                     user.setCreateDate(rs.getDate("create\_date"));  
19.                     userList.add(user);  
20.                 \}  
21.                 **return** userList;  
22.   
23.             \}  
24.   
25.         \}  
26.   
27.         JdbcTemplate jt = **new** JdbcTemplate();  
28.         **return** jt.query(**new** QueryStatementCallback());  
29.     \}  
30.   
31.     //匿名类方式  
32.     **public** Object query2(**final** String sql) **throws** Exception\{  
33.           
34.         JdbcTemplate jt = **new** JdbcTemplate();  
35.         **return** jt.query(**new** StatementCallback() \{  
36.               
37.             **public** Object doInStatement(Statement stmt) **throws** SQLException \{  
38.                 ResultSet rs = stmt.executeQuery(sql);  
39.                 List<User> userList = **new** ArrayList<User>();  
40.   
41.                 User user = **null**;  
42.                 **while** (rs.next()) \{  
43.   
44.                     user = **new** User();  
45.                     user.setId(rs.getInt("id"));  
46.                     user.setUserName(rs.getString("user\_name"));  
47.                     user.setBirth(rs.getDate("birth"));  
48.                     user.setCreateDate(rs.getDate("create\_date"));  
49.                     userList.add(user);  
50.                 \}  
51.                 **return** userList;  
52.   
53.             \}  
54.         \});  
55.           
56.     \}  
57.     **public** **static** **void** main(String\[\] args) **throws** Exception \{  
58.   
59.         String sql = "select \* from User";  
60.         Test t = **new** Test();  
61.           
62.         List<User> userList = (List<User>) t.query(sql);  
63.         List<User> userList2 = (List<User>) t.query2(sql);  
64.         System.out.println(userList);  
65.         System.out.println(userList2);  
66.     \}  
67. \}

言归正传，有了上面的基础后，我们正式开始阅读源码：

下面几个接口是对变化的部分进行建模

接口：创建PreparedStatement。根据Connection来创建PreparedStatement。

1.  **public** **interface** PreparedStatementCreator \{  
2.       PreparedStatement createPreparedStatement (Connection conn)  
3.         **throws** SQLException;  
4.     \}

使用方法就是：

1.  PreparedStatementCreator psc = **new** PreparedStatementCreator() \{  
2.    
3.       **public** PreparedStatement createPreparedStatement (Connection conn)  
4.           **throws** SQLException \{  
5.         PreparedStatement ps = conn. prepareStatement (  
6.           "SELECT seat\_id AS id FROM available\_seats WHERE " +  
7.           "performance\_id = ? AND price\_band\_id = ?");  
8.         ps.setInt(1, performanceId);  
9.         ps.setInt(2, seatType);  
10.        **return** ps;  
11.      \}  
12.    \};

给PreparedStatement设置参数。是对PreparedStatmentCreator的设置ps值的一个补充。

1.  **public** **interface** PreparedStatementSetter \{  
2.      **void** setValues(PreparedStatement ps) **throws** SQLException;  
3.  \}

对ResultSet进行处理。还有具体的子类。

1.  **public** **interface** RowCallbackHandler \{  
2.       **void** processRow(ResultSet rs) **throws** SQLException;  
3.     \}

使用方式：

1.   RowCallbackHandler rch = **new** RowCallbackHandler() \{  
2.     **public** **void** processRow(ResultSet rs) **throws** SQLException \{  
3.       **int** seatId = rs.getInt(1) ;  
4.       list.add(**new** Integer (seatId) );//典型的inner **class**的应用，list为外部类的变量。    
5.     \}  
6.   \};

和上面的RowCallbackHandler类似。

1.  **public** **interface** ResultSetExtractor \{    
2.        Object extractData(ResultSet rs) **throws** SQLException, DataAccessException;    
3.  \}   
4.

下面是JdbcTemplate中提供的模板方法。该方法完成对数据库的查询:)。  
       这个execute()方法非常关键。

1.  **public** Object query(  
2.              PreparedStatementCreator psc, **final** PreparedStatementSetter pss, **final** ResultSetExtractor rse)  
3.              **throws** DataAccessException \{  
4.    
5.          Assert.notNull(rse, "ResultSetExtractor must not be null");  
6.    
7.          **if** (logger.isDebugEnabled()) \{  
8.              String sql = getSql(psc); //取得不变的SQL部分。 
9.              logger.debug("Executing SQL query" + (sql != **null** ? " \[" + sql  + "\]" : ""));  
10.         \}  
11.         **return** execute(psc, **new** PreparedStatementCallback() \{  
12.             **public** Object doInPreparedStatement(PreparedStatement ps) **throws** SQLException \{  
13.                 ResultSet rs = **null**;  
14.                 **try** \{  
15.                     **if** (pss != **null**) \{  
16.                         **pss.setValues(ps);****/**/就是给ps来设置参数用的。ps.setInt(1, 0);  
17.                     \}  
18.   
19.                     **rs = ps.executeQuery();**//执行查询  
20.   
21.                     ResultSet rsToUse = rs;  
22.                     **if** (nativeJdbcExtractor != **null**) \{  
23.                         rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);  
24.                     \}  
25.                     **return** **rse.extractData(rsToUse);** // ResultSetExtractor从ResultSet中将值取出List。  
26.   
27.                 \}  
28.                 **finally** \{  
29.                     //最后的善后工作还是需要做好的:) rs.close()，把ps的相关参数清除掉。  
30.                    ** JdbcUtils.closeResultSet(rs); ** 
31.                     **if** (pss **instanceof** ParameterDisposer) \{  
32.                         ((ParameterDisposer) pss).cleanupParameters();  
33.                     \}  
34.                 \}  
35.             \}  
36.         \});  
37.     \}

看看execute()方法吧。

java 代码

1.  **public** Object execute(PreparedStatementCreator psc, PreparedStatementCallback action)  
2.              **throws** DataAccessException \{  
3.    
4.          Assert.notNull(psc, "PreparedStatementCreator must not be null");  
5.          Assert.notNull(action, "Callback object must not be null");  
6.    
7.          //取得数据库的连接  
8.         ** Connection con = DataSourceUtils.getConnection(getDataSource());  **
9.          PreparedStatement ps = **null**;  
10.         **try** \{  
11.             Connection conToUse = con;  
12.             **if** (**this**.nativeJdbcExtractor != **null** &&  
13.                     **this**.nativeJdbcExtractor.isNativeConnectionNecessaryForNativePreparedStatements()) \{  
14.                 conToUse = **this**.nativeJdbcExtractor.getNativeConnection(con);  
15.             \}  
16.             //创建PreparedStatement  
17.             **ps = psc.createPreparedStatement(conToUse);  **
18.   
19.             **applyStatementSettings(ps);**//这个方法是设置ps的一些属性，我平时不用，Spring框架倒是考虑得相当全的说。  
20.               
21.             PreparedStatement psToUse = ps;  
22.             **if** (**this**.nativeJdbcExtractor != **null**) \{  
23.                 psToUse = **this**.nativeJdbcExtractor.getNativePreparedStatement(ps);  
24.             \}  
25.             //调用Callback来完成PreparedStatement的设值。就是调用上面的doInPreparedStatement来使用ps。  
26.             **Object result = action.doInPreparedStatement(psToUse);  **
27.             
28.             SQLWarning warning = ps.getWarnings();  
29.             throwExceptionOnWarningIfNotIgnoringWarnings(warning);  
30.             **return** result;  
31.         \}  
32.         //如果有错误的话，那么就开始ps.close(), connection.close();  
33.         **catch** (SQLException ex) \{  
34.             // Release Connection early, to avoid potential connection pool deadlock  
35.             // in the case when the exception translator hasn't been initialized yet.  
36.             **if** (psc **instanceof** ParameterDisposer) \{  
37.                 ((ParameterDisposer) psc).cleanupParameters();  
38.             \}  
39.             String sql = getSql(psc);  
40.             psc = **null**;  
41.             **JdbcUtils.closeStatement(ps);**  //就是ps.close();
42.             ps = **null**;  
43.            ** DataSourceUtils.releaseConnection(con, getDataSource());** /  
44.             con = **null**;  
45.             **throw** getExceptionTranslator().translate("PreparedStatementCallback", sql, ex);  
46.         \}  
47.         //不管怎么样，ps.close(), Connection.close()吧，当然这里是releaseConnection。在我的程序中，Connection只有一个，没有ConnectionPool，当然不会去close Connection。一般来讲，如果没有Connection的线程池的话，我们肯定也不会经常的关闭Connection，得到Connection。毕竟这个东西非常耗费资源。  
48.         **finally** \{  
49.             **if** (psc **instanceof** ParameterDisposer) \{  
50.                 ((ParameterDisposer) psc).cleanupParameters();  
51.             \}  
52.            ** JdbcUtils.closeStatement(ps);  **
53. **            DataSourceUtils.releaseConnection(con, getDataSource()); ** 
54.         \}  
55.     \}

JdbcTemplate完成了负责的操作，客户只需要调用query()就可以完成查询操作了。当然，JdbcTemplate会实现很多带其它参数的方法，以方便你的使用。Template设计模式被发扬广大了。

DataSourceUtils：这个专门用于管理数据库Connection的类。

1.  **public** **static** Connection getConnection(DataSource dataSource) **throws** CannotGetJdbcConnectionException \{  
2.          **try** \{  
3.              **return** **doGetConnection(dataSource);**  
4.                  ~~~~~~ //这个方法很舒服，Spring Framework中到处有这样的方法。为什么要委派到这个动作方法？  
5.          \}  
6.          **catch** (SQLException ex) \{  
7.              **throw** **new** CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);  
8.          \}  
9.      \}

这里的doGetConnection就稍微复杂一点了。但是如果没有事务同步管理器的话，那就比较简单。  
只是在Connection上多了一个ConnecionHolder类用于持有Connection，实现ConnectionPool的一点小功能。

1.  **public** **static** Connection doGetConnection(DataSource dataSource) **throws** SQLException \{  
2.          Assert.notNull(dataSource, "No DataSource specified");  
3.    
4.          ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);  
5.          ~~~~~//Connection的持有器。通过持有器得到Connection。
6.          **if** (conHolder != **null** && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) \{  
7.              conHolder.requested();  
8.              **if** (!conHolder.hasConnection()) \{  
9.                  logger.debug("Fetching resumed JDBC Connection from DataSource");  
10.                 conHolder.setConnection(dataSource.getConnection());  
11.             \}  
12.             **return** **conHolder.getConnection(); ** 
13.         \}  
14.         // Else we either got no holder or an empty thread-bound holder here.  
15.   
16.         logger.debug("Fetching JDBC Connection from DataSource");  
17.         Connection con = dataSource.getConnection();   
18.         ……
19.         **return** con;  
20.     \}

ConnectionHolder：Connection的持有器。通过ConnectionHandler来完成对Connection的操作:) 典型的委派。

1.  **public** **class** ConnectionHolder **extends** ResourceHolderSupport \{  
2.        
3.      **private** Connection currentConnection; //当前的Connection  
4.      **private ConnectionHandle connectionHandle;**  //Connection的处理器，因此可以通过该类完成对connection的管理。  
5.    
6.      **public** ConnectionHolder(Connection connection) \{  
7.          **this**.connectionHandle = **new** SimpleConnectionHandle(connection);  
8.      \}  
9.        
10.     **public** ConnectionHolder(ConnectionHandle connectionHandle) \{  
11.         Assert.notNull(connectionHandle, "ConnectionHandle must not be null");  
12.         **this**.connectionHandle = connectionHandle;  
13.     \}  
14.   
15.     **public** Connection getConnection() \{  
16.         Assert.notNull(**this**.connectionHandle, "Active Connection is required");  
17.         **if** (**this**.currentConnection == **null**) \{  
18.             **this**.currentConnection = **this**.connectionHandle.getConnection();  
19.         \}  
20.         **return** **this**.currentConnection;  
21.     \}  
22.   
23.     **public** **void** released() \{  
24.         **super**.released();  
25.         **if** (**this**.currentConnection != **null**) \{  
26.             **this**.connectionHandle.releaseConnection(**this**.currentConnection);  
27.             **this**.currentConnection = **null**;  
28.         \}  
29.     \}

connectionHandle 的接口太纯粹了。但是我觉得这个设计太过于细致了:)

1.  **public** **interface** ConnectionHandle \{  
2.    
3.      /\*\* 
4.       \* Fetch the JDBC Connection that this handle refers to. 
5.       \*/  
6.      Connection getConnection();  
7.    
8.      /\*\* 
9.       \* Release the JDBC Connection that this handle refers to. 
10.      \* @param con the JDBC Connection to release 
11.      \*/  
12.     **void** releaseConnection(Connection con);  
13.   
14. \}

最后看一下SimpleConnectionHandle，这个ConnectionHandle的简单实现类。就只有一个Connection可管理。如果有多个Connection可管理的话，这里就是ConnectionPool了:)

java 代码

1.  **public** **class** SimpleConnectionHandle **implements** ConnectionHandle \{  
2.    
3.      **private** **final** Connection connection;  
4.    
5.    
6.      /\*\* 
7.       \* Create a new SimpleConnectionHandle for the given Connection. 
8.       \* @param connection the JDBC Connection 
9.       \*/  
10.     **public** SimpleConnectionHandle(Connection connection) \{  
11.         Assert.notNull(connection, "Connection must not be null");  
12.         **this**.connection = connection;  
13.     \}  
14.   
15.     /\*\* 
16.      \* Return the specified Connection as-is. 
17.      \*/  
18.     **public** Connection getConnection() \{  
19.         **return** connection;  
20.     \}  
21.   
22.     /\*\* 
23.      \* This implementation is empty, as we're using a standard 
24.      \* Connection handle that does not have to be released. 
25.      \*/  
26.     **public** **void** releaseConnection(Connection con) \{  
27.     \}  
28.   
29.   
30.     **public** String toString() \{  
31.         **return** "SimpleConnectionHandle: " + **this**.connection;  
32.     \}  
33.

1.  \}

转自：https://blog.csdn.net/songjinbin/article/details/19857567

[icon_star.png]: /images/20220527/dac0f44ed76d43f69b8d56f098ad7048.png
[view plain]: https://blog.csdn.net/songjinbin/article/details/19857567#

发表评论取消回复

表情：

评论列表（有 0 条评论，156人围观）

还没有评论，来说两句吧...

相关阅读

相关 ReentrantReadWriteLock源码深度剖析

1. ReentrantReadWriteLock 定义 ReentrantReadWriteLock: Reentrant(重入) Read (读) Write(写)

淡淡的烟草味﹌/ 2023年10月04日 09:03/ 0 赞/ 71 阅读

相关 Spring JdbcTemplate源码

[spring-framework/JdbcTemplate.java at main · spring-projects/spring-framework · GitHub]

Dear 丶/ 2023年09月26日 09:08/ 0 赞/ 15 阅读

相关 libevent源码深度剖析十

libevent源码深度剖析十 ——支持I/O多路复用技术张亮 Libevent的核心是事件驱动、同步非阻塞，为了达到这一目标，必须采用系统提供的I/

小咪咪/ 2022年08月07日 07:57/ 0 赞/ 186 阅读

相关 libevent源码深度剖析一

libevent源码深度剖析一 ——序幕张亮 1 前言 Libevent是一个轻量级的开源高性能网络库，使用者众多，研究者更甚，相关文章也不少。写这一

超、凢脫俗/ 2022年08月07日 06:59/ 0 赞/ 186 阅读

相关 libevent源码深度剖析三

libevent源码深度剖析三 ——libevent基本使用场景和事件流程张亮 1 前言学习源代码该从哪里入手？我觉得从程序的基本使用场景和代码的整体处理

偏执的太偏执、/ 2022年08月07日 06:59/ 0 赞/ 214 阅读

相关 libevent源码深度剖析五

libevent源码深度剖析五 ——libevent的核心：事件event 张亮对事件处理流程有了高层的认识后，本节将详细介绍libe

妖狐艹你老母/ 2022年08月07日 06:59/ 0 赞/ 236 阅读

相关 libevent源码深度剖析六

libevent源码深度剖析六 ——初见事件处理框架张亮前面已经对libevent的事件处理框架和event结构体做了描述，现在是时候剖析libevent对事

水深无声/ 2022年08月07日 06:59/ 0 赞/ 207 阅读

相关 Spring JdbcTemplate源码深度剖析

在Spring中，JdbcTemplate是经常被使用的类来帮助用户程序操作数据库，在JdbcTemplate为用户程序提供了许多便利的数据库操作方法，比如查询，更新等，而且在

深藏阁楼爱情的钟/ 2022年05月27日 05:05/ 0 赞/ 157 阅读

相关 Spring AOP 原理源码深度剖析

> 本文转载于公众号：吉姆餐厅ak 概述 AOP(Aspect-Oriented Programming) 面向切面编程。Spring Aop 在 Spring框架中的地

秒速五厘米/ 2022年04月05日 20:11/ 0 赞/ 241 阅读

相关集成源码深度剖析：Fescar x Spring Cloud

Fescar 简介常见的分布式事务方式有基于 2PC 的 XA (e.g. atomikos)，从业务层入手的 TCC( e.g. byteTCC)、事务消息 ( e.

àì夳堔傛蜴生んèń/ 2022年02月13日 02:59/ 0 赞/ 225 阅读