spring-JDBCTempalate方法提要

作者May

JDBCTemplate主要提供了五类方法：

1. execute()方法：可用于执行任何sql语句，但是一般用来执行DDL语句；
2. update()以及batchUpdate()方法：update()方法用来执行增加、修改和删除等语句；batchUpdate()方法用来执行批处理相关的语句；
3. query()以及queryForXxx()：用来执行查询相关的语句；
4. call()方法：用于执行存储过程、函数相关的语句；

JDBCTemplate支持的回调类：

• 预编译语句及存储过程创建回调：用于根据JDBCTemplate提供的连接创建相应的语句；

1、PreparedStatementCreator：通过回调获取JDBCTemplate提供的Connection，由用户使用该Connection来创建相关的PreparedStatement；      

   代码示例：

[java] view plain copy

1. jdbcTemplate.update(new PreparedStatementCreator(){  
2.     @Override  
3.     public PreparedStatement createPreparedStatement(Connection conn) {  
4.         PreparedStatement ps = null;  
5.         final String sql = "******";  
6.         try{  
7.             ps = conn.prepareStatement(sql);  
8.             ps.setString(1,UUID.randomUUID().toString());  
9.         }catch(Exception e){  
10.             logger.error("**** error " + e);  
11.         }finally{  
12.             conn.commit();  
13.         }  
14.         return ps;  
15.     }  
16. });   

2、CallableStatementCreator：通过回调获取JDBCTemplate提供的Connection，由用户使用该Connection来创建相关的CallableStatement；

代码示例：

[java] view plain copy

1. jdbcTemplate.execute(new CallableStatementCreator(){  
2.     @Override  
3.     public CallableStatement createCallableStatement(Connection connection) {  
4.         String procedure = "{call PRC_BJ_SYNC_CIRCUIT_DATA_ALL (?)}";//存储过程  
5.         CallableStatement cs = null;  
6.         try {  
7.             cs = connection.prepareCall(procedure);  
8.             cs.registerOutParameter(1,OracleTypes.VARCHAR);//注册输出参数的类型  
9.         } catch (Exception e) {  
10.             logger.error("call procedure error : " + e);  
11.             log.setResultCode("-2");//调用存储过程失败  
12.         }  
13.         return cs;  
14.     }  
15.     }, new CallableStatementCallback(){  
16.         @Override  
17.         public Object doInCallableStatement(CallableStatement cs) {  
18.             String csStr = null;  
19.             try {  
20.                 cs.execute();  
21.                 csStr = cs.getString(1);  
22.             } catch (Exception e) {  
23.                 logger.error("call procedure error : " + e);  
24.                 log.setResultCode("-2");//调用存储过程失败  
25.             }  
26.             return csStr;//获取输出参数的值   
27.         }  
28.     }  
29. );  

• 预编译语句设值回调：用于给预编译语句相应参数设值；

1、PreparedStatementSetter：通过回调获取JDBCTemplate提供的PreparedStatement，由用户来对相应的预编译语句的参数设值；

2、BatchPreparedStatementSetter：类似于PreparedStatementSetter，但用于批处理，需要指定批处理的大小；

• 自定义功能回调：提供给用户一个扩展点，用户可以在指定类型的扩展点执行任何数量需要的操作；

1、ConnectionCallBack：通过回调获取JDBCTemplate提供的Connection，用户可在该Connection执行任何数量的操作；

2、StatementCallBack：通过回调获取JDBCTemplate提供的Statement，用户可以在该Statement提供任何数量的操作；

3、PreparedStatementCallBack：通过回调获取JDBCTemplate提供的PreparedStatement，用户可以在该PreparedStatement执行任何数量的操作；

4、CallableStatementCallBack：通过回调获取JDBCTemplate提供的CallableStatement，用户可以在该CallableStatement执行任何数量的操作；

• 结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式；

1、RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。

2、RowCallbackHandler：用于处理ResultSet的每一行结果，用户需实现方法processRow(ResultSet rs)来完成处理，在该回调方法中无需执行rs.next()，该操作由JdbcTemplate来执行，用户只需按行获取数据然后处理即可。

3、ResultSetExtractor：用于结果集数据提取，用户需实现方法extractData(ResultSet rs)来处理结果集，用户必须处理整个结果集；

具体示例：

1、预编译语句或存储过程创建回调，自定义功能回调使用：

首先使用PreparedStatementCreator创建一个预编译语句，其次由JdbcTemplate通过PreparedStatementCallback回调传回，由用户决定如何执行该PreparedStatement。此处我们使用的是execute方法。

[java] view plain copy

