欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

【第七章】 对JDBC的支持 之 7.4 Spring提供的其它帮助 ——跟我学spring3【私塾在线原创】

程序员文章站 2022-06-15 16:39:48
...

 

 

 7.4  Spring提供的其它帮助

7.4.1  SimpleJdbc方式

       Spring JDBC抽象框架提供SimpleJdbcInsert和SimpleJdbcCall类，这两个类通过利用JDBC驱动提供的数据库元数据来简化JDBC操作。

 

1、SimpleJdbcInsert： 用于插入数据，根据数据库元数据进行插入数据，本类用于简化插入操作，提供三种类型方法：execute方法用于普通插入、executeAndReturnKey及executeAndReturnKeyHolder方法用于插入时获取主键值、executeBatch方法用于批处理。

 

java代码：
Java代码  收藏代码
  1. @Test  
  2. public void testSimpleJdbcInsert() {  
  3.     SimpleJdbcInsert insert = new SimpleJdbcInsert(jdbcTemplate);  
  4.     insert.withTableName("test");  
  5.     Map<String, Object> args = new HashMap<String, Object>();  
  6.     args.put("name", "name5");  
  7.     insert.compile();  
  8.     //1.普通插入  
  9.     insert.execute(args);  
  10.     Assert.assertEquals(1, jdbcTemplate.queryForInt("select count(*) from test"));  
  11.     //2.插入时获取主键值  
  12.     insert = new SimpleJdbcInsert(jdbcTemplate);  
  13.     insert.withTableName("test");  
  14.     insert.setGeneratedKeyName("id");  
  15.     Number id = insert.executeAndReturnKey(args);  
  16.     Assert.assertEquals(1, id);  
  17.     //3.批处理  
  18.     insert = new SimpleJdbcInsert(jdbcTemplate);  
  19.     insert.withTableName("test");  
  20.     insert.setGeneratedKeyName("id");  
  21.     int[] updateCount = insert.executeBatch(new Map[] {args, args, args});  
  22.     Assert.assertEquals(1, updateCount[0]);  
  23.     Assert.assertEquals(5, jdbcTemplate.queryForInt("select count(*) from test"));  
  24. }  
  • new SimpleJdbcInsert(jdbcTemplate) ： 首次通过DataSource对象或JdbcTemplate对象初始化SimpleJdbcInsert；
  • insert.withTableName("test") ： 用于设置数据库表名；
  • args ： 用于指定插入时列名及值，如本例中只有name列名，即编译后的sql类似于“insert into test(name) values(?)”；
  • insert.compile() ： 可选的编译步骤，在调用执行方法时自动编译，编译后不能再对insert对象修改；
  • 执行： execute方法用于执行普通插入；executeAndReturnKey用于执行并获取自动生成主键（注意是Number类型），必须首先通过setGeneratedKeyName设置主键然后才能获取，如果想获取复合主键请使用setGeneratedKeyNames描述主键然后通过executeReturningKeyHolder获取复合主键KeyHolder对象；executeBatch用于批处理；

 

2、SimpleJdbcCall： 用于调用存储过程及自定义函数，本类用于简化存储过程及自定义函数调用。

 

java代码：
Java代码  
  1. @Test  
  2. public void testSimpleJdbcCall1() {  
  3.     //此处用mysql,因为hsqldb调用自定义函数和存储过程一样  
  4.     SimpleJdbcCall call = new SimpleJdbcCall(getMysqlDataSource());  
  5.     call.withFunctionName("FUNCTION_TEST");  
  6.     call.declareParameters(new SqlOutParameter("result", Types.INTEGER));  
  7.     call.declareParameters(new SqlParameter("str", Types.VARCHAR));  
  8.     Map<String, Object> outVlaues = call.execute("test");  
  9.     Assert.assertEquals(4, outVlaues.get("result"));  
  10. }  
  • new SimpleJdbcCall(getMysqlDataSource()) ：通过DataSource对象或JdbcTemplate对象初始化SimpleJdbcCall；
  • withFunctionName("FUNCTION_TEST") ： 定义自定义函数名；自定义函数sql语句将被编译为类似于{?= call …}形式；
  • declareParameters ： 描述参数类型，使用方式与StoredProcedure对象一样；
  • 执行： 调用execute方法执行自定义函数；

 

