程序博客网 > 魅族安卓数据dns修改

【第七章】 对JDBC的支持 之 7.2 JDBC模板类 ——跟我学spring3

来源：互联网 发布：魅族安卓数据dns修改 编辑：程序博客网 时间：2024/04/28 07:53

7.2  JDBC模板类

7.2.1  概述

       Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。

 

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

 

       JdbcTemplate类对可变部分采用回调接口方式实现，如ConnectionCallback通过回调接口返回给用户一个连接，从而可以使用该连接做任何事情、StatementCallback通过回调接口返回给用户一个Statement，从而可以使用该Statement做任何事情等等，还有其他一些回调接口如图7-3所示。

 

图7-3 JdbcTemplate支持的回调接口

 

Spring除了提供JdbcTemplate核心类，还提供了基于JdbcTemplate实现的NamedParameterJdbcTemplate类用于支持命名参数绑定、 SimpleJdbcTemplate类用于支持Java5+的可变参数及自动装箱拆箱等特性。

 

7.2.3         传统JDBC编程替代方案

前边我们已经使用过传统JDBC编程方式，接下来让我们看下Spring JDBC框架提供的更好的解决方案。

1）准备需要的jar包并添加到类路径中：

 

java代码：
Java代码 复制代码 收藏代码
  1. //JDBC抽象框架模块   
  2. org.springframework.jdbc-3.0.5.RELEASE.jar        
  3. //Spring事务管理及一致的DAO访问及非检查异常模块    
  4. org.springframework.transaction-3.0.5.RELEASE.jar    
  5. //hsqldb驱动，hsqldb是一个开源的Java实现数据库，请下载hsqldb2.0.0+版本  
  6. hsqldb.jar  

 

2）传统JDBC编程替代方案：

在使用JdbcTemplate模板类时必须通过DataSource获取数据库连接，Spring JDBC提供了DriverManagerDataSource实现，它通过包装“DriverManager.getConnection”获取数据库连接，具体DataSource相关请参考【7.5.1控制数据库连接】。

 

java代码：
Java代码 复制代码 收藏代码
  1. package cn.javass.spring.chapter7;   
  2. import java.sql.ResultSet;   
  3. import java.sql.SQLException;   
  4. import org.junit.AfterClass;   
  5. import org.junit.BeforeClass;   
  6. import org.junit.Test;   
  7. import org.springframework.jdbc.core.JdbcTemplate;   
  8. import org.springframework.jdbc.core.RowCallbackHandler;   
  9. import org.springframework.jdbc.datasource.DriverManagerDataSource;   
  10. public class JdbcTemplateTest {   
  11.     private static JdbcTemplate jdbcTemplate;   
  12.     @BeforeClass  
  13.     public static void setUpClass() {   
  14.         String url = "jdbc:hsqldb:mem:test";   
  15.         String username = "sa";   
  16.         String password = "";   
  17.         DriverManagerDataSource dataSource = new DriverManagerDataSource(url, username, password);   
  18.         dataSource.setDriverClassName("org.hsqldb.jdbcDriver");   
  19.         jdbcTemplate = new JdbcTemplate(dataSource);   
  20.     }   
  21.     @Test  
  22.     public void test() {   
  23.         //1.声明SQL   
  24.         String sql = "select * from INFORMATION_SCHEMA.SYSTEM_TABLES";   
  25.         jdbcTemplate.query(sql, new RowCallbackHandler() {   
  26.             @Override  
  27.             public void processRow(ResultSet rs) throws SQLException {   
  28.                 //2.处理结果集   
  29.                 String value = rs.getString("TABLE_NAME");   
  30.                 System.out.println("Column TABLENAME:" + value);   
  31.             }   
  32.         });   
  33.     }   
  34. }   
  35.    


接下来让我们具体分析一下：

1）  jdbc:hsqldb:mem:test：表示使用hsqldb内存数据库，数据库名为“test”。

2）  public static void setUpClass()：使用junit的@BeforeClass注解，表示在所以测试方法之前执行，且只执行一次。在此方法中定义了DataSource并使用DataSource对象创建了JdbcTemplate对象。JdbcTemplate对象是线程安全的。

