Spring3 对JDBC的支持 之 7.3 关系数据库操作对象化

于 2014-01-23 12:34:10 发布
阅读量832 收藏
点赞数
分类专栏： 编程语言 JAVA编程 SPRING
编程语言 同时被 3 个专栏收录
101 篇文章 1 订阅
订阅专栏
JAVA编程
89 篇文章 0 订阅
订阅专栏
SPRING
21 篇文章 0 订阅
订阅专栏
所谓 关系数据库对象化其实就是用面向对象方式表示关系数据库操作，从而可以复用。

Spring JDBC框架将数据库操作封装为一个RdbmsOperation，该对象是线程安全的、可复用的对象，是所有数据库对象的父类。而SqlOperation继承了RdbmsOperation，代表了数据库SQL操作，如select、update、call等，如图7-4所示。

 

 

图7-4 关系数据库操作对象化支持类

 

数据库操作对象化只要有以下几种类型，所以类型是线程安全及可复用的：

  • 查询：将数据库操作select封装为对象，查询操作的基类是SqlQuery，所有查询都可以使用该类表示，Spring JDBC还提供了一些更容易使用的MappingSqlQueryWithParameters和MappingSqlQuery用于将结果集映射为Java对象，查询对象类还提供了两个扩展UpdatableSqlQuery和SqlFunction；
  • 更新：即增删改操作，将数据库操作insert 、update、delete封装为对象，增删改基类是SqlUpdate，当然还提供了BatchSqlUpdate用于批处理；
  • 存储过程及函数：将存储过程及函数调用封装为对象，基类是SqlCall类，提供了StoredProcedure实现。

 

7.3.2  查询

1）SqlQuery：需要覆盖如下方法来定义一个RowMapper，其中parameters参数表示命名参数或占位符参数值列表，而context是由用户传入的上下文数据。

 

java代码：
查看 复制到剪贴板 打印
  1. RowMapper<T> newRowMapper(Object[] parameters, Map context)  

 

       SqlQuery提供两类方法：

  • execute及executeByNamedParam方法：用于查询多行数据，其中executeByNamedParam用于支持命名参数绑定参数；
  • findObject及findObjectByNamedParam方法：用于查询单行数据，其中findObjectByNamedParam用于支持命名参数绑定。

      

演示一下SqlQuery如何使用：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testSqlQuery() {  
  3.     SqlQuery query = new UserModelSqlQuery(jdbcTemplate);  
  4.     List<UserModel> result = query.execute("name5");  
  5.     Assert.assertEquals(0, result.size());  
  6. }  

 

从测试代码可以SqlQuery使用非常简单，创建SqlQuery实现对象，然后调用相应的方法即可，接下来看一下SqlQuery实现：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class UserModelSqlQuery extends SqlQuery<UserModel> {  
  4.     public UserModelSqlQuery(JdbcTemplate jdbcTemplate) {  
  5.         //super.setDataSource(jdbcTemplate.getDataSource());  
  6.         super.setJdbcTemplate(jdbcTemplate);  
  7.         super.setSql("select * from test where name=?");  
  8.         super.declareParameter(new SqlParameter(Types.VARCHAR));  
  9.         compile();  
  10.     }  
  11.     @Override  
  12.     protected RowMapper<UserModel> newRowMapper(Object[] parameters, Map context) {  
  13.         return new UserRowMapper();  
  14.     }  
  15. }  
  16.    

 

从测试代码可以看出，具体步骤如下：

一、setJdbcTemplate/ setDataSource：首先设置数据源或JdbcTemplate；

二、setSql("select * from test where name=?")：定义sql语句，所以定义的sql语句都将被编译为PreparedStatement；

三、declareParameter(new SqlParameter(Types.VARCHAR))：对PreparedStatement参数描述，使用SqlParameter来描述参数类型，支持命名参数、占位符描述；

对于命名参数可以使用如new SqlParameter("name", Types.VARCHAR)描述；注意占位符参数描述必须按占位符参数列表的顺序进行描述；

四、编译：可选，当执行相应查询方法时会自动编译，用于将sql编译为PreparedStatement，对于编译的SqlQuery不能再对参数进行描述了。

五、以上步骤是不可变的，必须按顺序执行。

 

 

2）MappingSqlQuery：用于简化SqlQuery中RowMapper创建，可以直接在实现mapRow(ResultSet rs, int rowNum)来将行数据映射为需要的形式；

MappingSqlQuery所有查询方法完全继承于SqlQuery。

演示一下MappingSqlQuery如何使用：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testMappingSqlQuery() {  
  3.     jdbcTemplate.update("insert into test(name) values('name5')");  
  4.     SqlQuery<UserModel> query = new UserModelMappingSqlQuery(jdbcTemplate);  
  5.     Map<String, Object> paramMap = new HashMap<String, Object>();  
  6.     paramMap.put("name", "name5");  
  7.     UserModel result = query.findObjectByNamedParam(paramMap);  
  8.     Assert.assertNotNull(result);  
  9. }  

 

