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

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

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

详细文章请移步：CSDN-《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：数据库连接密码

首先引入依赖包：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：登录数据库的密码

使用注解方式配置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：数据库的密码

使用注解实现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。

使用注解实现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);
}

总结

数据是应用程序的血液。

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

一、Spring 的数据访问哲学

①松耦合

②Spring 数据访问异常

二、Spring 数据访问模板化

三、Spring+JDBC

Ⅰ、配置数据源

四、Spring+数据库操作

Ⅰ、继承JdbcDaoSupport类

Ⅱ、直接引用JdbcTemplate

Ⅲ、使用JdbcOperations类

五、Spring与JdbcTemplate

总结

AI模型 Llama 3体验笔记

【面试准备】又一次失败的面试经历，题目离谱～资深软件测试工程师

dotnet 8 版本与银河麒麟V10和UOS系统的 glibc 兼容性

SpringCloud上手實戰一、初始搭建SpringCloud項目環境

SpringCloud上手實戰-前言-微服務架構簡析

記一次關於待辦任務的鏈接設計需求設計思路總結

記一次activiti監聽器無法實例化的錯誤解決過程(SpringBoot Listener)

記一次關於待辦任務的鏈接設計

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結