Spring3核心技术之JdbcTemplate

Spring对JDBC的支持 
       Spring通过抽象JDBC访问并提供一致的API来简化JDBC编程的工作量。我们只需要声明SQL、调用合适的Spring JDBC框架API、处理结果集即可。事务由Spring管理，并将JDBC受查异常转换为Spring一致的非受查异常，从而简化开发。  

Java代码   

1. ....  
2.     Connection conn = null;    
3.     PreparedStatement pstmt = null;  
4.     try {  
5.       conn = getConnection();              //1.获取JDBC连接      
6.       String sql = "select * from tableName"; //2.声明SQL  
7.       pstmt = conn.prepareStatement(sql);    //3.预编译SQL    
8.       ResultSet rs = pstmt.executeQuery();   //4.执行SQL    
9.       process(rs);                       //5.处理结果集    
10.       closeResultSet(rs);                 //5.释放结果集    
11.       closeStatement(pstmt);              //6.释放Statement    
12.       conn.commit();                    //8.提交事务    
13.     } catch (Exception e) {    
14.       //9.处理异常并回滚事务    
15.       conn.rollback();    
16.       throw e;    
17.     } finally {    
18.       //10.释放JDBC连接，防止JDBC连接不关闭造成的内存泄漏    
19.       closeConnection(conn);    
20.     }  
21. ....  

以上代码片段具有冗长、重复、容易忘记某一步骤从而导致出错、显示控制事务、显示处理受检查异常等等。 
       Spring主要提供JDBC模板方式、关系数据库对象化方式和SimpleJdbc方式三种方式来简化JDBC编程，这三种方式就是Spring JDBC的工作模式： 
Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。 

JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部分），并且帮我们做哪些固定部分，如连接的创建及关闭。 
 

• JDBC模板方式：Spring JDBC框架提供以下几种模板类来简化JDBC编程，实现GoF模板设计模式，将可变部分和非可变部分分离，可变部分采用回调接口方式由用户来实现：如JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate。
• 关系数据库操作对象化方式：Spring JDBC框架提供了将关系数据库操作对象化的表示形式，从而使用户可以采用面向对象编程来完成对数据库的访问；如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类。这些类的实现一旦建立即可重用并且是线程安全的。
• SimpleJdbc方式：Spring JDBC框架还提供了SimpleJdbc方式来简化JDBC编程，SimpleJdbcInsert 、 SimpleJdbcCall用来简化数据库表插入、存储过程或函数访问。

Spring JDBC还提供了一些强大的工具类，如DataSourceUtils来在必要的时候手工获取数据库连接等。 

Spring的JDBC架构 
Spring JDBC抽象框架由四部分组成：datasource、support、core、object如图所示。 
 

• support包：提供将JDBC异常转换为DAO非检查异常转换类、一些工具类如JdbcUtils等。
• datasource包：提供简化访问JDBC 数据源（javax.sql.DataSource实现）工具类，并提供了一些DataSource简单实现类从而能使从这些DataSource获取的连接能自动得到Spring管理事务支持。
• core包：提供JDBC模板类实现及可变部分的回调接口，还提供SimpleJdbcInsert等简单辅助类。
• object包：提供关系数据库的对象表示形式，如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类，该包是基于core包JDBC模板类实现。

 
SpringJDbc工程中需要引入以下JAR包： 
 

Spring JDBC提供如下DaoSupport实现： 
● JdbcDaoSupport：用于支持一致的JdbcTemplate访问； 
● NamedParameterJdbcDaoSup port:继承JdbcDaoSupport，同时提供NamedParameterJdbcTempla te访问； 
● SimpleJdbcDaoSupport：继承JdbcDaoSupport，同时提供SimpleJdbcTemplate访问。 
由于JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate类使用DataSourceUtils获取及释放连接，而且连接是与线程绑定的，因此这些JDBC模板类是线程安全的，即JdbcTemplate对象可以在多线程中重用 

JdbcTemplate 
JdbcTemplate主要提供以下五类方法： 

• execute()：可以用于执行任何SQL语句，一般用于执行DDL语句；
• update()及batchUpdate()：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
• query()及queryForXXX()：用于执行查询相关语句；
• call()：用于执行存储过程、函数相关语句。

