第一节：

Spring提供了很多持久层技术的模板类简化编程

1.1 JDBC模板使用入门

• 创建项目引入jar包

  
  
• 创建数据库

CREATE DATABASE spring;
USE spring;
CREATE TABLE account(id int PRIMARY KEY auto_increment,
                name VARCHAR(20),
                money DOUBLE);
//修改数据库字符集
ALTER DATABASE spring CHARACTER SET utf8;
//修改表的字符集
ALTER TABLE account DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
//修改表中某个字段的字符集
ALTER TABLE account CHANGE name name VARCHAR(20) CHARACTER SET utf8 COLLATE utf8_general_ci;

• JDBC模板的简单使用

public class JdbcTest {

    @Test
    public void jdbc(){
        //创建连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://*.*.*.*:3306/spring?characterEncoding=utf-8");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        //创建JDBC模板
        JdbcTemplate template = new JdbcTemplate(dataSource);
        //执行插入操作
        template.update("insert into account value (null ,?,?)","周四",3000d);

        //执行更新操作
        template.update("update account set name = ? WHERE id = ?","周日",2);

        //执行删除操作
        template.update("delete FROM account WHERE id = ?",1);

        //执行查询操作
        Long aLong = template.queryForObject("SELECT COUNT(*) FROM account", Long.class);
        System.out.println(aLong);
    }
}

1.2 JDBC模板结合Spring的使用

• 在Spring配置文件中，通过属性注入的方式配置JdbcTemplate

<!--配置Spring的内置连接池-->
    <bean id="dataSorce" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--通过属性注入的方式，键入相关参数-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://*.*.*.*:3306/spring?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--配置JDBC模板-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--通过属性注入的方式，设置数据源-->
        <property name="dataSource" ref="dataSorce" />
    </bean>

• 对应测试类如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTest02 {

    @Resource(name = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Test
    /**
     * 添加数据
     */
    public void add(){
        jdbcTemplate.update("INSERT INTO account VALUE (null,?,?)","王者",10000d);
    }

    /**
     * 更新数据
     */
    @Test
    public void update(){
        jdbcTemplate.update("UPDATE account SET name = ? WHERE id = ? ","路飞",2);

    }

    /**
     * 数据查找
     */
    @Test
    public void find(){
        Long aLong = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM account", Long.class);
        System.out.println(aLong);
    }

    /**
     * 删除数据
     */
    @Test
    public void del(){
        jdbcTemplate.update("DELETE FROM account WHERE id = ?",2);
    }
}

1.3 DBCP以及C3p0的使用

• 通过Spirng配置文件，配置由DBCP生成的数据源(需引入对应的jar包)

  
  

<!--配置由DBCP生成的数据连接池-->
    <bean id="dateSourceDbcp" class="org.apache.commons.dbcp.BasicDataSource">
        <!--通过属性注入的方式，设置连接参数-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://*.*.*.*:3306/spring?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

• 通过Spirng配置文件，配置由C3p0生成的数据源连接池，引入对应jar包

  
  

<!--配置由C3p0生成的数据连接池-->
    <bean id="dateSourceC3p0" class="org.apache.commons.dbcp.BasicDataSource">
        <!--通过属性注入的方式，设置连接参数-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://*.*.*.*:3306/spring?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

1.4 关联参数由引入外部属性文件来配置

• 新建jdbc.properties 配置属性文件

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://*.*.*.*:3306/spring?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

• 在Spring的applicationContext.xml配置文件中引入属性文件

<!--引入外部配置的属性文件-->
    <!--方式一：-->
    <!--
        <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
          <property name="location" value="classpath:jdbc.properties"/>
        </bean>
        -->
    <!--方式二:通常使用该方法引入配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--通过外部属性来设置对应值-->
    <bean id="dateSourceC3p0" class="org.apache.commons.dbcp.BasicDataSource">
        <!--通过属性注入的方式，设置连接参数-->
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

第二节：Spring进行事务管理

2.1 PlatformTransactionManager：平台事务管理器

org.springframework.jdbc.datasource.DataSourceTransactionManager:使用Spring JDBC或iBatis进行持久化数据时使用。
org.springframework.orm.hibernate3.HibernateTransactionManager：使用Hibernate版本进行持久化数据时使用

2.2 TransactionDefinition:事务定义信息

• 隔离级别
• 传播行为
• 超时信息
• 是否只读

2.3 TransactionStatus:事务的状态

• 记录事务状态。

2.4 小结：

Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。

第三节：Spring事务的传播行为

Spring中提供了七种事务的传播行为：

• 保证多个操作在同一个事务中

PROPAGATION_REQUIRED：默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来

PROPAGATION_SUPPORTS：支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。

PROPAGATION_MANDATORY：如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。

• 保证多个操作不在同一个事务中

PROPAGATION_REQUIRES_NEW：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没有事务，创建一个新事务，包含自身操作。

PROPAGATION_NOT_SUPPORTED：如果A中有事务，将A的事务挂起。不使用事务管理。

PROPAGATION_NEVER：如果A中有事务，报异常。

• 嵌套式事务

PROPAGATION_NESTED：嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。

第四节：Spring事务管理实践

4.1 声明式事务（以xml方式实现）

• 定义基础类，实现测试环境的搭建

//Service
public interface AccountService {

    void transfer(String fromName,String toName,double money);

}

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void transfer(String fromName, String toName, double money) {
        accountDao.fromTransfer(fromName,money);
//模拟异常，测试事务的执行。
//        int i = 10/0;
        accountDao.toTransfer(toName,money);
    }
}

//DAO层
public interface AccountDao {
    
    void fromTransfer(String fromName,double money);
    void toTransfer(String toName,double money);

}
public class AccountDaoImpl implements AccountDao {


    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public void fromTransfer(String fromName, double money) {
        jdbcTemplate.update("UPDATE account SET money = money - ? WHERE name = ?"
                ,money,fromName);
    }

    @Override
    public void toTransfer(String toName, double money) {
        jdbcTemplate.update("UPDATE account set money = money + ? WHERE name = ?"
                ,money,toName);
    }
}

• Spring的applicationContext.xml配置文件中，实现对Service层以及Dao层的托管,并实现属性注入。

<bean id="accountService" class="com.seapp.spring.template.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <bean id="accountDao" class="com.seapp.spring.template.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

• AOP理论，实现事务增强

<!--声明式事务，以xml方式实现-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dateSourceC3p0"/>
    </bean>

    <!--配置事务的通知,配置增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--aop的配置-->
    <aop:config>
        <aop:pointcut expression="execution(* com.seapp.spring.template.impl.AccountServiceImpl.transfer(..))" id="pointcut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>

• 测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TemplateTest {


    @Resource(name = "accountService")
    private AccountService accountService;

    @Test
    public void demo01(){
        accountService.transfer("王者","乔巴",2000d);
    }
}

4.2 声明式事务（以注解方式实现：）

• applicationContext.xml对于注解式事务的配置

<!--声明式事务，以注解方式实现-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dateSourceC3p0"/>
    </bean>
    <!--开启事务管理注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

• 在需要开启事务的实现类上，添加注解

@Transactional//注解式事务所添加的注解
public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void transfer(String fromName, String toName, double money) {
        accountDao.fromTransfer(fromName,money);
//        int i = 10/0;
        accountDao.toTransfer(toName,money);
    }
}