1. public void testPreparedStatement() {   
2.   int count = jdbcTemplate.execute(new PreparedStatementCreator() {   
3.      @Override   
4.      public PreparedStatement createPreparedStatement(Connection conn)   
5.          throws SQLException {   
6.          return conn.prepareStatement("select count(*) from test");   
7.      }}, new PreparedStatementCallback<Integer>() {   
8.      @Override   
9.      public Integer doInPreparedStatement(PreparedStatement pstmt)   
10.          throws SQLException, DataAccessException {   
11.          pstmt.execute();   
12.          ResultSet rs = pstmt.getResultSet();   
13.          rs.next();   
14.          return rs.getInt(1);   
15.       }});         
16. }   

2、预编译语句设值回调使用：

通过JdbcTemplate的int update(String sql, PreparedStatementSetter pss)执行预编译sql，其中sql参数为“insert into TBL_SYS(name) values (?) ”，该sql有一个占位符需要在执行前设值，PreparedStatementSetter实现就是为了设值，使用setValues(PreparedStatement pstmt)回调方法设值相应的占位符位置的值。JdbcTemplate也提供一种更简单的方式“update(String sql, Object[] args)”来实现设值，所以只要当使用该种方式不满足需求时才应使用PreparedStatementSetter。

[java] view plain copy

1. public void testPreparedStatement() {   
2.   String insertSql = "insert into TBL_SYS(name) values (?)";   
3.   int count = jdbcTemplate.update(insertSql, new PreparedStatementSetter() {   
4.       @Override   
5.       public void setValues(PreparedStatement pstmt) throws SQLException {   
6.           pstmt.setObject(1, "name");   
7.   }});   
8.   
9.   //**************************************************************     
10.   String deleteSql = "delete from TBL_SYS where name=?";   
11.   count = jdbcTemplate.update(deleteSql, new Object[] {"name"});  
12. }  

3、结果集处理回调：

RowMapper接口提供mapRow(ResultSet rs, int rowNum)方法将结果集的每一行转换为一个Map，当然可以转换为其他类。

[java] view plain copy

1. public void testResultSet() {   
2.   jdbcTemplate.update("insert into TBL_SYS(name) values('name')");   
3.   
4.   String listSql = "select * from TBL_SYS";   
5.   List result = jdbcTemplate.query(listSql, new RowMapper<Map>() {   
6.       @Override   
7.       public Map mapRow(ResultSet rs, int rowNum) throws SQLException {   
8.           Map row = new HashMap();   
9.           row.put(rs.getInt("id"), rs.getString("name"));   
10.           return row;   
11.   }});        
12. }     

RowCallbackHandler接口也提供方法processRow(ResultSet rs)，能将结果集的行转换为需要的形式。

[java] view plain copy

1. public void testResultSet() {   
2.   jdbcTemplate.update("insert into TBL_SYS(name) values('name')");   
3.   
4.   String listSql = "select * from TBL_SYS";   
5.   final List result = new ArrayList();   
6.   jdbcTemplate.query(listSql, new RowCallbackHandler() {   
7.       @Override   
8.       public void processRow(ResultSet rs) throws SQLException {   
9.           Map row = new HashMap();   
10.           row.put(rs.getInt("id"), rs.getString("name"));   
11.           result.add(row);   
12.   }});   
13. }  

ResultSetExtractor使用回调方法extractData(ResultSet rs)提供给用户整个结果集，让用户决定如何处理该结果集。

[java] view plain copy

1. public void testResultSet() {  
2.   jdbcTemplate.update("insert into TBL_SYS(name) values('name')");   
3.   
4.   String listSql = "select * from TBL_SYS";   
5.   List result = jdbcTemplate.query(listSql, new ResultSetExtractor<List>() {   
6.       @Override   
7.       public List extractData(ResultSet rs) throws SQLException, DataAccessException {   
8.           List result = new ArrayList();   
9.           while(rs.next()) {   
10.               Map row = new HashMap();   
11.               row.put(rs.getInt("id"), rs.getString("name"));   
12.               result.add(row);   
13.            }   
14.            return result;   
15.   }});   
16. }  

4、JDBCTemplate的queryForXxx()方法：

[java] view plain copy

1. //1.查询一行数据并返回int型结果   
2. jdbcTemplate.queryForInt("select count(*) from TBL_SYS");   
3. //2. 查询一行数据并将该行数据转换为Map返回   
4. jdbcTemplate.queryForMap("select * from TBL_SYS where name='Tom'");   
5. //3.查询一行任何类型的数据，最后一个参数指定返回结果类型   
6. jdbcTemplate.queryForObject("select count(*) from TBL_SYS", Integer.class);   
7. //4.查询一批数据，默认将每行数据转换为Map         
8. jdbcTemplate.queryForList("select * from TBL_SYS");   
9. //5.只查询一列数据列表，列类型是String类型，列名字是name   
10. jdbcTemplate.queryForList("select name from TBL_SYS where name=?", new Object[]{"Tom"}, String.class);   
11. //6.查询一批数据，返回为SqlRowSet，类似于ResultSet，但不再绑定到连接上   
12. SqlRowSet rs = jdbcTemplate.queryForRowSet("select * from TBL_SYS");   

