10.Spring集成JDBC

川长思鸟来 2021-09-29 07:26 298阅读 0赞

相信大家都很熟悉jdbc的开发过程了，jdbc的开发繁琐，易错，虽然我们可以重构自己的一套JDBC模板，从而能简化日常开发，但自己开发的JDBC模板不够通用，而且对于每一套JDBC模板实现都差不多，从而导致开发人员必须掌握每一套模板。

Spring JDBC提供了一套JDBC抽象框架，用于简化JDBC开发，而且如果各个公司都使用该抽象框架，开发人员首先减少了学习成本，直接上手开发。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70][]

### Spring对JDBC的支持 ###

Spring通过抽象JDBC访问并提供一致的API来简化JDBC编程的工作量。我们只需要声明SQL、调用合适的Spring JDBC框架API、处理结果集即可。事务由Spring管理，并将JDBC受检异常转换为Spring一致的非受检异常，从而简化开发。

Spring主要提供JDBC模板方式、关系数据库对象化方式来简化JDBC编程：

*  关系数据库操作对象化方式：Spring JDBC框架提供了将关系数据库操作对象化的表示形式，从而使用户可以采用面向对象编程来完成对数据库的访问；如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类。这些类的实现一旦建立即可重用并且是线程安全的。

Spring JDBC还提供了一些强大的工具类，如DataSourceUtils来在必要的时候手工获取数据库连接等。

### Spring的JDBC架构 ###

Spring JDBC抽象框架由四部分组成：datasource、support、core、object，如图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70 1][]

*  support包：提供将JDBC异常转换为DAO非检查异常转换类、一些工具类如JdbcUtils等。
 *  datasource包：提供简化访问JDBC 数据源（javax.sql.DataSource实现）工具类，并提供了一些DataSource简单实现类从而能使从这些DataSource获取的连接能自动得到Spring管理事务支持。
 *  core包：提供JDBC模板类实现及可变部分的回调接口，还提供SimpleJdbcInsert等简单辅助类。
 *  object包：提供关系数据库的对象表示形式，如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类，该包是基于core包JDBC模板类实现。

### JDBC模板类 ###

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

JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部

分），并且帮我们做那些固定部分，如连接的创建及关闭。

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70 2][]

Spring除了提供JdbcTemplate核心类，还提供了基于JdbcTemplate实现的NamedParameterJdbcTemplate类用于支持命名参数绑定、 SimpleJdbcTemplate类用于支持

Java5+的可变参数及自动装箱拆箱等特性。

### 使用JdbcTemplate模板类 ###

在使用JdbcTemplate模板类时必须通过DataSource获取数据库连接，Spring JDBC提供了

DriverManagerDataSource实现，它通过包装“DriverManager.getConnection”获取数据库连接。

Spring JDBC通过实现DaoSupport来支持一致的数据库访问。Spring JDBC提供如下DaoSupport实现：

• JdbcDaoSupport：用于支持一致的JdbcTemplate访问；

• NamedParameterJdbcDaoSupport:继承JdbcDaoSupport，同时提供NamedParameterJdbcTemplate访问；

• SimpleJdbcDaoSupport：继承JdbcDaoSupport，同时提供SimpleJdbcTemplate访问。

由于JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate类使用DataSourceUtils获取及释放连接，而且连接是与线程绑定的，因此这些JDBC模板类是线程安全的，即JdbcTemplate对象可以在多线程中重用。

接下来看一下Spring JDBC框架的最佳实践：

在项目pom.xml文件里添加jdbc依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
    <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
    </dependency>

下面基于JdbcTemplate模板类，使用mysql数据库进行下测试，在使用JdbcTemplate模板类时必须通过DataSource获取数据库连接，Spring JDBC提供了DriverManagerDataSource实现，它通过包装“DriverManager.getConnection”获取数据库连接

1)首先定义Dao接口

public interface IUserDao {
        int insert(User user);
        int delete(Integer uid);
        int update(User user);
        List<User> getAll();
        User getById(Integer id);
    }

2）定义Dao实现，此处是使用Spring JDBC实现：

