《Spring实战》-第十章:Spring和JDBC

慢慢来比较快，虚心学技术

数据访问操作：初始化数据访问框架、打开连接、处理各种异常和关闭连接，任何一步出现异常都有可能导致损坏或删除企业数据库珍贵数据

一、Spring 的数据访问哲学

①松耦合

为了避免持久化的逻辑分散到应用的各个组件中，最好将数据访问的功能放到一个或多个专注于此项任务的组件中。这样的组件通常称为数据访问对象（ data access object ， DAO ）或 Repositor

为了避免应用与特定的数据访问策略耦合在一起，编写良好的 Repository 应该以接口的方式暴露功能。图 10.1 展现了设计数据访问层的合理方式

接口是实现松耦合代码的关键，并且应将其用于应用程序的各个层，而不仅仅是持久化层

②Spring 数据访问异常

JDBC对于所有的数据访问问题都会抛出 SQLException ，可能导致抛出 SQLException 的常见问题包括：

• 应用程序无法连接数据库
• 要执行的查询存在语法错误；
• 查询中所使用的表和 / 或列不存在；
• 试图插入或更新的数据违反了数据库约束

可见JDBC对于数据访问异常的处理十分粗糙，他并不会告诉你具体问题出现在哪里，而是讲所有问题都指向SQLException。所以很多持久化框架如Hibernate等都会提供自身的数据访问异常类，以供使用。但是如果我们在应用层次中引入了持久化框架的异常，很显然会紧紧的耦合在一起，违反了松耦合的约定。故而，Spring提供了自身一系列的异常类。

然而，Spring所提供的异常都是继承自非检查型异常，所以并不需要强制开发人员必须catch。

二、Spring 数据访问模板化

模板方法模式（设计模式）：模板方法定义过程的主要框架，模板方法将过程中与特定实现相关的部分委托给接口，而这个接口的不同实现定义了过程中的具体行为

Spring将数据访问分为可变（模板）和不可变（固定）两部分：模板（ template ）和回调（ callback ）

• Spring 的模板类处理数据访问的固定部分 —— 事务控制、管理资源以及处理异常。
• 应用程序相关的数据访问 —— 语句、绑定参数以及整理结果集 —— 在回调的实现中处理。

模板：Spring为了兼容多个持久化框架，提供了一系列的模板类

jca.cci.core.CciTemplate	JCA CCI 连接
jdbc.core.JdbcTemplate	JDBC 连接
jdbc.core.namedparam.NamedParameterJdbcTemplate	支持命名参数的 JDBC 连接
jdbc.core.simple.SimpleJdbcTemplate	通过 Java 5 简化后的 JDBC 连接（ Spring 3.1 中已经废弃）
orm.hibernate3.HibernateTemplate	Hibernate 3.x 以上的 Session
orm.ibatis.SqlMapClientTemplate	iBATIS SqlMap 客户端
orm.jdo.JdoTemplate	Java 数据对象（ Java Data Object ）实现
orm.jpa.JpaTemplate	Java 持久化 API 的实体管理器

三、Spring+JDBC

Ⅰ、配置数据源

Spring配置数据源依赖的第三方框架都提供了基本的DataSource接口。

使用数据库连接池：

• Apache Commons DBCP
• c3p0
• BoneCP
• Druid

DBCP连接池

DBCP是 apache 上的一个 java 连接池项目，也是 tomcat 使用的连接池组件。

依赖于BasicDataSource对象实现数据源配置

BasicDataSource部分属性如下：

属性名	属性描述
driverClassName	数据库连接驱动名，如：com.mysql.jdbc.Driver
url	数据库连接地址，如:jdbc:mysql://localshot:3306/数据库名
username	数据库连接用户名
passowrd	数据库连接密码
defaultAutoCommit	设置从数据源中返回的连接是否采用自动提交机制，默认值为 true；
validationQuery	用于验证连接是否成功的查询SQL语句，SQL语句必须至少要返回一行数据，如你可以简单地设置为：“select count(*) from user”
initialSize	池启动时创建的连接数量
maxActive	同一时间可从池中分配的最多连接数。如果设置为 0 ，表示无限制
maxIdle	池里不会被释放的最多空闲连接数。如果设置为 0 ，表示无限制
maxOpenPreparedStatements	在同一时间能够从语句池中分配的预处理语句（ prepared statement ）的最大数量。如果设置为 0 ，表示无限制
maxWait	在抛出异常之前，池等待连接回收的最大时间（当没有可用连接时）。如果设置为 -1 ，表示无限等待
minEvictableIdleTimeMillis	连接在池中保持空闲而不被回收的最大时间
minIdle	在不创建新连接的情况下，池中保持空闲的最小连接数
poolPreparedStatements	是否对预处理语句（ prepared statement ）进行池管理（布尔值）
removeAbandoned	是否自我中断，默认是 false
removeAbandonedTimeout	几秒后数据连接会自动断开，在removeAbandoned为true，提供该值；
logAbandoned	是否记录中断事件， 默认为 false