MappingSqlQuery使用和SqlQuery完全一样，创建MappingSqlQuery实现对象，然后调用相应的方法即可，接下来看一下MappingSqlQuery实现，findObjectByNamedParam方法用于执行命名参数查询：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class UserModelMappingSqlQuery extends MappingSqlQuery<UserModel> {  
  4.   public UserModelMappingSqlQuery(JdbcTemplate jdbcTemplate) {  
  5.     super.setDataSource(jdbcTemplate.getDataSource());  
  6.     super.setSql("select * from test where name=:name");  
  7.     super.declareParameter(new SqlParameter("name", Types.VARCHAR));  
  8.     compile();  
  9.   }  
  10.   @Override  
  11.   protected UserModel mapRow(ResultSet rs, int rowNum) throws SQLException {  
  12.     UserModel model = new UserModel();  
  13.     model.setId(rs.getInt("id"));  
  14.     model.setMyName(rs.getString("name"));  
  15.     return model;  
  16.   }   
  17. }  

 

和SqlQuery唯一不同的是使用mapRow来讲每行数据转换为需要的形式，其他地方完全一样。

1）  UpdatableSqlQuery：提供可更新结果集查询支持，子类实现updateRow(ResultSet rs, int rowNum, Map context)对结果集进行更新。

2）  GenericSqlQuery：提供setRowMapperClass(Class rowMapperClass)方法用于指定RowMapper实现，在此就不演示了。具体请参考testGenericSqlQuery()方法。

3）  SqlFunction：SQL“函数”包装器，用于支持那些返回单行结果集的查询。该类主要用于返回单行单列结果集。

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testSqlFunction() {  
  3.     jdbcTemplate.update("insert into test(name) values('name5')");  
  4.     String countSql = "select count(*) from test";  
  5.     SqlFunction<Integer> sqlFunction1 = new SqlFunction<Integer>(jdbcTemplate.getDataSource(), countSql);  
  6.     Assert.assertEquals(1, sqlFunction1.run());  
  7.     String selectSql = "select name from test where name=?";  
  8.     SqlFunction<String> sqlFunction2 = new SqlFunction<String>(jdbcTemplate.getDataSource(), selectSql);  
  9.     sqlFunction2.declareParameter(new SqlParameter(Types.VARCHAR));  
  10.     String name = (String) sqlFunction2.runGeneric(new Object[] {"name5"});  
  11.     Assert.assertEquals("name5", name);  
  12. }  

 

如代码所示，SqlFunction初始化时需要DataSource和相应的sql语句，如果有参数需要使用declareParameter对参数类型进行描述；run方法默认返回int型，当然也可以使用runGeneric返回其他类型，如String等。

 

7.3.3  更新

       SqlUpdate类用于支持数据库更新操作，即增删改（insert、delete、update）操作，该方法类似于SqlQuery，只是职责不一样。

       SqlUpdate提供了update及updateByNamedParam方法用于数据库更新操作，其中updateByNamedParam用于命名参数类型更新。

 

演示一下SqlUpdate如何使用：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class InsertUserModel extends SqlUpdate {  
  4.     public InsertUserModel(JdbcTemplate jdbcTemplate) {  
  5.         super.setJdbcTemplate(jdbcTemplate);  
  6.         super.setSql("insert into test(name) values(?)");  
  7.         super.declareParameter(new SqlParameter(Types.VARCHAR));  
  8.         compile();  
  9.     }  
  10. }  
  11.    

 

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testSqlUpdate() {         
  3.     SqlUpdate insert = new InsertUserModel(jdbcTemplate);  
  4.     insert.update("name5");  
  5.          
  6.     String updateSql = "update test set name=? where name=?";  
  7.     SqlUpdate update = new SqlUpdate(jdbcTemplate.getDataSource(), updateSql, new int[]{Types.VARCHAR, Types.VARCHAR});  
  8.     update.update("name6", "name5");  
  9.     String deleteSql = "delete from test where name=:name";  
  10.    
  11.     SqlUpdate delete = new SqlUpdate(jdbcTemplate.getDataSource(), deleteSql, new int[]{Types.VARCHAR});  
  12.     Map<String, Object> paramMap = new HashMap<String, Object>();  
  13.     paramMap.put("name", "name5");  
  14.     delete.updateByNamedParam(paramMap);  
  15. }  

 

       InsertUserModel类实现类似于SqlQuery实现，用于执行数据库插入操作，SqlUpdate还提供一种更简洁的构造器SqlUpdate(DataSource ds, String sql, int[] types)，其中types用于指定占位符或命名参数类型；SqlUpdate还支持命名参数，使用updateByNamedParam方法来进行命名参数操作。

 

7.3.4  存储过程及函数

       StoredProcedure用于支持存储过程及函数，该类的使用同样类似于SqlQuery。

       StoredProcedure提供execute方法用于执行存储过程及函数。