JdbcTemplate类支持的回调类： 
●  预编译语句及存储过程创建回调：用于根据JdbcTemplate提供的连接创建相应的语句； 
                PreparedStatementCreator ：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的PreparedStatement； 
                CallableStatementCreator ：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的CallableStatement； 
●  预编译语句设值回调：用于给预编译语句相应参数设值； 
                PreparedStatementSetter：通过回调获取JdbcTemplate提供的PreparedStatement，由用户来对相应的预编译语句相应参数设值； 
                BatchPreparedStatementSe tter：；类似于PreparedStatementSetter，但用于批处理，需要指定批处理大小； 
●  自定义功能回调：提供给用户一个扩展点，用户可以在指定类型的扩展点执行任何数量需要的操作； 
                ConnectionCallback：通过回调获取JdbcTemplate提供的Connection，用户可在该Connection执行任何数量的操作； 
                StatementCallback：通过回调获取JdbcTemplate提供的Statement，用户可以在该Statement执行任何数量的操作； 
                PreparedStatementCallbac k：通过回调获取JdbcTemplate提供的PreparedStatement，用户可以在该PreparedStatement执行任何数量的操作； 
                CallableStatementCallbac k：通过回调获取JdbcTemplate提供的CallableStatement，用户可以在该CallableStatement执行任何数量的操作； 
●  结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式； 
                RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。 
                RowCallbackHandler：用于处理ResultSet的每一行结果，用户需实现方法processRow(ResultSet rs)来完成处理，在该回调方法中无需执行rs.next()，该操作由JdbcTemplate来执行，用户只需按行获取数据然后处理即可。 
                ResultSetExtractor：用于结果集数据提取，用户需实现方法extractData(ResultSet rs)来处理结果集，用户必须处理整个结果集；  

Java代码   

