开涛spring3(7.3) - 对JDBC的支持之 7.3 关系数据库操作对象化

7.3.1 概述

所谓关系数据库对象化其实就是用面向对象方式表示关系数据库操作，从而可以复用。

Spring JDBC框架将数据库操作封装为一个RdbmsOperation，该对象是线程安全的、可复用的对象，是所有数据库对象的父类。而 SqlOperation继承了RdbmsOperation，代表了数据库SQL操作，如select、update、call等，如图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是由用户传入的上下文数据。

RowMapper<T> newRowMapper(Object[] parameters, Map context)

SqlQuery提供两类方法：

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

演示一下SqlQuery如何使用：

    @Test  
    public void testSqlQuery() {  
        SqlQuery query = new UserModelSqlQuery(jdbcTemplate);  
        List<UserModel> result = query.execute("name5");  
        Assert.assertEquals(0, result.size());  
    }

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

package cn.javass.spring.chapter7;  
//省略import  
public class UserModelSqlQuery extends SqlQuery<UserModel> {  
    public UserModelSqlQuery(JdbcTemplate jdbcTemplate) {  
        //super.setDataSource(jdbcTemplate.getDataSource());  
        super.setJdbcTemplate(jdbcTemplate);  
        super.setSql("select * from test where name=?");  
        super.declareParameter(new SqlParameter(Types.VARCHAR));  
        compile();  
    }  
    @Override  
    protected RowMapper<UserModel> newRowMapper(Object[] parameters, Map context) {  
        return new UserRowMapper();  
    }  
}

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

一、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如何使用：

    @Test  
    public void testMappingSqlQuery() {  
        jdbcTemplate.update("insert into test(name) values('name5')");  
        SqlQuery<UserModel> query = new UserModelMappingSqlQuery(jdbcTemplate);  
        Map<String, Object> paramMap = new HashMap<String, Object>();  
        paramMap.put("name", "name5");  
        UserModel result = query.findObjectByNamedParam(paramMap);  
        Assert.assertNotNull(result);  
    }

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

    package cn.javass.spring.chapter7;  
    //省略import  
    public class UserModelMappingSqlQuery extends MappingSqlQuery<UserModel> {  
      public UserModelMappingSqlQuery(JdbcTemplate jdbcTemplate) {  
        super.setDataSource(jdbcTemplate.getDataSource());  
        super.setSql("select * from test where name=:name");  
        super.declareParameter(new SqlParameter("name", Types.VARCHAR));  
        compile();  
      }  
      @Override  
      protected UserModel mapRow(ResultSet rs, int rowNum) throws SQLException {  
        UserModel model = new UserModel();  
        model.setId(rs.getInt("id"));  
        model.setMyName(rs.getString("name"));  
        return model;  
      }   
    }

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

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

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

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

    @Test  
    public void testSqlFunction() {  
        jdbcTemplate.update("insert into test(name) values('name5')");  
        String countSql = "select count(*) from test";  
        SqlFunction<Integer> sqlFunction1 = new SqlFunction<Integer>(jdbcTemplate.getDataSource(), countSql);  
        Assert.assertEquals(1, sqlFunction1.run());  
        String selectSql = "select name from test where name=?";  
        SqlFunction<String> sqlFunction2 = new SqlFunction<String>(jdbcTemplate.getDataSource(), selectSql);  
        sqlFunction2.declareParameter(new SqlParameter(Types.VARCHAR));  
        String name = (String) sqlFunction2.runGeneric(new Object[] {"name5"});  
        Assert.assertEquals("name5", name);  
    }

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

7.3.3 更新

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

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

演示一下SqlUpdate如何使用：