3）  JdbcTemplate执行流程：首先定义SQL，其次调用JdbcTemplate方法执行SQL，最后通过RowCallbackHandler回调处理ResultSet结果集。

Spring JDBC解决方法相比传统JDBC编程方式是不是简单多了，是不是只有可变部分需要我们来做，其他的都由Spring JDBC框架来实现了。

接下来让我们深入JdbcTemplate及其扩展吧。

 

7.2.4         JdbcTemplate

       首先让我们来看下如何使用JdbcTemplate来实现增删改查。

一、首先创建表结构：

 

java代码：
Java代码 复制代码 收藏代码
  1. //代码片段(cn.javass.spring.chapter7.JdbcTemplateTest)  
  2. @Before  
  3. public void setUp() {   
  4.    String createTableSql = "create memory table test" + "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " + "name varchar(100))";   
  5.    jdbcTemplate.update(createTableSql);   
  6. }   
  7. @After  
  8. public void tearDown() {   
  9.   String dropTableSql = "drop table test";   
  10.   jdbcTemplate.execute(dropTableSql);   
  11. }  

 

1）  org.junit包下的@Before和@After分别表示在测试方法之前和之后执行的方法，对于每个测试方法都将执行一次；

 

2）  create memory table test表示创建hsqldb内存表，包含两个字段id和name，其中id是具有自增功能的主键，如果有朋友对此不熟悉hsqldb可以换成熟悉的数据库。

 

 

二、定义测试骨架，该测试方法将用于实现增删改查测试：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testCURD() {   
  3.     insert();   
  4.     delete();   
  5.     update();   
  6.     select();   
  7. }  

 

三、新增测试：

 

java代码：
Java代码 复制代码 收藏代码
  1. private void insert() {   
  2.   jdbcTemplate.update("insert into test(name) values('name1')");   
  3.   jdbcTemplate.update("insert into test(name) values('name2')");   
  4.   Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));   
  5. }  

 

四、删除测试：

 

java代码：
Java代码 复制代码 收藏代码
  1. private void delete() {   
  2.   jdbcTemplate.update("delete from test where name=?", new Object[]{"name2"});   
  3.   Assert.assertEquals(1, jdbcTemplate.queryForInt("select count(*) from test"));   
  4. }  

 

五、更新测试：

 

java代码：
Java代码 复制代码 收藏代码
  1. private void update() {   
  2.   jdbcTemplate.update("update test set name='name3' where name=?", new Object[]{"name1"});   
  3.   Assert.assertEquals(1, jdbcTemplate.queryForInt("select count(*) from test where name='name3'"));   
  4. }  

 

 

六、查询测试：

 

java代码：
Java代码 复制代码 收藏代码
  1. private void select() {   
  2.   jdbcTemplate.query("select * from test", new RowCallbackHandler(){   
  3.     @Override  
  4.     public void processRow(ResultSet rs) throws SQLException {   
  5.       System.out.print("====id:" + rs.getInt("id"));   
  6.       System.out.println(",name:" + rs.getString("name"));   
  7.     }   
  8.   });   
  9. }  

 

       看完以上示例，大家是否觉得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，由用户来对相应的预编译语句相应参数设值；

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

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

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

         StatementCallback：通过回调获取JdbcTemplate提供的Statement，用户可以在该Statement执行任何数量的操作；

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

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

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

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

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

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

 

接下来让我们看下具体示例吧，在示例中不可能介绍到JdbcTemplate全部方法及回调类的使用方法，我们只介绍代表性的，其余的使用都是类似的；

 

 

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

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testPpreparedStatement1() {   
  3.   int count = jdbcTemplate.execute(new PreparedStatementCreator() {   
  4.      @Override  
  5.      public PreparedStatement createPreparedStatement(Connection conn)   
  6.          throws SQLException {   
  7.          return conn.prepareStatement("select count(*) from test");   
  8.      }}, new PreparedStatementCallback<Integer>() {   
  9.      @Override  
  10.      public Integer doInPreparedStatement(PreparedStatement pstmt)   
  11.          throws SQLException, DataAccessException {   
  12.          pstmt.execute();   
  13.          ResultSet rs = pstmt.getResultSet();   
  14.          rs.next();   
  15.          return rs.getInt(1);   
  16.       }});       
  17.    Assert.assertEquals(0, count);   
  18. }   
  19.    

 

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

 

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

 