1.   
2. public class JdbcTemplateDao extends JdbcDaoSupport{  
3.       
4.     public void setDadasource(DataSource dataSource) {  
5.         super.setDataSource(dataSource);  
6.     }  
7.   
8.     public void commonSql() {  
9.         String insertSql = "insert into tab_item values(?,?,?)";  
10.         String updateSql = "update tab_item set itemno = ?, itemname = ? where id = ?";  
11.         String deleteSql = "delete tab_item where id = ?";  
12.   
13.         Assert.isTrue(  
14.         getJdbcTemplate().update(insertSql, new Object[]{4, "HP", "PT540"}) == 1, "插入失败");  
15.         Assert.isTrue(  
16.         getJdbcTemplate().update(updateSql, new Object[]{"HP", "PT555", 4}) == 1, "修改失败");  
17.         Assert.isTrue(  
18.         getJdbcTemplate().update(deleteSql, new Object[]{4}) == 1, "删除失败");  
19.     }  
20.       
21.       
22.     public void preparedStatementSql() {  
23.         String sql = "insert into tab_item values(?,?,?)";  
24.         int row = getJdbcTemplate().update(sql, new PreparedStatementSetter() {  
25.             @Override  
26.             public void setValues(PreparedStatement ps) throws SQLException {  
27.                 ps.setInt(1, 101);// JDBC占位符集合的序号是从1开始的，而不是0  
28.                 ps.setObject(2, "Apple");  
29.                 ps.setString(3, "Ipad4");  
30.             }  
31.         });  
32.         Assert.isTrue(row == 1, "插入失败");  
33.   
34.         // JdbcTemplate也提供一种更简单的方式设值相应的占位符位置的值  
35.         sql = "delete from tab_item where id = ?";  
36.         row = getJdbcTemplate().update(sql, new Object[] { 101 });  
37.         Assert.isTrue(row == 1, "删除失败");  
38.     }  
39.   
40.     public void queryCallback() {  
41.         String listSql = "select * from player";  
42.           
43.           
44.         List
45.             @Override  
46.             public Map mapRow(ResultSet rs, int rowNum) throws SQLException {  
47.                 System.out.println(rowNum);  
48.                 Map map = new HashMap();    
49.                 map.put(rs.getLong("id"), rs.getString("name"));  
50.                 return map;  
51.             }  
52.         });  
53.         Iterator it = result.iterator();  
54.         while (it.hasNext()) {  
55.             Map map = (Map) it.next();  
56.             System.out.println(map.values());  
57.         }  
58.           
59.           
60.         getJdbcTemplate().query(listSql, new RowCallbackHandler() {  
61.             @Override  
62.             public void processRow(ResultSet rs) throws SQLException {  
63.                 System.out.println("处理结果集");  
64.                 System.out.print("id:" + rs.getInt("id") + "***");  
65.                 System.out.println("name:" + rs.getString("name"));  
66.             }  
67.         });  
68.           
69.           
70.         List list = getJdbcTemplate().query(listSql, new ResultSetExtractor() {  
71.             @Override  
72.             public List extractData(ResultSet rs) throws SQLException,DataAccessException {  
73.                 List result = new ArrayList();    
74.                 while(rs.next()) {  
75.                     Map row = new HashMap();  
76.                     row.put(rs.getInt("id"), rs.getString("name"));  
77.                     result.add(row);  
78.                     System.out.println(row);  
79.                 }  
80.                 return result;  
81.             }  
82.         });  
83.     }  
84.       
85.       
86.     private void queryForSimple() {  
87.         //1.查询一行数据并返回int型结果    
88.         int countRs = getJdbcTemplate().queryForInt("select count(*) from player");  
89.         System.out.println(countRs);  
90.           
91.         //2. 查询一行数据并将该行数据转换为Map返回    
92.         Map map = getJdbcTemplate().queryForMap("select * from tab_item where id = ?", new Object[]{100});  
93.         System.out.println(map.values());  
94.           
95.         //3.查询一行任何类型的数据，最后一个参数指定返回结果类型    
96.         countRs = getJdbcTemplate().queryForObject("select count(*) from player", Integer.class);  
97.         System.out.println(countRs);  
98.           
99.         //4.查询一批数据，默认将每行数据转换为Map         
100.         List
101.         System.out.println(list.get(0).values());  
102.           
103.         //5.只查询一列数据列表，列类型是String类型，列名字是name  
104.         List names = getJdbcTemplate().queryForList("select itemname from tab_item where itemname=?", new Object[]{"雷蛇鼠标"}, String.class);  
105.         System.out.println(names.size());  
106.           
107.         //6.查询一批数据，返回为SqlRowSet，类似于ResultSet，但不再绑定到连接上    
108.         SqlRowSet rs = getJdbcTemplate().queryForRowSet("select * from player");  
109.     }  
110.   
111.       
112.     public void createProcedure() {  
113.             String createTableSql = "create memory table test" +    
114.             "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +    
115.             "name varchar(100))";    
116.               
117.             String dropTableSql = "drop table test";   
118.                    
119.             String createHsqldbFunctionSql =    
120.               "CREATE FUNCTION FUNCTION_TEST(str CHAR(100)) " +    
121.               "returns INT begin atomic return length(str);end";    
122.             getJdbcTemplate().update(createHsqldbFunctionSql);  
123.               
124.             String createProcedureSql =    
125.               "CREATE PROCEDURE PROCEDURE_TEST" +    
126.               "(INOUT inOutName VARCHAR(100), OUT outId INT) " +    
127.               "MODIFIES SQL DATA " +    
128.               "BEGIN ATOMIC " +    
129.               "  insert into test(name) values (inOutName); " +    
130.               "  SET outId = IDENTITY(); " +    
131.               "  SET inOutName = 'Hello,' + inOutName; " +    
132.             "END";  
133.               
134.             getJdbcTemplate().update(createTableSql);    
135.             getJdbcTemplate().execute(createProcedureSql);  
136.               
137.             getJdbcTemplate().execute("DROP FUNCTION FUNCTION_TEST");    
138.             getJdbcTemplate().execute("DROP PROCEDURE PROCEDURE_TEST");    
139.                
140.             getJdbcTemplate().execute(dropTableSql);   
141.     }  
142.   
143.     public static DriverManagerDataSource getMyDataSource() {  
144.         DriverManagerDataSource dataSource = new DriverManagerDataSource(url,  
145.                 username, password);  
146.         dataSource.setDriverClassName(driver);  
147.         return dataSource;  
148.     }  
149. }  