首先引入依赖包：commons-dbcp.jar和commons-pool.jar

 <!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/commons-pool/commons-pool -->
    <dependency>
        <groupId>commons-pool</groupId>
        <artifactId>commons-pool</artifactId>
        <version>1.4</version>
    </dependency>

    <!--引入Spring-jdbc的支持-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    
    <!--引入mysql数据连接驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

两种方式配置DBCP连接池：

• 使用注解配置实现

①创建数据源配置类，定义数据源与JdbcTemplate操作模板

@Configuration
public class DataSourceConfig {
    /**
     * 数据源连接池
     */
    @Bean
    public DataSource dataSource(){
        BasicDataSource basicDataSource = new BasicDataSource();
        //设置驱动
        basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        //设置数据库路径
        basicDataSource.setUrl("jdbc:mysql://localhost:3306/spring");
        //设置数据库登录名
        basicDataSource.setUsername("spring");
        //设置数据库登录密码
        basicDataSource.setPassword("spring");
        //是否自动提交事务（默认为true）
        basicDataSource.setDefaultAutoCommit(true);
        return basicDataSource;
    }
    
    /**
     * Spring JdbcTemplate
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

②创建统一配置类，开启组件扫描，并将数据源配置类引入

@ComponentScan(basePackages = {"com.my.spring"})
@Configuration
@Import(DataSourceConfig.class)
public class SystemConfig {
}

③创建数据库操作的Object对象和相应的Dao和Service类

//BaseBean.java
@Data
public class BaseBean {

    private Integer id;

    private String name;

    private Integer age;
}

//BaseDaoParent.java,系统内所有Dao的父类，继承自JdbcDaoSupport
@Component
public class BaseDaoParent extends JdbcDaoSupport {
    
    //注入DataSource
    @Autowired
    private DataSource dataSource;
    
    //因为JdbcDaoSupport的setDataSource方法是final修饰的，@Autowired注入失败，所以必须手动注入
    @PostConstruct
    private void initialize(){
        setDataSource(dataSource);
    }
}

//BaseDao.java
@Repository
public class BaseDao extends BaseDaoParent{
    
    /**
     * 保存一个记录
     * @param baseBean
     */
    public void save(BaseBean baseBean){
        this.getJdbcTemplate().update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
    }
    
    /**
     * 获取所有bean记录
     * @return
     */
    public List<BaseBean> findAll(){
        RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
        return this.getJdbcTemplate().query("select * from basebean",rowMapper);
    }
}

//BaseService.java
public interface BaseService{
     /**
     * 保存一个记录
     * @param baseBean
     */
    void save(BaseBean baseBean);

    /**
     * 获取所有bean记录
     * @return
     */
    List<BaseBean> findAll();
}

//BaseServiceImpl.java
@Component
public class BaseServiceImpl implements BaseService {

    @Autowired
    private BaseDao baseDao;

    @Override
    public void save(BaseBean baseBean) {
        this.baseDao.save(baseBean);
    }

    @Override
    public List<BaseBean> findAll() {
        return this.baseDao.findAll();
    }
}

④编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SystemConfig.class})
public class DataSourceTest {

    @Autowired
    private BaseService baseService;
    
    /**
     *调用service方法存入对象
    */
    @Test
    public void testSaveBean(){
        BaseBean baseBean = new BaseBean();
        baseBean.setName("test");
        baseBean.setAge(15);
        this.baseService.save(baseBean);
    }
    
    /**
     *调用service方法获取所有记录
    */
   @Test
    public void testFindAll(){
        List<BaseBean> list = this.baseService.findAll();
        System.out.println(list.toString());
    }
}

⑤创建数据库表

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for basebean
-- ----------------------------
DROP TABLE IF EXISTS `basebean`;
CREATE TABLE `basebean`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `age` int(10) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

SET FOREIGN_KEY_CHECKS = 1;

 

⑥测试结果

调用存入BaseBean，同时获取列表：

[BaseBean(id=1, name=test, age=15)]

• 使用xml配置实现

创建datasource.properties文件

#指定数据库驱动
jdbc.driver = com.mysql.jdbc.Driver

#指定数据库url
jdbc.url = jdbc:mysql://localhost:3306/spring

#指定数据库用户
jdbc.username = spring