5、存储过程及函数回调：

存储过程回调：

方法一：

首先使用CallableStatementCreator 创建一个预编译语句，其次由JdbcTemplate通过CallableStatementCallback 回调传回，由用户决定如何执行该CallableStatement 。此处我们使用的是execute方法。

[java] view plain copy

1. public static void callProcedure() {  
2.     jdbcTemplate.execute(new CallableStatementCreator(){  
3.         @Override  
4.         public CallableStatement createCallableStatement(Connection connection) {  
5.             String procedure = "{call PRC_BJ_SYNC_CIRCUIT_DATA_ALL (?)}";//存储过程  
6.             CallableStatement cs = null;  
7.             try {  
8.                 cs = connection.prepareCall(procedure);  
9.                 cs.registerOutParameter(1,OracleTypes.VARCHAR);//注册输出参数的类型  
10.             } catch (Exception e) {  
11.   
12.             }  
13.             return cs;  
14.         }  
15.     }, new CallableStatementCallback(){  
16.         @Override  
17.         public Object doInCallableStatement(CallableStatement cs) {  
18.             String csStr = null;  
19.             try {  
20.                 cs.execute();  
21.                 csStr = cs.getString(1);  
22.             } catch (Exception e) {  
23.   
24.             }  
25.             return csStr;//获取输出参数的值   
26.         }});  
27. }   

方法二：

[java] view plain copy

1. public void testCallableStatementCreator() {   
2.     final String callProcedureSql = "{call PROCEDURE_TEST(?, ?)}";   
3.     List<SqlParameter> params = new ArrayList<SqlParameter>();   
4.     params.add(new SqlInOutParameter("inOutName", Types.VARCHAR));   
5.     params.add(new SqlOutParameter("outId", Types.INTEGER));   
6.      // outValues：通过SqlInOutParameter及SqlOutParameter参数定义的name来获取存储过程结果  
7.     Map<String, Object> outValues = jdbcTemplate.call(   
8.       new CallableStatementCreator() {   
9.         @Override   
10.         public CallableStatement createCallableStatement(Connection conn) throws SQLException {   
11.           CallableStatement cstmt = conn.prepareCall(callProcedureSql);   
12.           cstmt.registerOutParameter(1, Types.VARCHAR);   
13.           cstmt.registerOutParameter(2, Types.INTEGER);   
14.           cstmt.setString(1, "test");   
15.           return cstmt;   
16.     }}, params);     
17. }    

自定义函数回调：

1、params：用于描述自定义函数占位符参数或命名参数类型；SqlParameter用于描述IN类型参数、SqlOutParameter用于描述OUT类型参数、SqlInOutParameter用于描述INOUT类型参数、SqlReturnResultSet用于描述调用存储过程或自定义函数返回的ResultSet类型数据，其中SqlReturnResultSet需要提供结果集处理回调用于将结果集转换为相应的形式，hsqldb自定义函数返回值是ResultSet类型。

2、CallableStatementCreator：提供Connection对象用于创建CallableStatement对象

3、outValues：调用call方法将返回类型为Map<String, Object>对象；

4、outValues.get("result")：获取结果，即通过SqlReturnResultSet对象转换过的数据；其中SqlOutParameter、SqlInOutParameter、SqlReturnResultSet指定的name用于从call执行后返回的Map中获取相应的结果，即name是Map的键。

[java] view plain copy