public class UserJdbcDaoImpl extends SimpleJdbcDaoSupport implements IUserDao {
        private static final String INSERT_SQL = "insert into test(name) values(:myName)";
        private static final String COUNT_ALL_SQL = "select count(*) from test";    
        @Override
        public void save(UserModel model) {
            getSimpleJdbcTemplate().update(INSERT_SQL, new BeanPropertySqlParameterSource(model));
        }
        @Override
        public int countAll() {
            return getJdbcTemplate().update(COUNT_ALL_SQL);
        }  
    }

3）进行资源配置

resources.properties：

db.driver.class=com.mysql.cj.jdbc.Driver
    
    db.url=jdbc:mysql://127.0.0.1/first_db?characterEncoding=utf-8
    
    db.username=root
    
    db.password=9958

applicationContext-jdbc.xml：

<context:property-placeholder location="classpath:db/resources.properties"/>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        
        <property name="driverClassName" value="${db.driver.class}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
        <property name="maxWait" value="3000"/>
        <property name="maxActive" value="100"/>
        
        <property name="filters" value="wall,stat"/>
    </bean>
    
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="abstractDao" abstract="true">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <bean id="userDaoImpl"
          class="com.spring.db.dao.impl.UserDaoImpl"
          parent="abstractDao"/>

写个测试：

public class JdbcTemplateTest {
        private static UserDaoImpl userDao;
    
        @BeforeClass
        public static void setUpClass() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("db/applicationContext-jdbc.xml");
            userDao = ctx.getBean("userDaoImpl", UserDaoImpl.class);
        }
    
        /*增*/
        @Test
        public void add() {
            User user=new User();
            user.setName("lily");
            user.setSex("m");
            userDao.insert(user);
        }

**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)来处理结果集，用户必须处理整个结果集；

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

@Test
    public void testPreparedStatement1() {
        int count = jdbcTemplate.execute(new PreparedStatementCreator() {
            @Override
            public PreparedStatement createPreparedStatement(Connection conn)
                    throws SQLException {
                return conn.prepareStatement("select count(*) from user");
            }
        }, new PreparedStatementCallback<Integer>() {
            @Override
            public Integer doInPreparedStatement(PreparedStatement pstmt)
                    throws SQLException, DataAccessException {
                pstmt.execute();
                ResultSet rs = pstmt.getResultSet();
                rs.next();
                return rs.getInt(1);
            }
        });
        System.out.println("count========="+count);
    }

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

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

@Test
    public void testPreparedStatement2() {
        String insertSql = "insert into user(name,sex) values (?,?)";
        int count = jdbcTemplate.update(insertSql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement pstmt) throws SQLException {
                pstmt.setObject( 1,"marry");
                pstmt.setObject( 2,"m");
            }
        });
        System.out.println("count======"+count);
    
        String deleteSql = "delete from user where name=?";
        count = jdbcTemplate.update(deleteSql, new Object[]{"marry"});
        System.out.println(count);
    }

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

3）结果集处理回调：

@Test
    public void testResultSet1() {
        jdbcTemplate.update("insert into user(name,sex) values('test','f')");
        String listSql = "select * from user";
        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;
            }
        });
        System.out.println(result.size());
        jdbcTemplate.update("delete from user where name='test'");
    
    }

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

@Test
    public void testResultSet2() {
        jdbcTemplate.update("insert into user(name,sex) values('test','f')");
        String listSql = "select * from user";
        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);
            }
    
        });
        System.out.println(result.size());
        jdbcTemplate.update("delete from user where name='test'");
    
    }

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

@Test
    public void testResultSet3() {
        jdbcTemplate.update("insert into user(name,sex) values('test','f')");
        String listSql = "select * from user";
        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;
            }
        });
        System.out.println(result.size());
        jdbcTemplate.update("delete from user where name='test'");
    }

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

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

// 查询一行数据并将该行数据转换为Map返回

jdbcTemplate.queryForMap("select \* from user where name='name5'");

//查询一行任何类型的数据，最后一个参数指定返回结果类型

jdbcTemplate.queryForObject("select count(\*) from user", Integer.class);

//查询一批数据，默认将每行数据转换为Map