NamedParameterJdbcTemplate 
NamedParameterJdbcTemplate类是基于JdbcTemplate类，并对它进行了封装从而支持命名参数特性。NamedParameterJdbcTemplate主要提供以下三类方法： execute方法、 query及queryForXXX方法、update及batchUpdate方法。  

Java代码   

1.   
2. public class NamedParameterJdbcTemplateDao extends NamedParameterJdbcDaoSupport{  
3.       
4.     public void setDadasource(DataSource dataSource) {  
5.         super.setDataSource(dataSource);  
6.     }  
7.   
8.     public void commonSql() {  
9.         //可以使用DataSource或JdbcTemplate对象作为构造器参数初始化  
10.         namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(getJdbcTemplate());  
11.         String insertSql = "insert into tab_item values(:id, :itemno, :itemname)";  
12.         String deleteSql = "delete from tab_item where id = :id";  
13.         String selectSql = "select * from player where place = :place";  
14.   
15.         //NamedParameterJdbcTemplate类为命名参数设值有两种方式：java.util.Map和SqlParameterSource  
16.         Map paramMap = new HashMap();  
17.         paramMap.put("id", 101);  
18.         paramMap.put("itemno", "Menzu");  
19.         paramMap.put("itemname", "MP4");  
20.         int row = namedParameterJdbcTemplate.update(insertSql, paramMap);  
21.         Assert.isTrue(row == 1, "插入失败");  
22.   
23.           
24.         //Map paramMap2 = new HashMap();  
25.         //paramMap2.put("id", 1);  
26.         //SqlParameterSource paramSource = new MapSqlParameterSource(paramMap2);  
27.           
28.         Item model = new Item();  
29.         model.setId(101l);  
30.         SqlParameterSource paramSource = new BeanPropertySqlParameterSource(model);  
31.           
32.         row = namedParameterJdbcTemplate.update(deleteSql, paramSource);  
33.         Assert.isTrue(row == 1, "删除失败");  
34.           
35.         Map paramMap1 = new HashMap();  
36.         paramMap1.put("place","PG   ");  
37.         namedParameterJdbcTemplate.query(selectSql, paramMap1, new RowCallbackHandler() {  
38.             @Override  
39.             public void processRow(ResultSet rs) throws SQLException {  
40.                 System.out.println(rs.getString("name"));  
41.             }  
42.         });  
43.     }  
44. }  
45.   
46. public class Item {  
47.     private Long id;  
48.     private String itemno;  
49.     private String itemname;  
50.       
51.     //省略get和set方法  
52. }  

SimpleJdbcTemplate 
SimpleJdbcTemplate类也是基于JdbcTemplate类，但利用Java5+的可变参数列表和自动装箱和拆箱从而获取更简洁的代码。但是SimpleJdbcDaoSupport在Spring3.X中已经不推荐使用了。  

Java代码   

1.   
2. public class SimpleJdbcTemplateDao extends SimpleJdbcDaoSupport{  
3.       
4.     public void setDadasource(DataSource dataSource) {  
5.         super.setDataSource(dataSource);  
6.     }  
7.   
8.     public void commonSql() {  
9.         String insertSql = "update tab_item set itemno = :itemno where itemno = :itemno2";  
10.         int rows = getSimpleJdbcTemplate().update(insertSql, "APPLE", "Apple");  
11.         System.out.println(rows);  
12.     }  
13. }  

SimpleJdbc 
Spring JDBC抽象框架提供SimpleJdbcInsert和SimpleJdbcCall类，这两个类通过利用JDBC驱动提供的数据库元数据来简化JDBC操作。下面代码演示SimpleJdbcInsert用法，SimpleJdbcCall用于调用存储过程及自定义函数，可以参考博客：http://jinnianshilongnian.iteye.com/blog/1428149  

Java代码   