java代码：
Java代码 复制代码 收藏代码
  1.        
  2. @Test  
  3. public void testPreparedStatement2() {   
  4.   String insertSql = "insert into test(name) values (?)";   
  5.   int count = jdbcTemplate.update(insertSql, new PreparedStatementSetter() {   
  6.       @Override  
  7.       public void setValues(PreparedStatement pstmt) throws SQLException {   
  8.           pstmt.setObject(1, "name4");   
  9.   }});   
  10.   Assert.assertEquals(1, count);       
  11.   String deleteSql = "delete from test where name=?";   
  12.   count = jdbcTemplate.update(deleteSql, new Object[] {"name4"});   
  13.   Assert.assertEquals(1, count);   
  14. }  

 

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

 

3）结果集处理回调：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testResultSet1() {   
  3.   jdbcTemplate.update("insert into test(name) values('name5')");   
  4.   String listSql = "select * from test";   
  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.   Assert.assertEquals(1, result.size());   
  13.   jdbcTemplate.update("delete from test where name='name5'");        
  14. }  

 

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

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testResultSet2() {   
  3.   jdbcTemplate.update("insert into test(name) values('name5')");   
  4.   String listSql = "select * from test";   
  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.   Assert.assertEquals(1, result.size());   
  14.   jdbcTemplate.update("delete from test where name='name5'");   
  15. }  


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

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testResultSet3() {   
  3.   jdbcTemplate.update("insert into test(name) values('name5')");   
  4.   String listSql = "select * from test";   
  5.   List result = jdbcTemplate.query(listSql, new ResultSetExtractor<List>() {   
  6.       @Override  
  7.       public List extractData(ResultSet rs)   
  8.      throws SQLException, DataAccessException {   
  9.           List result = new ArrayList();   
  10.           while(rs.next()) {   
  11.               Map row = new HashMap();   
  12.               row.put(rs.getInt("id"), rs.getString("name"));   
  13.               result.add(row);   
  14.            }   
  15.            return result;   
  16.   }});   
  17.   Assert.assertEquals(0, result.size());   
  18.   jdbcTemplate.update("delete from test where name='name5'");   
  19. }  

 

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

 

当然JdbcTemplate提供更简单的queryForXXX方法，来简化开发：

 

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

 

3） 存储过程及函数回调：

首先修改JdbcTemplateTest的setUp方法，修改后如下所示：

 

 

java代码：
Java代码 复制代码 收藏代码
  1.        
  2. @Before  
  3. public void setUp() {   
  4.     String createTableSql = "create memory table test" +   
  5.     "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +   
  6.     "name varchar(100))";   
  7.     jdbcTemplate.update(createTableSql);   
  8.           
  9.     String createHsqldbFunctionSql =   
  10.       "CREATE FUNCTION FUNCTION_TEST(str CHAR(100)) " +   
  11.       "returns INT begin atomic return length(str);end";   
  12.     jdbcTemplate.update(createHsqldbFunctionSql);   
  13.     String createHsqldbProcedureSql =   
  14.       "CREATE PROCEDURE PROCEDURE_TEST" +   
  15.       "(INOUT inOutName VARCHAR(100), OUT outId INT) " +   
  16.       "MODIFIES SQL DATA " +   
  17.       "BEGIN ATOMIC " +   
  18.       "  insert into test(name) values (inOutName); " +   
  19.       "  SET outId = IDENTITY(); " +   
  20.       "  SET inOutName = 'Hello,' + inOutName; " +   
  21.     "END";   
  22.     jdbcTemplate.execute(createHsqldbProcedureSql);   
  23. }  

 

       其中CREATE FUNCTION FUNCTION_TEST用于创建自定义函数，CREATE PROCEDURE PROCEDURE_TEST用于创建存储过程，注意这些创建语句是数据库相关的，本示例中的语句只适用于HSQLDB数据库。

 

       其次修改JdbcTemplateTest的tearDown方法，修改后如下所示：

 