java代码：
Java代码  
  1. @Test  
  2. public void testSimpleJdbcCall2() {  
  3.     //调用hsqldb自定义函数得使用如下方式  
  4.     SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate);  
  5.     call.withProcedureName("FUNCTION_TEST");  
  6. call.declareParameters(new SqlReturnResultSet("result",  
  7. new ResultSetExtractor<Integer>() {  
  8.         @Override  
  9.         public Integer extractData(ResultSet rs)  
  10. throws SQLException, DataAccessException {  
  11.           while(rs.next()) {  
  12.             return rs.getInt(1);  
  13.           }  
  14.           return 0;  
  15.     }}));  
  16.     call.declareParameters(new SqlParameter("str", Types.VARCHAR));  
  17.     Map<String, Object> outVlaues = call.execute("test");  
  18.     Assert.assertEquals(4, outVlaues.get("result"));  
  19. }  

 

 

调用hsqldb数据库自定义函数与调用mysql自定义函数完全不同，详见StoredProcedure中的解释。

 

java代码：
Java代码  
  1. @Test  
  2. public void testSimpleJdbcCall3() {  
  3.   SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate);  
  4.   call.withProcedureName("PROCEDURE_TEST");  
  5.   call.declareParameters(new SqlInOutParameter("inOutName", Types.VARCHAR));  
  6.   call.declareParameters(new SqlOutParameter("outId", Types.INTEGER));  
  7.   SqlParameterSource params =  
  8.   new MapSqlParameterSource().addValue("inOutName", "test");  
  9.   Map<String, Object> outVlaues = call.execute(params);  
  10.   Assert.assertEquals("Hello,test", outVlaues.get("inOutName"));  
  11.   Assert.assertEquals(0, outVlaues.get("outId"));  
  12. }  

 

与自定义函数调用不同的是使用withProcedureName来指定存储过程名字；其他参数描述等完全一样。

 

7.4.2  控制数据库连接

       Spring JDBC通过DataSource控制数据库连接，即通过DataSource实现获取数据库连接。

       Spring JDBC提供了一下DataSource实现：

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

第三方提供的DataSource实现主要有C3P0、Proxool、DBCP等，这些实现都具有数据库连接池能力。

 

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

 

7.4.3  获取自动生成的主键

       有许多数据库提供自动生成主键的能力，因此我们可能需要获取这些自动生成的主键，JDBC 3.0标准支持获取自动生成的主键，且必须数据库支持自动生成键获取。

1 ）JdbcTemplate 获取自动生成主键方式：

 

java代码：
Java代码  
  1. @Test  
  2. public void testFetchKey1() throws SQLException {  
  3.     final String insertSql = "insert into test(name) values('name5')";  
  4.     KeyHolder generatedKeyHolder = new GeneratedKeyHolder();  
  5.     jdbcTemplate.update(new PreparedStatementCreator() {  
  6.         @Override  
  7.        public PreparedStatement createPreparedStatement(Connection conn)  
  8.             throws SQLException {  
  9.             return conn.prepareStatement(insertSql, new String[]{"ID"});  
  10.       }}, generatedKeyHolder);  
  11.     Assert.assertEquals(0, generatedKeyHolder.getKey());  
  12. }  

 

使用JdbcTemplate的update(final PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)方法执行需要返回自动生成主键的插入语句，其中psc用于创建PreparedStatement并指定自动生成键，如“prepareStatement(insertSql, new String[]{"ID"})”；generatedKeyHolder是KeyHolder类型，用于获取自动生成的主键或复合主键；如使用getKey方法获取自动生成的主键。

 

2 ）SqlUpdate 获取自动生成主键方式：

 

java代码：
Java代码  
  1. @Test  
  2. public void testFetchKey2() {  
  3.     final String insertSql = "insert into test(name) values('name5')";  
  4.     KeyHolder generatedKeyHolder = new GeneratedKeyHolder();  
  5.     SqlUpdate update = new SqlUpdate();  
  6.     update.setJdbcTemplate(jdbcTemplate);  
  7.     update.setReturnGeneratedKeys(true);  
  8.     //update.setGeneratedKeysColumnNames(new String[]{"ID"});  
  9.     update.setSql(insertSql);  
  10.     update.update(null, generatedKeyHolder);  
  11.     Assert.assertEquals(0, generatedKeyHolder.getKey());  
  12. }  
  13.    

 

