Spring框架的JDBC模板技术

一、JDBC模板技术

（一）什么是模板技术

Spring框架中提供了很多持久层的模板类来简化编程，使用模板类编写程序会变的简单，Spring框架提供的JdbcTemplate类，Connection 表示连接，管理事务 Statement ResultSet.

（二）模板的使用

①创建maven工程，引入坐标

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
  </dependencies>

②编写测试代码（用new对象的方式）

public class Demo1 {

@Test
public void run1(){
    // 创建连接池对象，Spring框架内置了连接池对象
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    // 设置4个参数
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///数据库");
    dataSource.setUsername("用户名");
    dataSource.setPassword("密码");
    
    // 提供模板，创建对象
    JdbcTemplate template = new JdbcTemplate(dataSource);
    // 完成数据的增删改查
    template.update("insert into account values (null,?,?)","熊大",1000);
}}

（三）使用Spring框架来管理模板类

①Spring管理内置连接池

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd">

        <!--配置连接池-->
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
                <!--设置4个值-->
                <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///spring_db"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
        </bean>
        <!--配置模板类-->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <property name="dataSource" ref="dataSource"/>
        </bean>
</beans>

②编写测试方法

@RunWith(SpringJUnit4ClassRunner.class)//单元测试
@ContextConfiguration("classpath:applicationContext5.xml")//加载配置文件
public class demo5 {
	//按类型自动导入
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void run1(){
        //提供数据的增删改查
        jdbcTemplate.update("insert into account values (null,?,?)","雄二",9989);
    }
}

（四）Spring框架管理开源的连接池

①导入Druid开源连接池
②将数据库连接的信息配置到属性文件（jdbc.properties）中
③核心配置改为

		<!--使用提供标签的方式-->
        <context:property-placeholder location="classpath:jdbc.properties"/>

        <!--加载属性文件-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <property name="driverClassName" value="${jdbc.driverClassName}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />

        </bean>

        <!--配置模板类-->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <property name="dataSource" ref="dataSource"/>
        </bean>

（五）Spring框架的JDBC模板的简单操作（增，删，改，查）

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_jdbc.xml")
public class Demo1_1 {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 测试的方式  增
     */
    @Test
    public void run1(){
        jdbcTemplate.update("insert into account values (null,?,?)","熊四",800);
    }
    /**
     * 修改
     */
    @Test
    public void run2(){
        jdbcTemplate.update("update account set name = ?,money = ? where id = ?","光头强",100,7);
    }
    /**
     * 删除
     */
    @Test
    public void run3(){
        jdbcTemplate.update("delete from account where id = ?",7);
    }
    /**
     * 通过id查询
     */
    @Test
    public void run4(){
        Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new BeanMapper(), 6);
        System.out.println(account);
    }
    /**
     * 查询所有的数据
     */
    @Test
    public void run5(){
        List<Account> list = jdbcTemplate.query("select * from account", new BeanMapper());
        for (Account account : list) {
            System.out.println(account);
        }
    }
}
/**
 * 实现类，用来进行数据封装的
 */
class BeanMapper implements RowMapper<Account>{
    /**
     * 是一行一行进行数据封装的
     */
    @Override
    public Account mapRow(ResultSet resultSet, int i) throws SQLException {
        Account account = new Account();
        account.setId(resultSet.getInt("id"));
        account.setName(resultSet.getString("name"));
        account.setMoney(resultSet.getDouble("money"));
        return account;
    }
}

二、模拟转账开发（练习）

首先搭建环境（maven工程坐标）

（一）service代码的编写

接口：
public interface AccountService {
    public void pay(String out,String in,double money);
}
实现类：
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
	//转账方法
    @Override
    public void pay(String out, String in, double money) {
        // 调用dao方法
        accountDao.outMoney(out,money);
        accountDao.inMoney(in,money);
    }
}

（二）dao代码的编写

接口：
public interface AccountDao {
	//付款
    public void outMoney(String out,double money);
   	//收款
    public void inMoney(String in,double money);
}
实现类：
public class AccountDaoImpl implements AccountDao {
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 	//付款
    public void outMoney(String out, double money) {
        jdbcTemplate.update("update account set money = money - ? where name = ?",money,out);
    }
    //收款
    public void inMoney(String in, double money) {
        jdbcTemplate.update("update account set money = money + ? where name = ?",money,in);
    }
}

dao代码的编写的第二种方式

继承JdbcDaoSupport

（三）配置文件代码编写

约束同上

<!--第二种写法：使用提供标签的方式-->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--加载属性的文件-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!--配置Jdbc模板类-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!--配置service-->
    <bean id="accountService" class="cn.tx.demo2.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
     </bean>

    <!--配置dao-->
    <bean id="accountDao" class="cn.tx.demo2.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>

（四）测试代码编写

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:配置文件")
public class Demo2 {
	//按照类型自动导入
    @Autowired
    private AccountService accountService;
    /**
     * 测试转账的方法
     */
    @Test
    public void testPay(){
        accountService.pay("熊大","熊二",100);
    }
}

三、Spring框架声明式事务管理

PlatformTransactionManager接口
平台事务管理器。该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类！
接口方法如下：
void commit(TransactionStatus status)
void rollback(TransactionStatus status)
如果使用的Spring的JDBC模板或者MyBatis框架，需要选择DataSourceTransactionManager实现类

（一）配置文件的方式

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

<!--配置事务的通知（没有自己编写切面类，通知方法也不是自己编写，Spring框架提供的）-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--对pay进行增强，设置隔离级别，传播行为，超时的时间-->
        <tx:method name="pay" isolation="DEFAULT" propagation="REQUIRED" />
        <tx:method name="find*" read-only="true" />
    </tx:attributes>
</tx:advice>

<!--配置AOP的增强-->
<aop:config>
    <!--Spring框架提供系统通知，使用advisor标签-->
    <aop:advisor advice-ref="txAdvice" pointcut="execution(public * cn.tx.demo4.AccountServiceImpl.pay(..))" />
</aop:config>

（二）配置文件+注解的方式

①配置文件留下，配置平台事务管理器的配置
②将service进行注入并@Transactional(isolation = Isolation.DEFAULT)

（三）纯注解的方式

纯注解的目的就是替换所有的配置文件，但需要编写配置类

	/**
     * 配置类
     * @author Administrator
     */
    @Configuration  //声明配置类
    @ComponentScan(basePackages="cn.tx.demo6")  //扫描
    @EnableTransactionManagement        // 开启事务注解
    public class SpringConfig {
      
        @Bean(name="dataSource")
        public DataSource createDataSource() throws Exception{
            // 创建连接池对象，Spring框架内置了连接池对象
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            // 设置4个参数
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql:///spring_db");
            dataSource.setUsername("root");
            dataSource.setPassword("root");
            return dataSource;
        }
        /**
         * 创建模板对象
         * @return
         */
        @Resource(name="dataSource")        // 不仅可以作用在属性上，也可以作用方法上。
        @Bean(name="jdbcTemplate")          // 把JdbcTemplate保存到IOC容器中
        public JdbcTemplate createJdbcTemplate(DataSource dataSource){
            JdbcTemplate template = new JdbcTemplate(dataSource);
            return template;
        }
        /**
         * 创建平台事务管理器对象
         * @param dataSource
         * @return
         */
        @Resource(name="dataSource")
        @Bean(name="transactionManager")
        public PlatformTransactionManager createTransactionManager(DataSource dataSource){
            DataSourceTransactionManager manager = new DataSourceTransactionManager(dataSource);
            return manager;
        }     
    }

Spring框架重要知识点总结（四）