#指定数据库用户密码
jdbc.password = spring

创建application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入数据库资源文件 -->
    <context:property-placeholder location="classpath:datasource.properties"/>
    <!--配置数据源-->
    <bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置注入数据源-->
    <bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>

    <bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
        <property name="baseDao" ref="baseDao"></property>
    </bean>
</beans>

关闭组件扫描，同时在全局配置中引入application.xml

@Configuration
//@Import(DataSourceConfig.class)
@ImportResource(value = {"classpath:application.xml"})
public class SystemConfig {}

测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15)]

C3P0连接池

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

依赖于ComboPooledDataSource 对象实现配置，其基本属性如下：

属性	描述
driverclass	数据库驱动类，比如MySQL为“com.mysql.jdbc.Driver”
jdbcUrl	数据库连接
user	登录数据库的账号
password	登录数据库的密码
acquireIncrement	当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3
minPoolSize	连接池中保留的最小连接数，默认为：3
maxPoolSize	连接池中保留的最大连接数。默认值: 15
initialPoolSize	初始化时获取连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3
maxIdleTime	最大空闲时间，多少秒内未使用则连接被丢弃。若为0则永不丢弃。默认值: 0
maxStatements	c3p0全局的PreparedStatements缓存的大小。如果maxStatements与maxStatementsPerConnection均为0，则缓存不生效，只要有一个不为0，则语句的缓存就能生效。如果默认值: 0
numHelperThreads	c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能通过多线程实现多个操作同时被执行。Default: 3
acquireRetryAttempts	定义在从数据库获取新连接失败后重复尝试的次数。默认值: 30 ；小于等于0表示无限次
acquireRetryDelay	重新尝试的时间间隔，默认为：1000毫秒
checkoutTimeout	获取一个connection超时时间，单位毫秒
idleConnectionTestPeriod	每隔多少秒检查所有连接池中的空闲连接。Default: 0
automaticTestTable	c3p0将建一张名为改配置项的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么属性preferredTestQuery将#被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试使用。默认值: null。由于运营平台的数据库用户没有创建表的权限，故需要发sql创建表。
testConnectionOnCheckin	如果设为true那么在取得连接的同时将校验连接的有效性。Default: false
unreturnedConnectionTimeout=15	一个checkout连接的超时设置，一旦一个checkout连接超时，他将物理的关闭，而不是返回池中，主要是防止连接被长期使用不释放，这个设置也是比较危险的

使用注解方式配置C3P0

①引入jar包：

<!--引入c3p0支持-->
<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${org.springframework.version}</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

②创建数据源配置类，定义数据源与JdbcTemplate操作模板

