spring学习之JdbcTemplate

于 2017-07-23 15:54:13 发布
阅读量308 收藏
点赞数

JdbcTemplate 主要提供一下四类方法：
1.execute() 方法：主要用于DDL语句；
2.update() batchupdate()方法：update()主要用于执行增，删，改；
batchupdate()主要用于执行批处理语句；

//batchupdate详解
/*使用的原因：在某些情况下，可能需要将一批记录插入到数据库中。如果你对每条记录调用一个插件的方法，SQL语句将被重复编译，造成系统缓慢进行。
在上述情况下，你可以使用 JdbcTemplate BATCHUPDATE()方法来执行批量插入操作。用这种方法，该语句只被编译一次，执行多次。
*/
//insert batchupdate example
public void InsertBatchupdate(final List<Customer> customers){
    String insert_sql = "insert into customer(name,id) value(?,?)";
    getJdbcTemplate().batchUpdate(insert_sql, new BatchPreparedStatementSetter(){
        @Override
        public void setValues(PreparedStatement ps, int i) throws SQLException{
            Customer customer = customers.get(i);
            ps.setString(1,customer.getname());
            ps.setInt(2,customer.getid());
            }
        @Override
        public int getBatchSize(){
            return customer.size();
        }
    });
}
//Or
public void insertBatch(){
    getJdbcTemplate().batchUpdate(new String[]{sql});
}

@test
public void testBatch(){
    //Customer的初始化省略
    customerDao.insertBatch(customers); 
}

3.query()，queryForxxx()：详细用法见下面的链接
4.call():用于执行储存过程，函数相关等操作；

JdbcTempalte支持的回调类： 

预编译语句及存储过程创建回调：用于根据JdbcTemplate提供的连接创建相应的语句；
                     PreparedStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的PreparedStatement；
                     CallableStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的CallableStatement；

//预编译语句及存储过程创建回调、自定义功能回调使用：
@Test  
public void testPpreparedStatement1() {  
  int count = jdbcTemplate.execute(new PreparedStatementCreator() {  
     @Override  
     public PreparedStatement createPreparedStatement(Connection conn)  
         throws SQLException {  
         return conn.prepareStatement("select count(*) from test");  
     }}, new PreparedStatementCallback<Integer>() {  
     @Override  
     public Integer doInPreparedStatement(PreparedStatement pstmt)  
         throws SQLException, DataAccessException {  
         pstmt.execute();  
         ResultSet rs = pstmt.getResultSet();  
         rs.next();  
         return rs.getInt(1);  
      }});      
   Assert.assertEquals(0, count);  
}  
(注：首先使用PreparedStatementCreator创建一个预编译语句，其次由JdbcTemplate通过PreparedStatementCallback回调传回，由用户决定如何执行该PreparedStatement。此处我们使用的是execute方法。)

预编译语句设值回调：用于给预编译语句相应参数设值；
     PreparedStatementSetter：通过回调获取JdbcTemplate提供的PreparedStatement，由用户来对相应的预编译语句相应参数设值；
     BatchPreparedStatementSetter：；类似于PreparedStatementSetter，但用于批处理，需要指定批处理大小；

//预编译语句设值回调使用：
@Test  
public void testPreparedStatement2() {  
  String insertSql = "insert into test(name) values (?)";  
  int count = jdbcTemplate.update(insertSql, new PreparedStatementSetter() {  
      @Override  
      public void setValues(PreparedStatement pstmt) throws SQLException {  
          pstmt.setObject(1, "name4");  
  }});  
  Assert.assertEquals(1, count);      
  String deleteSql = "delete from test where name=?";  
  count = jdbcTemplate.update(deleteSql, new Object[] {"name4"});  
  Assert.assertEquals(1, count);  
}  
结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式；
     RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。
     RowCallbackHandler：用于处理ResultSet的每一行结果，用户需实现方法processRow(ResultSet rs)来完成处理，在该回调方法中无需执行rs.next()，该操作由JdbcTemplate来执行，用户只需按行获取数据然后处理即可。
     ResultSetExtractor：用于结果集数据提取，用户需实现方法extractData(ResultSet rs)来处理结果集，用户必须处理整个结果集；