1. public void testCallableStatementCreator() {   
2.     final String callFunctionSql = "{call FUNCTION_TEST(?)}";   
3.     List<SqlParameter> params = new ArrayList<SqlParameter>();   
4.     params.add(new SqlParameter(Types.VARCHAR));   
5.     params.add(new SqlReturnResultSet("result",new ResultSetExtractor<Integer>() {   
6.            @Override   
7.            public Integer extractData(ResultSet rs) throws SQLException,DataAccessException {   
8.                while(rs.next()) {   
9.                    return rs.getInt(1);   
10.                }   
11.               return 0;   
12.        }));   
13.   
14.     Map<String, Object> outValues = jdbcTemplate.call(new CallableStatementCreator() {   
15.             @Override   
16.             public CallableStatement createCallableStatement(Connection conn) throws SQLException {   
17.               CallableStatement cstmt = conn.prepareCall(callFunctionSql);   
18.               cstmt.setString(1, "test");  
19.               return cstmt;   
20.     }}, params);   
21. }  

 几种具体使用：
1、调用无返回值的存储过程

[java] view plain copy

1. public class callProcedure {        
2.     private JdbcTemplate jdbcTemplate;        
3.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {        
4.     this.jdbcTemplate = jdbcTemplate;        
5.     }        
6.     public void test(){        
7.        this.jdbcTemplate.execute("{call procedureName (?)}");        
8.     }        
9.   }   

2、调用有返回值的存储过程（不是结果集）

[java] view plain copy

1. public class test {    
2.           
3.       /**  
4.        * 调用无参的存储过程（有返回值）  
5.        * @return  
6.        */    
7.       public static int callProcedure() {    
8.             String str = (String)jdbcTemplate.execute(new CallableStatementCreator(){    
9.                   @Override    
10.                   public CallableStatement createCallableStatement(Connection connection) {    
11.                         String procedure = "{call PRC_BJ_SYNC_CIRCUIT_DATA_INCRE (?)}";//存储过程    
12.                         CallableStatement cs = null;//创建存储过程的对象    
13.                         try {    
14.                               cs = connection.prepareCall(procedure);    
15.                               cs.registerOutParameter(1,OracleTypes.VARCHAR);//注册输出参数的类型    
16.                         } catch (Exception e) {    
17.                               logger.error("call procedure error : " + e);    
18.                         }    
19.                         return cs;    
20.                   }    
21.             }, new CallableStatementCallback(){    
22.                   @Override    
23.                   public Object doInCallableStatement(CallableStatement cs) {    
24.                         String csStr = null;    
25.                         try {    
26.                               cs.execute();    
27.                               csStr = cs.getString(1);//获取输出参数的值    
28.                         } catch (Exception e) {    
29.                               logger.error("call procedure error : " + e);    
30.                         }    
31.                         return csStr;//获取输出参数的值    
32.                   }});    
33.             return Integer.parseInt(str);    
34.       }    
35.           
36.       /**  
37.        * 调用有参的存储过程（有返回值）  
38.        * @return  
39.        */    
40.       public static int callProcedure() {    
41.             String str = (String)jdbcTemplate.execute(new CallableStatementCreator(){    
42.                   @Override    
43.                   public CallableStatement createCallableStatement(Connection connection) {    
44.                         String procedure = "{call PRC_BJ_SYNC_CIRCUIT_DATA_INCRE (?,?)}";//存储过程    
45.                         CallableStatement cs = null;//创建存储过程的对象    
46.                         try {    
47.                               cs = connection.prepareCall(procedure);    
48.                               cs.setString(1,"value1");//设置入参的值    
49.                               cs.registerOutParameter(1,OracleTypes.VARCHAR);//注册输出参数的类型    
50.                         } catch (Exception e) {    
51.                               logger.error("call procedure error : " + e);    
52.                         }    
53.                         return cs;    
54.                   }    
55.             }, new CallableStatementCallback(){    
56.                   @Override    
57.                   public Object doInCallableStatement(CallableStatement cs) {    
58.                         String csStr = null;    
59.                         try {    
60.                               cs.execute();    
61.                               csStr = cs.getString(2);//获取输出参数的值    
62.                         } catch (Exception e) {    
63.                               logger.error("call procedure error : " + e);    
64.                         }    
65.                         return csStr;//获取输出参数的值    
66.                   }});    
67.             return Integer.parseInt(str);    
68.       }    
69. }    

3、调用有返回值的存储过程（是结果集）

[java] view plain copy

1. public class test {        
2.     List resultList = (List) jdbcTemplate.execute(      
3.            new CallableStatementCreator() {      
4.           public CallableStatement createCallableStatement(Connection con) throws SQLException {      
5.              String storedProc = "{call PRC_BJ_SYNC_CUST_DATA(?,?)}";// 调用的sql      
6.              CallableStatement cs = con.prepareCall(storedProc);      
7.              cs.setString(1, "p1");// 设置输入参数的值      
8.              cs.registerOutParameter(2, OracleTypes.CURSOR);// 注册输出参数的类型      
9.              return cs;      
10.           }      
11.            }, new CallableStatementCallback() {      
12.           public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {      
13.              List resultsMap = new ArrayList();      
14.              cs.execute();      
15.              ResultSet rs = (ResultSet) cs.getObject(2);// 获取游标一行的值      
16.              while (rs.next()) {// 转换每行的返回值到Map中      
17.             Map rowMap = new HashMap();      
18.             rowMap.put("id", rs.getString("id"));      
19.             rowMap.put("name", rs.getString("name"));      
20.             resultsMap.add(rowMap);      
21.              }      
22.              rs.close();      
23.              return resultsMap;      
24.           }      
25.         });      
26.     for (int i = 0; i < resultList.size(); i++) {      
27.        Map rowMap = (Map) resultList.get(i);      
28.        String id = rowMap.get("id").toString();      
29.        String name = rowMap.get("name").toString();      
30.        System.out.println("id=" + id + ";name=" + name);      
31.     }    
32. }