@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String userName;

    @Value("${jdbc.password}")
    private String password;
    
     /**
     * 数据源连接池
     */
    @Bean
    public DataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setJdbcUrl(url);
        comboPooledDataSource.setUser(userName);
        comboPooledDataSource.setPassword(password);
        return comboPooledDataSource;
    }
    
     /**
     * Spring JbdcTemplate
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

执行测试：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15)

使用XML配置C3P0

依旧使用application.xml，将数据源改为c3p0

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入数据库资源文件 -->
    <context:property-placeholder location="classpath:datasource.properties"/>
    <!--配置数据源DBCP-->
    <bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置数据源C3P0-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置注入数据源c3p0-->
    <bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
        <property name="dataSource" ref="dataSourceC3P0"></property>
    </bean>
    
    <bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>

    <bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
        <property name="baseDao" ref="baseDao"></property>
    </bean>
</beans>

将全局配置调整至读取xml模式，测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15)]

BoneCP连接池

一个快速，开源的数据库连接池。帮你管理数据连接让你的应用程序能更快速地访问数据库。比C3P0和DBCP快25倍

BoneCP依赖于com.jolbox.bonecp.BoneCPDataSource 类，其主要属性如下：

属性	描述
driveClass	数据库驱动
jdbcUrl	响应驱动的jdbcUrl
username	数据库的用户名
password	数据库的密码
acquireIncrement:	当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3
idleConnectionTestPeriod	捡查数据库连接池中控线连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0
idleMaxAge	连接池中未使用的链接最大存活时间，单位是分，默认值：60，如果要永远存活设置为0
maxConnectionsPerPartition	每个分区最大的连接数
minConnectionsPerPartition	每个分区最小的连接数
partitionCount	分区数，默认值2，最小1，推荐3-4，视应用而定
acquireIncrement	每次去拿数据库连接的时候一次性要拿几个，默认值：2
statementsCacheSize	缓存prepared statements的大小，默认值：0
releaseHelperThreads	每个分区释放链接助理进程的数量，默认值：3，除非你的一个数据库连接的时间内做了很多工作，不然过多的助理进程会影响你的性能

使用注解实现BoneCP配置

①引入依赖包

<!--引入BoneCP支持-->
<!-- https://mvnrepository.com/artifact/com.jolbox/bonecp -->
<dependency>
    <groupId>com.jolbox</groupId>
    <artifactId>bonecp</artifactId>
    <version>0.8.0.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${org.springframework.version}</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

②创建配置类：

@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String userName;

    @Value("${jdbc.password}")
    private String password;
    
     /**
     * 数据源连接池
     */
    @Bean
    public DataSource dataSource(){
        BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
        boneCPDataSource.setDriverClass(driver);
        boneCPDataSource.setJdbcUrl(url);
        boneCPDataSource.setUser(userName);
        boneCPDataSource.setPassword(password);
        return boneCPDataSource;
    }
    
     /**
     * Spring JbdcTemplate
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

③测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15)]

使用XML实现BoneCP配置

依旧使用application.xml，将数据源改为BoneCP

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入数据库资源文件 -->
    <context:property-placeholder location="classpath:datasource.properties"/>
    <!--配置数据源DBCP-->
    <bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置数据源C3P0-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
     <!--配置数据源BoneCP-->
    <bean class="com.jolbox.bonecp.BoneCPDataSource" id="dataSourceBoneCP">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置注入数据源BonCP-->
    <bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
        <property name="dataSource" ref="dataSourceBoneCP"></property>
    </bean>
    
    <bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>

    <bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
        <property name="baseDao" ref="baseDao"></property>
    </bean>
</beans>

测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15)]

 

Druid连接池

阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池

Druid依赖于com.alibaba.druid.pool.DruidDataSource 实现，其主要属性如下：

属性	描述
name	配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this)
driverClassName	这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
jdbcUrl	连接数据库的url，不同数据库不一样。例如：  mysql : jdbc:mysql://10.20.153.104:3306/druid2  oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username	连接数据库的用户名
password	连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
initialSize	初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive	最大连接池数量
maxIdle	已经不再使用，配置了也没效果
minIdle	最小连接池数量
maxWait	获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery	用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrow	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis	有两个含义：  1) Destroy线程会检测连接的间隔时间2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun	不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls	物理连接初始化的时候执行的sql
exceptionSorter	当数据库抛出一些不可恢复的异常时，抛弃连接
filters	属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：  监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters	类型是List<com.alibaba.druid.filter.Filter>，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

使用注解实现Druid配置

引入支持依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${org.springframework.version}</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

②创建配置类

@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String userName;

    @Value("${jdbc.password}")
    private String password;
    
     /**
     * 数据源连接池
     */
    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(userName);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
    
     /**
     * Spring JbdcTemplate
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15), BaseBean(id=7, name=test, age=15)]

使用XML实现Druid配置

使用application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入数据库资源文件 -->
    <context:property-placeholder location="classpath:datasource.properties"/>
    <!--配置数据源DBCP-->
    <bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置数据源C3P0-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
     <!--配置数据源BoneCP-->
    <bean class="com.jolbox.bonecp.BoneCPDataSource" id="dataSourceBoneCP">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置数据源Druid-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSourceDruid">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--配置注入数据源Druid-->
    <bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
        <property name="dataSource" ref="dataSourceDruid"></property>
    </bean>
    
    <bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>

    <bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
        <property name="baseDao" ref="baseDao"></property>
    </bean>
</beans>

测试结果：

[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15), BaseBean(id=7, name=test, age=15), BaseBean(id=8, name=test, age=15)]

四、Spring+数据库操作

如同往常我们想要实现一个简单的数据库操作，可能都会需要需要编写很多不必要的重复性代码，比如打开数据库，连接数据库，关闭数据库等，Spring JDBC使用JdbcTemplate封装重复操作

上述代码已经展示了简单的JdbcTemplate操作。实际上我们有几种可能的方式去使用JdbcTemplate带给我们的便利

Ⅰ、继承JdbcDaoSupport类

如同上述代码中所使用的例子：

@Component
public class BaseDaoParent extends JdbcDaoSupport {
    
    //注入DataSource
    @Autowired
    private DataSource dataSource;
    
    //因为JdbcDaoSupport的setDataSource方法是final修饰的，@Autowired注入失败，所以必须手动注入
    @PostConstruct
    private void initialize(){
        setDataSource(dataSource);
    }
}

@Repository
public class BaseDao extends BaseDaoParent{
    
    /**
     * 保存一个记录
     * @param baseBean
     */
    public void save(BaseBean baseBean){
        this.getJdbcTemplate().update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
    }
    
    /**
     * 获取所有bean记录
     * @return
     */
    public List<BaseBean> findAll(){
        RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
        return this.getJdbcTemplate().query("select * from basebean",rowMapper);
    }
}