java代码：
Java代码 复制代码 收藏代码
  1. @After  
  2. public void tearDown() {   
  3.     jdbcTemplate.execute("DROP FUNCTION FUNCTION_TEST");   
  4.     jdbcTemplate.execute("DROP PROCEDURE PROCEDURE_TEST");   
  5.     String dropTableSql = "drop table test";   
  6.     jdbcTemplate.execute(dropTableSql);   
  7. }  

 

       其中drop语句用于删除创建的存储过程、自定义函数及数据库表。

 

       接下来看一下hsqldb如何调用自定义函数：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testCallableStatementCreator1() {   
  3.     final String callFunctionSql = "{call FUNCTION_TEST(?)}";   
  4.     List<SqlParameter> params = new ArrayList<SqlParameter>();   
  5.     params.add(new SqlParameter(Types.VARCHAR));   
  6.     params.add(new SqlReturnResultSet("result",   
  7.        new ResultSetExtractor<Integer>() {   
  8.            @Override  
  9.            public Integer extractData(ResultSet rs) throws SQLException,   
  10.                DataAccessException {   
  11.                while(rs.next()) {   
  12.                    return rs.getInt(1);   
  13.                }   
  14.               return 0;   
  15.        }));   
  16.     Map<String, Object> outValues = jdbcTemplate.call(   
  17.        new CallableStatementCreator() {   
  18.             @Override  
  19.             public CallableStatement createCallableStatement(Connection conn) throws SQLException {   
  20.               CallableStatement cstmt = conn.prepareCall(callFunctionSql);   
  21.               cstmt.setString(1, "test");   
  22.               return cstmt;   
  23.     }}, params);   
  24.     Assert.assertEquals(4, outValues.get("result"));   
  25. }   
  26.    

 

  • {call FUNCTION_TEST(?)}：定义自定义函数的sql语句，注意hsqldb {?= call …}和{call …}含义是一样的，而比如mysql中两种含义是不一样的；
  • params：用于描述自定义函数占位符参数或命名参数类型；SqlParameter用于描述IN类型参数、SqlOutParameter用于描述OUT类型参数、SqlInOutParameter用于描述INOUT类型参数、SqlReturnResultSet用于描述调用存储过程或自定义函数返回的ResultSet类型数据，其中SqlReturnResultSet需要提供结果集处理回调用于将结果集转换为相应的形式，hsqldb自定义函数返回值是ResultSet类型。
  • CallableStatementCreator：提供Connection对象用于创建CallableStatement对象
  • outValues：调用call方法将返回类型为Map<String, Object>对象；
  • outValues.get("result")：获取结果，即通过SqlReturnResultSet对象转换过的数据；其中SqlOutParameter、SqlInOutParameter、SqlReturnResultSet指定的name用于从call执行后返回的Map中获取相应的结果，即name是Map的键。

注：因为hsqldb {?= call …}和{call …}含义是一样的，因此调用自定义函数将返回一个包含结果的ResultSet。

 

最后让我们示例下mysql如何调用自定义函数：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testCallableStatementCreator2() {   
  3.     JdbcTemplate mysqlJdbcTemplate = new JdbcTemplate(getMysqlDataSource);   
  4.     //2.创建自定义函数   
  5. String createFunctionSql =   
  6.     "CREATE FUNCTION FUNCTION_TEST(str VARCHAR(100)) " +   
  7.      "returns INT return LENGTH(str)";   
  8. String dropFunctionSql = "DROP FUNCTION IF EXISTS FUNCTION_TEST";   
  9. mysqlJdbcTemplate.update(dropFunctionSql);          
  10. mysqlJdbcTemplate.update(createFunctionSql);   
  11. //3.准备sql,mysql支持{?= call …}   
  12. final String callFunctionSql = "{?= call FUNCTION_TEST(?)}";   
  13. //4.定义参数   
  14. List<SqlParameter> params = new ArrayList<SqlParameter>();   
  15. params.add(new SqlOutParameter("result", Types.INTEGER));   
  16. params.add(new SqlParameter("str", Types.VARCHAR));   
  17. Map<String, Object> outValues = mysqlJdbcTemplate.call(   
  18. new CallableStatementCreator() {   
  19.     @Override  
  20.     public CallableStatement createCallableStatement(Connection conn) throws SQLException {   
  21.       CallableStatement cstmt = conn.prepareCall(callFunctionSql);   
  22.       cstmt.registerOutParameter(1, Types.INTEGER);   
  23.       cstmt.setString(2, "test");   
  24.         return cstmt;   
  25.     }}, params);   
  26.    Assert.assertEquals(4, outValues.get("result"));   
  27. }   
  28. public DataSource getMysqlDataSource() {   
  29.     String url = "jdbc:mysql://localhost:3306/test";   
  30.     DriverManagerDataSource dataSource =   
  31.         new DriverManagerDataSource(url, "root", "");     dataSource.setDriverClassName("com.mysql.jdbc.Driver");   
  32.     return dataSource;   
  33. }   
  34.    
  • getMysqlDataSource：首先启动mysql（本书使用5.4.3版本），其次登录mysql创建test数据库（“create database test;”），在进行测试前，请先下载并添加mysql-connector-java-5.1.10.jar到classpath；
  • {?= call FUNCTION_TEST(?)}：可以使用{?= call …}形式调用自定义函数；
  • params：无需使用SqlReturnResultSet提取结果集数据，而是使用SqlOutParameter来描述自定义函数返回值；
  • CallableStatementCreator：同上个例子含义一样；
  • cstmt.registerOutParameter(1, Types.INTEGER)：将OUT类型参数注册为JDBC类型Types.INTEGER，此处即返回值类型为Types.INTEGER。
  • outValues.get("result")：获取结果，直接返回Integer类型，比hsqldb简单多了吧。

 

最后看一下如何如何调用存储过程：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testCallableStatementCreator3() {   
  3.     final String callProcedureSql = "{call PROCEDURE_TEST(?, ?)}";   
  4.     List<SqlParameter> params = new ArrayList<SqlParameter>();   
  5.     params.add(new SqlInOutParameter("inOutName", Types.VARCHAR));   
  6.     params.add(new SqlOutParameter("outId", Types.INTEGER));   
  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.     Assert.assertEquals("Hello,test", outValues.get("inOutName"));   
  18.     Assert.assertEquals(0, outValues.get("outId"));   
  19. }   
  20.    
  • {call PROCEDURE_TEST(?, ?)}：定义存储过程sql；
  • params：定义存储过程参数；SqlInOutParameter描述INOUT类型参数、SqlOutParameter描述OUT类型参数；
  • CallableStatementCreator：用于创建CallableStatement，并设值及注册OUT参数类型；
  • outValues：通过SqlInOutParameter及SqlOutParameter参数定义的name来获取存储过程结果。

 

       JdbcTemplate类还提供了很多便利方法，在此就不一一介绍了，但这些方法是由规律可循的，第一种就是提供回调接口让用户决定做什么，第二种可以认为是便利方法（如queryForXXX），用于那些比较简单的操作。

 

7.2.4  NamedParameterJdbcTemplate

       NamedParameterJdbcTemplate类是基于JdbcTemplate类，并对它进行了封装从而支持命名参数特性。

NamedParameterJdbcTemplate主要提供以下三类方法：execute方法、query及queryForXXX方法、update及batchUpdate方法。

首先让我们看个例子吧：

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testNamedParameterJdbcTemplate1() {   
  3. NamedParameterJdbcTemplate namedParameterJdbcTemplate = null;   
  4. //namedParameterJdbcTemplate =   
  5. //    new NamedParameterJdbcTemplate(dataSource);  
  6. namedParameterJdbcTemplate =   
  7. new NamedParameterJdbcTemplate(jdbcTemplate);   
  8.     String insertSql = "insert into test(name) values(:name)";   
  9.     String selectSql = "select * from test where name=:name";   
  10.     String deleteSql = "delete from test where name=:name";   
  11.     Map<String, Object> paramMap = new HashMap<String, Object>();   
  12.     paramMap.put("name", "name5");   
  13.     namedParameterJdbcTemplate.update(insertSql, paramMap);   
  14.     final List<Integer> result = new ArrayList<Integer>();   
  15. namedParameterJdbcTemplate.query(selectSql, paramMap,   
  16. new RowCallbackHandler() {   
  17.         @Override  
  18.         public void processRow(ResultSet rs) throws SQLException {   
  19.             result.add(rs.getInt("id"));   
  20.         }   
  21.     });   
  22. Assert.assertEquals(1, result.size());   
  23. SqlParameterSource paramSource = new MapSqlParameterSource(paramMap);   
  24. namedParameterJdbcTemplate.update(deleteSql, paramSource);   
  25. }  

 

接下来让我们分析一下代码吧：

1）NamedParameterJdbcTemplate初始化：可以使用DataSource或JdbcTemplate 对象作为构造器参数初始化；

2）insert into test(name) values(:name)：其中“:name”就是命名参数；

3） update(insertSql, paramMap)：其中paramMap是一个Map类型，包含键为“name”，值为“name5”的键值对，也就是为命名参数设值的数据；

4）query(selectSql, paramMap, new RowCallbackHandler()……)：类似于JdbcTemplate中介绍的，唯一不同是需要传入paramMap来为命名参数设值；

5）update(deleteSql, paramSource)：类似于“update(insertSql, paramMap)”，但使用SqlParameterSource参数来为命名参数设值，此处使用MapSqlParameterSource实现，其就是简单封装java.util.Map。

 

 

NamedParameterJdbcTemplate类为命名参数设值有两种方式：java.util.Map和SqlParameterSource：

1）java.util.Map：使用Map键数据来对于命名参数，而Map值数据用于设值；

2）SqlParameterSource：可以使用SqlParameterSource实现作为来实现为命名参数设值，默认有MapSqlParameterSource和BeanPropertySqlParameterSource实现；MapSqlParameterSource实现非常简单，只是封装了java.util.Map；而BeanPropertySqlParameterSource封装了一个JavaBean对象，通过JavaBean对象属性来决定命名参数的值。

 

java代码：
Java代码 复制代码 收藏代码
  1. package cn.javass.spring.chapter7;   
  2. public class UserModel {   
  3.     private int id;   
  4.     private String myName;      
  5.     //省略getter和setter        
  6. }  

 

 

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testNamedParameterJdbcTemplate2() {   
  3.     NamedParameterJdbcTemplate namedParameterJdbcTemplate = null;   
  4.     namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);   
  5.     UserModel model = new UserModel();   
  6.     model.setMyName("name5");   
  7.     String insertSql = "insert into test(name) values(:myName)";   
  8.     SqlParameterSource paramSource = new BeanPropertySqlParameterSource(model);   
  9.     namedParameterJdbcTemplate.update(insertSql, paramSource);   
  10. }  

 