1.   
2. @SuppressWarnings("deprecation")  
3. public class SimpleJdbcTemplateDao{  
4.   
5.     private static SimpleJdbcInsert insert;  
6.   
7.     public static void main(String[] args) {  
8.         insert = new SimpleJdbcInsert(JdbcTemplateTest.getMyDataSource());  
9.         simpleInsetId()  
10.         System.out.println(insert.getInsertString());  
11.     }  
12.       
13.     public static void simpleInsetId() {  
14.         insert.withTableName("tab_item");  
15.         //主键是数据库自动生成的情况下  
16.         insert.setGeneratedKeyName("id");  
17.           
18.         Map args = new HashMap();  
19.         args.put("itemno", "SONY");  
20.         args.put("itemname", "SONY");  
21.           
22.           
23.         Number id = insert.executeAndReturnKey(args);  
24.         System.out.println(id);  
25.     }  
26. }  

SpringJdbc批量操作  

Java代码   

1. public class BatchExecuteDao extends JdbcDaoSupport{  
2.       
3.     public void setDadasource(DataSource dataSource) {  
4.         super.setDataSource(dataSource);  
5.     }  
6.       
7.     @SuppressWarnings("unchecked")  
8.     public void batchBySimpleJdbcInsert() {  
9.          SimpleJdbcInsert insert = new SimpleJdbcInsert(getJdbcTemplate());    
10.          insert.withTableName("tab_item");    
11.          Map valueMap = new HashMap();    
12.          valueMap.put("id", 101);  
13.          valueMap.put("itemno", "SONY");  
14.          valueMap.put("itemname", "SONY");  
15.          Map valueMap2 = new HashMap();    
16.          valueMap2.put("id", 102);  
17.          valueMap2.put("itemno", "SONY");  
18.          valueMap2.put("itemname", "SONY");  
19.          insert.executeBatch(new Map[] {valueMap, valueMap2});  
20.          System.out.println(insert.getInsertString());  
21.     }  
22.   
23.       
24.     public void batchBySimpleJdbcTemplate() {  
25.         SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(getJdbcTemplate());    
26.         String deleteSql = "delete tab_item where id = :id";    
27.         List
28.         params.add(new Object[]{101});  
29.         params.add(new Object[]{102});  
30.         params.add(new Object[]{103});  
31.         params.add(new Object[]{104});  
32.         simpleJdbcTemplate.batchUpdate(deleteSql, params);  
33.           
34.     }  
35.   
36.     public void batchByNamedParameterJdbcTemplate() {  
37.         NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(getJdbcTemplate());  
38.         String updateSql = "update tab_item set itemname = :itemname where id = :id";  
39.         Item model1 = new Item();  
40.         Item model2 = new Item();  
41.         Item model3 = new Item();  
42.         Item model4 = new Item();  
43.         model1.setId(101l);  
44.         model2.setId(102l);  
45.         model3.setId(103l);  
46.         model4.setId(104l);  
47.           
48.         model1.setItemname("I9100");  
49.         model2.setItemname("I9101");  
50.         model3.setItemname("I9102");  
51.         model4.setItemname("I9103");  
52.           
53.         SqlParameterSource[] params = SqlParameterSourceUtils.createBatch(new Object[] {model1, model2, model3, model4});    
54.         namedParameterJdbcTemplate.batchUpdate(updateSql, params);  
55.           
56.     }  
57.   
58.       
59.     public void batchByJdbcTemplate() {  
60.         String insertSql = "insert into tab_item values(?,?,?)";  
61.         Object[] arg1 = {101, "SUMSUNG", "GAS1"};  
62.         Object[] arg2 = {102, "SUMSUNG", "GAS2"};  
63.         Object[] arg3 = {103, "SUMSUNG", "GAS3"};  
64.         Object[] arg4 = {104, "SUMSUNG", "GAS4"};  
65.         final List
66.         list.add(arg1);  
67.         list.add(arg2);  
68.         list.add(arg3);  
69.         list.add(arg4);  
70.           
71.         int[] rows = getJdbcTemplate().batchUpdate(insertSql, new BatchPreparedStatementSetter() {  
72.               
73.             @Override  
74.             public void setValues(PreparedStatement ps, int i) throws SQLException {  
75.                 Object[] obj = list.get(i);  
76.                 ps.setInt(1, (Integer) obj[0]);  
77.                 ps.setString(2, (String) obj[1]);  
78.                 ps.setString(3, (String)obj[2]);  
79.             }  
80.               
81.             @Override  
82.             public int getBatchSize() {//返回批量操作数最大值  
83.                 return list.size();  
84.             }  
85.         });  
86.         System.out.println(getJdbcTemplate().getFetchSize());  
87.         System.out.println(getJdbcTemplate().getQueryTimeout());  
88.         for (int i = 0; i < rows.length; i++) {  
89.             System.out.println(rows[i]);  
90.         }  
91.           
92.         Assert.isTrue(list.size() == getJdbcTemplate().queryForInt("select count(1) from tab_item where itemno = 'SUMSUNG'"), "批量更新失败");  
93.     }  
94. }  