可以看到这种方式的限制是DataSource的注入过于繁琐，所以一般不使用这种方式

Ⅱ、直接引用JdbcTemplate

实际上，上述代码中的this.getJdbcTemplate()得到的也是上下文中的JdbcTemplate对象，我们可以选择直接注入JdbcTemplate进行使用，效果一样：

@Repository
public class BaseDao{
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    
    /**
     * 保存一个记录
     * @param baseBean
     */
    public void save(BaseBean baseBean){
        this.jdbcTemplate.update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
    }
    
    /**
     * 获取所有bean记录
     * @return
     */
    public List<BaseBean> findAll(){
        RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
        return this.jdbcTemplate.query("select * from basebean",rowMapper);
    }
}

这种做法的限制是应用代码与Spring JdbcTemplate的耦合性增强

Ⅲ、使用JdbcOperations类

JdbcOperations 是一个接口，定义了 JdbcTemplate 所实现的操作。通过注入 JdbcOperations ，而不是具体的 JdbcTemplate ，能够保证dao 通过 JdbcOperations 接口达到与 JdbcTemplate 保持松耦合

@Repository
public class BaseDao{
    
    @Autowired
    private JdbcOperations jdbcOperations;
    
    /**
     * 保存一个记录
     * @param baseBean
     */
    public void save(BaseBean baseBean){
        this.jdbcOperations.update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
    }
    
    /**
     * 获取所有bean记录
     * @return
     */
    public List<BaseBean> findAll(){
        RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
        return this.jdbcOperations.query("select * from basebean",rowMapper);
    }
}

五、Spring与JdbcTemplate

实际上，JdbcTemplate所能做的远不止上述代码所展示。Spring中，有如下三种JdbcTemplate：

• JdbcTemplate ：最基本的 Spring JDBC 模板，这个模板支持简单的 JDBC 数据库访问功能以及基于索引参数的查询；
• NamedParameterJdbcTemplate ：使用该模板类执行查询时可以将值以命名参数的形式绑定到 SQL 中，而不是使用简单的索引参
• 数；
• SimpleJdbcTemplate ：该模板类利用 Java 5 的一些特性如自动装箱、泛型以及可变参数列表来简化 JDBC 模板的使用。

我们采用最合适的jdbcOperations来学习JdbcTemplate的功能

JdbcTemplate主要提供以下五类方法：

• execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
• update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
• query方法及queryForXXX方法：用于执行查询相关语句；
• call方法：用于执行存储过程、函数相关语句。

其中较为常用的有以下方法：

①<T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws DataAccessException

根据语句和传参查询某个记录并将结果封装成对象

private final static String FIND_BASE_BEAN = "select * from basebean where id=?";
public BaseBean findOne(Integer id){
    //目标对象映射
    RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
    //执行查询并返回目标对象
    return this.jdbcOperations.queryForObject(FIND_BASE_BEAN,rowMapper,id);
}

②int update(String sql, @Nullable Object... args) throws DataAccessException;

更新或插入数据

private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (?,?)";
public void save(BaseBean baseBean){
    this.jdbcOperations.update(INSERT_BASE_BEAN,baseBean.getName(),baseBean.getAge());
}

③int update(String sql, @Nullable PreparedStatementSetter pss) throws DataAccessException;

使用预编译设置更新或插入数据

private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (?,?)";
int count = this.jdbcOperations.update(INSERT_BASE_BEAN, new PreparedStatementSetter() {  
      @Override  
      public void setValues(PreparedStatement pstmt) throws SQLException {  
          pstmt.setObject(1, baseBean.getName());  
          pstmt.setObject(2, baseBean.getAge());
}}); 

使用命名参数Template实现功能，与使用简单的JdbcTemplate几乎完全相同：

@Bean
public NamedParameterJdbcTemplate jdbcTemplate(DataSource dataSource) {
    return new NamedParameterJdbcTemplate(dataSource);
}

通过NamedParameterJdbcTemplate执行插入

//此处留下命名参数占位
private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (:name,:age)";

public void save(BaseBean baseBean){
    //封装命名参数值
    Map<String,Object> paramMap=new HashMap();
    paramMap.put("name",baseBean.getName()));
    paramMap.put("age", baseBean.getAge());
    
    this.jdbcOperations.update(INSERT_BASE_BEAN,paramMap);
}

总结

数据是应用程序的血液。