可以看出BeanPropertySqlParameterSource使用能减少很多工作量，但命名参数必须和JavaBean属性名称相对应才可以。

 

7.2.5  SimpleJdbcTemplate

       SimpleJdbcTemplate类也是基于JdbcTemplate类，但利用Java5+的可变参数列表和自动装箱和拆箱从而获取更简洁的代码。

SimpleJdbcTemplate主要提供两类方法：query及queryForXXX方法、update及batchUpdate方法。

首先让我们看个例子吧：

 

java代码：
Java代码 复制代码 收藏代码
  1. //定义UserModel的RowMapper   
  2. package cn.javass.spring.chapter7;   
  3. import java.sql.ResultSet;   
  4. import java.sql.SQLException;   
  5. import org.springframework.jdbc.core.RowMapper;   
  6. public class UserRowMapper implements RowMapper<UserModel> {   
  7.     @Override  
  8.     public UserModel mapRow(ResultSet rs, int rowNum) throws SQLException {   
  9.         UserModel model = new UserModel();   
  10.         model.setId(rs.getInt("id"));   
  11.         model.setMyName(rs.getString("name"));   
  12.         return model;   
  13.     }   
  14. }  

 

 

java代码：
Java代码 复制代码 收藏代码
  1. @Test  
  2. public void testSimpleJdbcTemplate() {   
  3.     //还支持DataSource和NamedParameterJdbcTemplate作为构造器参数  
  4.     SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(jdbcTemplate);   
  5.     String insertSql = "insert into test(id, name) values(?, ?)";   
  6.     simpleJdbcTemplate.update(insertSql, 10, "name5");   
  7.     String selectSql = "select * from test where id=? and name=?";   
  8.     List<Map<String, Object>> result = simpleJdbcTemplate.queryForList(selectSql, 10, "name5");   
  9.     Assert.assertEquals(1, result.size());       
  10.     RowMapper<UserModel> mapper = new UserRowMapper();         
  11.     List<UserModel> result2 = simpleJdbcTemplate.query(selectSql, mapper, 10, "name5");   
  12.     Assert.assertEquals(1, result2.size());      
  13. }  

 