SqlUpdate获取自动生成主键方式和JdbcTemplate完全一样，可以使用setReturnGeneratedKeys（true）表示要获取自动生成键；也可以使用setGeneratedKeysColumnNames指定自动生成键列名。

 

3 ）SimpleJdbcInsert ： 前边示例已介绍，此处就不演示了。

 

7.4.4  JDBC批量操作

       JDBC批处理用于减少与数据库交互的次数来提升性能，Spring JDBC抽象框架通过封装批处理操作来简化批处理操作

1 ）JdbcTemplate 批处理： 支持普通的批处理及占位符批处理；

 

java代码：
Java代码  
  1. @Test  
  2. public void testBatchUpdate1() {  
  3.     String insertSql = "insert into test(name) values('name5')";  
  4.     String[] batchSql = new String[] {insertSql, insertSql};  
  5.     jdbcTemplate.batchUpdate(batchSql);  
  6.     Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));  
  7. }  

 

       直接调用batchUpdate方法执行需要批处理的语句即可。

 

java代码：
Java代码  
  1. @Test  
  2. public void testBatchUpdate2() {  
  3.     String insertSql = "insert into test(name) values(?)";  
  4.     final String[] batchValues = new String[] {"name5", "name6"};  
  5.     jdbcTemplate.batchUpdate(insertSql, new BatchPreparedStatementSetter() {  
  6.         @Override  
  7.         public void setValues(PreparedStatement ps, int i) throws SQLException {  
  8.             ps.setString(1, batchValues[i]);  
  9.         }  
  10.         @Override  
  11.         public int getBatchSize() {  
  12.             return batchValues.length;  
  13.         }  
  14.     });  
  15.     Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));  
  16. }  

 

       JdbcTemplate还可以通过batchUpdate(String sql, final BatchPreparedStatementSetter pss)方法进行批处理，该方式使用预编译语句，然后通过BatchPreparedStatementSetter实现进行设值（setValues）及指定批处理大小（getBatchSize）。

 

2 ）NamedParameterJdbcTemplate 批处理： 支持命名参数批处理；

 

java代码：
Java代码  
  1. @Test  
  2. public void testBatchUpdate3() {  
  3.     NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);  
  4.     String insertSql = "insert into test(name) values(:myName)";  
  5.     UserModel model = new UserModel();  
  6.     model.setMyName("name5");  
  7.     SqlParameterSource[] params = SqlParameterSourceUtils.createBatch(new Object[] {model, model});  
  8.     namedParameterJdbcTemplate.batchUpdate(insertSql, params);  
  9.     Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));  
  10. }  

 

 

通过batchUpdate(String sql, SqlParameterSource[] batchArgs)方法进行命名参数批处理，batchArgs指定批处理数据集。SqlParameterSourceUtils.createBatch用于根据JavaBean对象或者Map创建相应的BeanPropertySqlParameterSource或MapSqlParameterSource。

 

3) SimpleJdbcTemplate 批处理： 已更简单的方式进行批处理；

 

 

java代码：
Java代码  
  1. @Test  
  2. public void testBatchUpdate4() {  
  3.     SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(jdbcTemplate);  
  4.     String insertSql = "insert into test(name) values(?)";  
  5.     List<Object[]> params = new ArrayList<Object[]>();  
  6.     params.add(new Object[]{"name5"});  
  7.     params.add(new Object[]{"name5"});  
  8.     simpleJdbcTemplate.batchUpdate(insertSql, params);  
  9.     Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));  
  10. }  

       本示例使用batchUpdate(String sql, List<Object[]> batchArgs)方法完成占位符批处理，当然也支持命名参数批处理等。

 

 

4 ）SimpleJdbcInsert 批处理：

 

 

java代码：
Java代码  
  1. @Test  
  2. public void testBatchUpdate5() {  
  3.     SimpleJdbcInsert insert = new SimpleJdbcInsert(jdbcTemplate);  
  4.     insert.withTableName("test");  
  5.     Map<String, Object> valueMap = new HashMap<String, Object>();  
  6.     valueMap.put("name", "name5");  
  7.     insert.executeBatch(new Map[] {valueMap, valueMap});  
  8.    Assert.assertEquals(2, jdbcTemplate.queryForInt("select count(*) from test"));  
  9. }  

 

上一篇： thinkphp中的composer.json是做啥用的

下一篇： Duplicate entry_PHP教程

推荐阅读