Xml代码   

1. ...  
2. <</span>bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">    
3.         <</span>property name="locations">    
4.           <</span>list>    
5.               <</span>value>classpath:application.properties</</span>value>    
6.           </</span>list>    
7.         </</span>property>  
8.     </</span>bean>  
9.       
10.     <</span>bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
11.            
12.         <</span>property name="driverClassName" value="${db.driver.class}" />  
13.         <</span>property name="url" value="${db.url}" />  
14.         <</span>property name="username" value="${db.username}" />  
15.         <</span>property name="password" value="${db.password}" />  
16.   
17.            
18.         <</span>property name="initialSize" value="${proxool.initialSize}" />  
19.         <</span>property name="maxActive" value="${proxool.maxActive}" />  
20.         <</span>property name="maxIdle" value="${proxool.maxIdle}" />  
21.         <</span>property name="minIdle" value="${proxool.minIdle}" />  
22.         <</span>property name="maxWait" value="500" />  
23.         <</span>property name="poolPreparedStatements" value="false" />  
24.     </</span>bean>  
25.       
26.     <</span>bean id="abstractDao" abstract="true">    
27.         <</span>property name="dataSource" ref="dataSource"/>    
28.     </</span>bean>  
29.       
30.     <</span>bean id="dao1" class="com.chou.jdbc.JdbcTemplateDao" parent="abstractDao"/>  
31.     <</span>bean id="dao2" class="com.chou.jdbc.NamedParameterJdbcTemplateDao" parent="abstractDao"/>  
32.     <</span>bean id="dao3" class="com.chou.jdbc.SimpleJdbcTemplateDao" parent="abstractDao"/>  
33.     <</span>bean id="dao4" class="com.chou.jdbc.BatchExecuteDao" parent="abstractDao"/>  
34. ...  

Java代码   

1. db.driver.class=oracle.jdbc.driver.OracleDriver  
2. db.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl  
3. db.username=db_test  
4. db.password=db_test  
5.   
6. #连接池连接数初始值  
7. proxool.initialSize=2  
8.   
9. #连接池最大连接数量  
10. proxool.maxActive=10  
11.   
12. #连接池最大空闲值，释放多余的不用的连接，释放到多少为止  
13. proxool.maxIdle=5  
14.   
15. #连接池最小空闲值，当空闲连接数小于这个数的时候，连接池就会去申请一些连接以免高峰期来不及申请  
16. proxool.minIdle=1  

Spring JDBC自身提供了以下DataSource实现： 

• DriverManagerDataSource ：简单封装了DriverManager获取数据库连接；通过DriverManager的getConnection方法获取数据库连接；
• SingleConnectionDataSource ：内部封装了一个连接，该连接使用后不会关闭，且不能在多线程环境中使用，一般用于测试；
• LazyConnectionDataSourceProxy ：包装一个DataSource，用于延迟获取数据库连接，只有在真正创建Statement等时才获取连接，因此再说实际项目中最后使用该代理包装原始DataSource从而使得只有在真正需要连接时才去获取。

Spring也能通过第三方提供的连接池实现主要有C3P0、Proxool、DBCP 
DBCP没有自动的去回收空闲连接的功能 
C3P0有自动回收空闲连接功能,它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。 

DataSourceUtils： 
Spring JDBC抽象框架内部都是通过它的getConnection(DataSource dataSource)方法获取数据库连接，releaseConnection(Connection con, DataSource dataSource) 用于释放数据库连接，DataSourceUtils用于支持Spring管理事务，只有使用DataSourceUtils获取的连接才具有Spring管理事务。