@Test  
public void testResultSet1() {  
  jdbcTemplate.update("insert into test(name) values('name5')");  
  String listSql = "select * from test";  
  List result = jdbcTemplate.query(listSql, new RowMapper<Map>() {  
      @Override  
      public Map mapRow(ResultSet rs, int rowNum) throws SQLException {  
          Map row = new HashMap();  
          row.put(rs.getInt("id"), rs.getString("name"));  
          return row;  
  }});  
  Assert.assertEquals(1, result.size());  
  jdbcTemplate.update("delete from test where name='name5'");       
}  
（注：RowMapper接口提供mapRow(ResultSet rs, int rowNum)方法将结果集的每一行转换为一个Map，当然可以转换为其他类，如表的对象画形式。）

@Test  
public void testResultSet2() {  
  jdbcTemplate.update("insert into test(name) values('name5')");  
  String listSql = "select * from test";  
  final List result = new ArrayList();  
  jdbcTemplate.query(listSql, new RowCallbackHandler() {  
      @Override  
      public void processRow(ResultSet rs) throws SQLException {  
          Map row = new HashMap();  
          row.put(rs.getInt("id"), rs.getString("name"));  
          result.add(row);  
  }});  
  Assert.assertEquals(1, result.size());  
  jdbcTemplate.update("delete from test where name='name5'");  
}  
（注：RowCallbackHandler接口也提供方法processRow(ResultSet rs)，能将结果集的行转换为需要的形式。）

@Test  
public void testResultSet3() {  
  jdbcTemplate.update("insert into test(name) values('name5')");  
  String listSql = "select * from test";  
  List result = jdbcTemplate.query(listSql, new ResultSetExtractor<List>() {  
      @Override  
      public List extractData(ResultSet rs)  
     throws SQLException, DataAccessException {  
          List result = new ArrayList();  
          while(rs.next()) {  
              Map row = new HashMap();  
              row.put(rs.getInt("id"), rs.getString("name"));  
              result.add(row);  
           }  
           return result;  
  }});  
  Assert.assertEquals(0, result.size());  
  jdbcTemplate.update("delete from test where name='name5'");  
}  
（注：ResultSetExtractor使用回调方法extractData(ResultSet rs)提供给用户整个结果集，让用户决定如何处理该结果集。）

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

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

mysql如何调用自定义函数示例：

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

mysql如何调用存储过程：

@Test  
public void testCallableStatementCreator3() {  
    final String callProcedureSql = "{call PROCEDURE_TEST(?, ?)}";  
    List<SqlParameter> params = new ArrayList<SqlParameter>();  
    params.add(new SqlInOutParameter("inOutName", Types.VARCHAR));  
    params.add(new SqlOutParameter("outId", Types.INTEGER));  
    Map<String, Object> outValues = jdbcTemplate.call(  
      new CallableStatementCreator() {  
        @Override  
        public CallableStatement createCallableStatement(Connection conn) throws SQLException {  
          CallableStatement cstmt = conn.prepareCall(callProcedureSql);  
          cstmt.registerOutParameter(1, Types.VARCHAR);  
          cstmt.registerOutParameter(2, Types.INTEGER);  
          cstmt.setString(1, "test");  
          return cstmt;  
    }}, params);  
    Assert.assertEquals("Hello,test", outValues.get("inOutName"));  
    Assert.assertEquals(0, outValues.get("outId"));  
}  
(注：{call PROCEDURE_TEST(?, ?)}：定义存储过程sql；
    params：定义存储过程参数；SqlInOutParameter描述INOUT类型参数、SqlOutParameter描述OUT类型参数；
    CallableStatementCreator：用于创建CallableStatement，并设值及注册OUT参数类型；
    outValues：通过SqlInOutParameter及SqlOutParameter参数定义的name来获取存储过程结果。)

常见用法见链接
http://www.iteye.com/topic/53526

mrzhangzifu
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值