《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);
}

总结

数据是应用程序的血液。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,530评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,403评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,120评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,770评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,758评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,649评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,021评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,675评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,931评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,751评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,410评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,004评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,969评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,042评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,493评论 2赞 343