package cn.javass.spring.chapter7;  
//省略import  
public class InsertUserModel extends SqlUpdate {  
    public InsertUserModel(JdbcTemplate jdbcTemplate) {  
        super.setJdbcTemplate(jdbcTemplate);  
        super.setSql("insert into test(name) values(?)");  
        super.declareParameter(new SqlParameter(Types.VARCHAR));  
        compile();  
    }  
}

    @Test  
    public void testSqlUpdate() {         
        SqlUpdate insert = new InsertUserModel(jdbcTemplate);  
        insert.update("name5");  
             
        String updateSql = "update test set name=? where name=?";  
        SqlUpdate update = new SqlUpdate(jdbcTemplate.getDataSource(), updateSql, new int[]{Types.VARCHAR, Types.VARCHAR});  
        update.update("name6", "name5");  
        String deleteSql = "delete from test where name=:name";  
       
        SqlUpdate delete = new SqlUpdate(jdbcTemplate.getDataSource(), deleteSql, new int[]{Types.VARCHAR});  
        Map<String, Object> paramMap = new HashMap<String, Object>();  
        paramMap.put("name", "name5");  
        delete.updateByNamedParam(paramMap);  
    }

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

7.3.4 存储过程及函数

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

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

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

@Test  
public void testStoredProcedure1() {  
    StoredProcedure lengthFunction = new HsqldbLengthFunction(jdbcTemplate);  
    Map<String,Object> outValues = lengthFunction.execute("test");  
    Assert.assertEquals(4, outValues.get("result"));  
}

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

    package cn.javass.spring.chapter7;  
    //省略import  
    public class HsqldbLengthFunction extends StoredProcedure {  
        public HsqldbLengthFunction(JdbcTemplate jdbcTemplate) {  
            super.setJdbcTemplate(jdbcTemplate);  
            super.setSql("FUNCTION_TEST");  
            super.declareParameter(  
              new SqlReturnResultSet("result", new ResultSetExtractor<Integer>() {  
                @Override  
                public Integer extractData(ResultSet rs) throws SQLException, DataAccessException {  
                    while(rs.next()) {  
                        return rs.getInt(1);  
                    }  
                    return 0;  
                }  
            }));  
            super.declareParameter(new SqlParameter("str", Types.VARCHAR));  
            compile();  
        }  
    }

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

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

    @Test  
    public void testStoredProcedure2() {  
        JdbcTemplate mysqlJdbcTemplate = new JdbcTemplate(getMysqlDataSource());  
        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);  
        StoredProcedure lengthFunction = new MysqlLengthFunction(mysqlJdbcTemplate);  
        Map<String,Object> outValues = lengthFunction.execute("test");  
        Assert.assertEquals(4, outValues.get("result"));  
    }

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

    package cn.javass.spring.chapter7;  
    //省略import  
    public class MysqlLengthFunction extends StoredProcedure {  
        public MysqlLengthFunction(JdbcTemplate jdbcTemplate) {  
            super.setJdbcTemplate(jdbcTemplate);  
            super.setSql("FUNCTION_TEST");  
            super.setFunction(true);  
            super.declareParameter(new SqlOutParameter("result", Types.INTEGER));  
            super.declareParameter(new SqlParameter("str", Types.VARCHAR));  
            compile();  
        }  
    }

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如何调用存储过程：

    @Test  
    public void testStoredProcedure3() {  
        StoredProcedure procedure = new HsqldbTestProcedure(jdbcTemplate);  
        Map<String,Object> outValues = procedure.execute("test");  
        Assert.assertEquals(0, outValues.get("outId"));  
        Assert.assertEquals("Hello,test", outValues.get("inOutName"));  
    }

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

    package cn.javass.spring.chapter7;  
    //省略import  
    public class HsqldbTestProcedure extends StoredProcedure {  
        public HsqldbTestProcedure(JdbcTemplate jdbcTemplate) {  
            super.setJdbcTemplate(jdbcTemplate);  
            super.setSql("PROCEDURE_TEST");  
            super.declareParameter(new SqlInOutParameter("inOutName", Types.VARCHAR));  
            super.declareParameter(new SqlOutParameter("outId", Types.INTEGER));  
            compile();  
        }  
    }

declareParameter：使用SqlInOutParameter描述INOUT类型参数，使用SqlOutParameter描述OUT类型参数，必须按顺序定义，不能颠倒。

posted @ 2015-03-05 11:17 crazyYong 阅读(226) 评论(0) 编辑收藏举报

刷新页面返回顶部

开涛spring3(7.3) - 对JDBC的支持 之 7.3 关系数据库操作对象化

7.3.1 概述

7.3.2 查询

7.3.3 更新

7.3.4 存储过程及函数

公告

开涛spring3(7.3) - 对JDBC的支持之 7.3 关系数据库操作对象化