1）SimpleJdbcTemplate初始化：可以使用DataSource、JdbcTemplate或NamedParameterJdbcTemplate对象作为构造器参数初始化；

2）update(insertSql, 10, "name5")：采用Java5+可变参数列表从而代替new Object[]{10, "name5"}方式；

3）query(selectSql, mapper, 10, "name5")：使用Java5+可变参数列表及RowMapper回调并利用泛型特性来指定返回值类型（List<UserModel>）。

 

SimpleJdbcTemplate类还支持命名参数特性，如queryForList(String sql, SqlParameterSource args)和queryForList(String sql, Map<String, ?> args) ，类似于NamedParameterJdbcTemplate中使用，在此就不介绍了。

 

注：SimpleJdbcTemplate还提供类似于ParameterizedRowMapper 用于泛型特性的支持，ParameterizedRowMapper是RowMapper的子类，但从Spring 3.0由于允许环境需要Java5+，因此不再需要ParameterizedRowMapper ，而可以直接使用RowMapper；

query(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)

query(String sql, RowMapper<T> rm, Object... args) //直接使用该语句

 

SimpleJdbcTemplate还提供如下方法用于获取JdbcTemplate和NamedParameterJdbcTemplate：

1）获取JdbcTemplate对象方法：JdbcOperations是JdbcTemplate的接口