一、StoredProcedure如何调用自定义函数：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testStoredProcedure1() {  
  3.     StoredProcedure lengthFunction = new HsqldbLengthFunction(jdbcTemplate);  
  4.     Map<String,Object> outValues = lengthFunction.execute("test");  
  5.     Assert.assertEquals(4, outValues.get("result"));  
  6. }     

 

StoredProcedure使用非常简单，定义StoredProcedure实现HsqldbLengthFunction，并调用execute方法执行即可，接下来看一下HsqldbLengthFunction实现：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class HsqldbLengthFunction extends StoredProcedure {  
  4.     public HsqldbLengthFunction(JdbcTemplate jdbcTemplate) {  
  5.         super.setJdbcTemplate(jdbcTemplate);  
  6.         super.setSql("FUNCTION_TEST");  
  7.         super.declareParameter(  
  8.           new SqlReturnResultSet("result", new ResultSetExtractor<Integer>() {  
  9.             @Override  
  10.             public Integer extractData(ResultSet rs) throws SQLException, DataAccessException {  
  11.                 while(rs.next()) {  
  12.                     return rs.getInt(1);  
  13.                 }  
  14.                 return 0;  
  15.             }  
  16.         }));  
  17.         super.declareParameter(new SqlParameter("str", Types.VARCHAR));  
  18.         compile();  
  19.     }  
  20. }  

 

StoredProcedure自定义函数使用类似于SqlQuery，首先设置数据源或JdbcTemplate对象，其次定义自定义函数，然后使用declareParameter进行参数描述，最后调用compile（可选）编译自定义函数。

 

接下来看一下mysql自定义函数如何使用：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testStoredProcedure2() {  
  3.     JdbcTemplate mysqlJdbcTemplate = new JdbcTemplate(getMysqlDataSource());  
  4.     String createFunctionSql =  
  5.         "CREATE FUNCTION FUNCTION_TEST(str VARCHAR(100)) " +  
  6.         "returns INT return LENGTH(str)";  
  7.     String dropFunctionSql = "DROP FUNCTION IF EXISTS FUNCTION_TEST";  
  8.     mysqlJdbcTemplate.update(dropFunctionSql);  
  9.     mysqlJdbcTemplate.update(createFunctionSql);  
  10.     StoredProcedure lengthFunction = new MysqlLengthFunction(mysqlJdbcTemplate);  
  11.     Map<String,Object> outValues = lengthFunction.execute("test");  
  12.     Assert.assertEquals(4, outValues.get("result"));  
  13. }  

 

MysqlLengthFunction自定义函数使用与HsqldbLengthFunction使用完全一样，只是内部实现稍有差别：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class MysqlLengthFunction extends StoredProcedure {  
  4.     public MysqlLengthFunction(JdbcTemplate jdbcTemplate) {  
  5.         super.setJdbcTemplate(jdbcTemplate);  
  6.         super.setSql("FUNCTION_TEST");  
  7.         super.setFunction(true);  
  8.         super.declareParameter(new SqlOutParameter("result", Types.INTEGER));  
  9.         super.declareParameter(new SqlParameter("str", Types.VARCHAR));  
  10.         compile();  
  11.     }  
  12. }  

 

       MysqlLengthFunction与HsqldbLengthFunction实现不同的地方有两点：

  • setFunction(true)：表示是自定义函数调用，即编译后的sql为{?= call …}形式；如果使用hsqldb不能设置为true，因为在hsqldb中{?= call …}和{call …}含义一样；
  • declareParameter(new SqlOutParameter("result", Types.INTEGER))：将自定义函数返回值类型直接描述为Types.INTEGER；SqlOutParameter必须指定name，而不用使用SqlReturnResultSet首先获取结果集，然后再从结果集获取返回值，这是mysql与hsqldb的区别；

 

一、StoredProcedure如何调用存储过程：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testStoredProcedure3() {  
  3.     StoredProcedure procedure = new HsqldbTestProcedure(jdbcTemplate);  
  4.     Map<String,Object> outValues = procedure.execute("test");  
  5.     Assert.assertEquals(0, outValues.get("outId"));  
  6.     Assert.assertEquals("Hello,test", outValues.get("inOutName"));  
  7. }  

 

 

StoredProcedure存储过程实现HsqldbTestProcedure调用与HsqldbLengthFunction调用完全一样，不同的是在实现时，参数描述稍有不同：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter7;  
  2. //省略import  
  3. public class HsqldbTestProcedure extends StoredProcedure {  
  4.     public HsqldbTestProcedure(JdbcTemplate jdbcTemplate) {  
  5.         super.setJdbcTemplate(jdbcTemplate);  
  6.         super.setSql("PROCEDURE_TEST");  
  7.         super.declareParameter(new SqlInOutParameter("inOutName", Types.VARCHAR));  
  8.         super.declareParameter(new SqlOutParameter("outId", Types.INTEGER));  
  9.         compile();  
  10.     }  
  11. }  
declareParameter：使用SqlInOutParameter描述INOUT类型参数，使用SqlOutParameter描述OUT类型参数，必须按顺序定义，不能颠倒。
悟之思语
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值