jdbcTemplate.queryForList("select \* from user");

//只查询一列数据列表，列类型是String类型，列名字是name

jdbcTemplate.queryForList("

select name from user where name=?", new Object\[\]\{"name5"\}, String.class);

//查询一批数据，返回为SqlRowSet，类似于ResultSet，但不再绑定到连接上

SqlRowSet rs = jdbcTemplate.queryForRowSet("select \* from user");

### NamedParameterJdbcTemplate ###

NamedParameterJdbcTemplate类是基于JdbcTemplate类，并对它进行了封装从而支持命名参数特性。NamedParameterJdbcTemplate主要提供以下三类方法：execute方法、query及queryForXXX方法、update及batchUpdate方法。首先让我们看个例子吧：

@Test
        public void testNamedParameterJdbcTemplate1() {
            NamedParameterJdbcTemplate namedParameterJdbcTemplate = null;
            namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
            String insertSql = "insert into user(name,sex) values(:name,:sex)";
            String selectSql = "select * from user where name=:name";
            String deleteSql = "delete from user where name=:name";
            Map<String, Object> paramMap = new HashMap<String, Object>();
            paramMap.put("name", "name6");
            paramMap.put("sex", "f");
            namedParameterJdbcTemplate.update(insertSql, paramMap);
    
            final List<Integer> result = new ArrayList<Integer>();
            namedParameterJdbcTemplate.query(selectSql, paramMap, new RowCallbackHandler() {
    
                @Override
                public void processRow(ResultSet rs) throws SQLException {
                    result.add(rs.getInt("id"));
                }
            });
            assertEquals(1, result.size());
            SqlParameterSource paramSource = new MapSqlParameterSource(paramMap);
            namedParameterJdbcTemplate.update(deleteSql, paramSource);
    
        }

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

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

2）insert into user(name,sex) values(:name,:sex)：其中“: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对象属性来决定命名参数的值。

public class UserModel {
        private int id;
        private String myName;
        private String sex;
        //省略getter和setter
    }

@Test
    public void testNamedParameterJdbcTemplate2() {
        NamedParameterJdbcTemplate namedParameterJdbcTemplate = null;
        namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
        UserModel model = new UserModel();
        model.setMyName("name5");
        String insertSql = "insert into test(name) values(:myName)";
        SqlParameterSource paramSource = new BeanPropertySqlParameterSource(model);
        namedParameterJdbcTemplate.update(insertSql, paramSource);
    }

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

参考：

[https://www.cnblogs.com/xiohao/p/3663619.html][https_www.cnblogs.com_xiohao_p_3663619.html]

[https://blog.csdn.net/sinat\_39955521/article/details/78957617][https_blog.csdn.net_sinat_39955521_article_details_78957617]

[https://blog.csdn.net/weixin\_42047611/article/details/80926415][https_blog.csdn.net_weixin_42047611_article_details_80926415]

[https://www.cnblogs.com/jiyukai/p/9386183.html][https_www.cnblogs.com_jiyukai_p_9386183.html]

[http://sishuok.com/forum/blogPost/list/0/2489.html][http_sishuok.com_forum_blogPost_list_0_2489.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70]: /images/20210920/9442c7280cd6470292e384c0c9b6cd93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70 1]: /images/20210920/02cdae99a8e344619870f6c43ee23dcf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70 2]: /images/20210920/27d5636aadb146b6a265a9f4fc001880.png
[https_www.cnblogs.com_xiohao_p_3663619.html]: https://www.cnblogs.com/xiohao/p/3663619.html
[https_blog.csdn.net_sinat_39955521_article_details_78957617]: https://blog.csdn.net/sinat_39955521/article/details/78957617
[https_blog.csdn.net_weixin_42047611_article_details_80926415]: https://blog.csdn.net/weixin_42047611/article/details/80926415
[https_www.cnblogs.com_jiyukai_p_9386183.html]: https://www.cnblogs.com/jiyukai/p/9386183.html
[http_sishuok.com_forum_blogPost_list_0_2489.html]: http://sishuok.com/forum/blogPost/list/0/2489.html