JdbcOperations getJdbcOperations()

2）获取NamedParameterJdbcTemplate对象方法：NamedParameterJdbcOperations是NamedParameterJdbcTemplate的接口

NamedParameterJdbcOperations getNamedParameterJdbcOperations()

 

 

原创内容，转载请注明出处【http://sishuok.com/forum/blogPost/list/0/2490.html】

魅族安卓数据dns修改 魅族安卓数据dns修改
原创粉丝点击
热门IT博客
qq三国100js孟获qq三国100js孟获
截获特定端口的数据包截获特定端口的数据包
linux nginx 自动启动
双11淘宝退货率
linux export
日本工资 知乎
广联达预算软件版本
unity3d 模型下载
四三九九网络ipo排队
32寸网络电视价格
淘宝网手提电脑
第一名排名软件
spring cloud 内存优化
软件测试学不会
淘宝商品ps教程
手机图文设计软件
2017人口普查数据
青岛城阳灭门案 知乎
许嵩如果当时知乎
淘宝联盟qq推广设置
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 吊兰图片 金边吊兰 吊兰作用 吊兰的作用 青叶吊兰 银边吊兰 牡丹吊兰 叶吊兰 珍珠吊兰 水培吊兰 吊兰怎么养 金心吊兰 彩叶吊兰 吊兰开花 大叶吊兰 吊兰花 吊兰水培 千叶吊兰 吊兰花语 吊兰水养 吊兰换盆 吊兰修剪 水养吊兰 吊兰开花吗 吊兰花图片 吊兰有毒吗 吊兰有几种 吊兰养殖 吊兰的根 吊兰花盆 吊兰种类 吊兰繁殖 吊兰的种类 吊兰品种 法国吊兰 宽叶吊兰 吊兰种子 紫吊兰图片 紫罗兰吊兰 银心吊兰 吊兰吧

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里