Spring第三天——AOP注解实现与事务管理

Z时代
2024-01-10
分类：综合

本文内容纲要：

- 一、AspectJ的基于注解的AOP操作 - 二、jdbcTemplate操作 - 三、spring配置连接池和dao使用jdbcTemplate - 四、spring的事务管理

　　大致内容：

　　　　aspectJ的aop操作（基于注解，对比day02配置操作）（会用）

　　　　*jdbcTemplate操作（实现CRUD）

　　　　*spring配置连接池

　　　　*spring事务管理

一、AspectJ的基于注解的AOP操作

　　　　（day02的配置回顾，略显麻烦，配置稍多）

　　　　建立项目记得导入day02操作aop的那些包（如果是复制项目一定要修改项目的context name）

　　　　再把配置文件拿过来

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> 
    <!-- 开启aop代理（开启aop操作） -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <!-- 配置创建对象 -->
    <bean id="book" class="cn.aop.Book"></bean>
    <bean id="buyBook" class="cn.aop.BuyBook"></bean>
</beans>

　　　　建立两个类：Book 和 BuyBook，这里我们使用的是配置文件中创建，这里第二次看spring觉得应该改为扫描包，然后加注解@Componet等注解来完成把类交给spring容器来管理（右上角的小s图标），开发更快，更方便！

　　依旧使用配置文件创建对象，开启aop操作

　　　　在增强的类上使用注解实现增强的操作

　　　　在增强的类上使用注解完成aop操作

　　　　在类上加@Aspect

　　　　在方法上加真正的注解

　　@Before 前置通知

　　@AfterReturning 后置通知

　　@Around 环绕通知

　　@AfterThrowing 抛出通知

　　@After 最终通知

　　value属性值为原来的表达式的值

　　(表达式写法需要注意)

　　其它项目不用时请将其关闭！

package cn.aop;
public class Book {
    public void buy(){
        System.out.println("Book.buy");
    }
}
package cn.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class BuyBook {
    //方法上使用注解完成真正的增强操作
    @Before(value="execution(* cn.aop.Book.*(..))")
    public void before1(){
        System.out.println("BuyBook.before");
    }
}

**　　//任何拥有@AspectJ的注解不能**被spring自动检测发现，需要配合@Component注解配合使用（或者使用xml的bean的配置方式）

**　　**//定义切入点见day02

**　　【更新】：（例如拿到原方法的参数：通过JoinPoint）**

package com.atguigu.spring.aop;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
 * AOP 的 helloWorld
 * 1. 加入 jar 包
 * com.springsource.net.sf.cglib-2.2.0.jar
 * com.springsource.org.aopalliance-1.0.0.jar
 * com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
 * spring-aspects-4.0.0.RELEASE.jar
 * 
 * 2. 在 Spring 的配置文件中加入 aop 的命名空间。 
 * 
 * 3. 基于注解的方式来使用 AOP
 * 3.1 在配置文件中配置自动扫描的包: <context:component-scan base-package="com.atguigu.spring.aop"></context:component-scan>
 * 3.2 加入使 AspjectJ 注解起作用的配置: <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 * 为匹配的类自动生成动态代理对象. 
 * 
 * 4. 编写切面类: 
 * 4.1 一个一般的 Java 类
 * 4.2 在其中添加要额外实现的功能. 
 *
 * 5. 配置切面
 * 5.1 切面必须是 IOC 中的 bean: 实际添加了 @Component 注解
 * 5.2 声明是一个切面: 添加 @Aspect
 * 5.3 声明通知: 即额外加入功能对应的方法. 
 * 5.3.1 前置通知: @Before("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(int, int))")
 * @Before 表示在目标方法执行之前执行 @Before 标记的方法的方法体. 
 * @Before 里面的是切入点表达式: 
 * 
 * 6. 在通知中访问连接细节: 可以在通知方法中添加 JoinPoint 类型的参数, 从中可以访问到方法的签名和方法的参数. 
 * 
 * 7. @After 表示后置通知: 在方法执行之后执行的代码. 
 */
//通过添加 @Aspect 注解声明一个 bean 是一个切面!
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object [] args = joinPoint.getArgs();
        System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
    }
    @After("execution(* com.atguigu.spring.aop.*.*(..))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends");
    }
}

二、jdbcTemplate操作

　　spring是一站式的框架，对应javaEE三层框架都有不同的解决方案，jdbcTemplate就是对应于DAO层的

　　spring对不同的持久化层技术都作了不同的支持

　　JDBC === jdbcTemplate

　　Hibernate === HibernateTemplate （少写很多的操作）

　　MyBatis JPA等都有不同的支持

　　jdbcTemplate使用(CRUD操作)和DBUtils比较类似（但是并没有DBUtils方便，只是jdbc模板是spring封装好的）

　**　这里可以参见博友的博客：http://www.cnblogs.com/caoyc/p/5630622.html**

**　　　　像这里批量操作，适用于SQL语句相同，而参数不同（注意参数）**

　　具体的使用：

　　　　准备工作：

　　　　　　导包：spring-jdbc spring-tx(事务)

　　　　说到数据库，当然少不了最最最基本驱动jar包

　　添加：

　　　　依赖连接池获得连接，创建对象，设置数据库信息

　　　　创建jdbcTemplate对象，设置数据源

　　建表

　　　　使用jdbcTemplate实现操作（和DBUtils是非常像的）

　　　　增加修改在类中，删除不再赘述，只是SQL语句的差异

　　　　当然，具体的信息可以通过log4j看到，log4j的介绍在另外的博文中作介绍

package cn.jdbc;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JDBCDemo01 {
    @Test
    public void add(){
        //创建对象，设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        //本机时可以写成jdbc:mysql:///mydb
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        //创建jdbcTemplate对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        //使用jdbcTemplate实现操作(已经建表)
        String sql = "insert into user values(?,?)";
        //注意使用的方法,dbutils调的也是update方法，参数是SQL和可变参数
        int i = jdbcTemplate.update(sql, "lulu","123");
        System.out.println(i);
    }
    //测试模板的修改方法，这是SQL语句的方法
    @Test
    public void update(){
        //创建对象，设置数据库信息
                DriverManagerDataSource dataSource = new DriverManagerDataSource();
                dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                //本机时可以写成jdbc:mysql:///mydb
                dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
                dataSource.setUsername("root");
                dataSource.setPassword("root");
                //创建jdbcTemplate对象，设置数据源
                JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
                String sql = "update user set username=? where username=?";
                int i = jdbcTemplate.update(sql, "lucy","lulu");
                System.out.println(i);
    }
}

　　***查询：查询是重点

　　　　（QueryRunner runner = new QueryRunner(dataSource);

　　　　runner.query(sql,new BeanHandler(User.class));

　　　　具体的ResultSetHandler可参考DBUtils部分）

　　　　使用jdbcTemplate实现查询时，有接口RowMapper,**但没有像dbutils一样提供实现类

　　　　需要自己提供实现类（学习这个的目的不是为了更加方便，而是一般的，如果允许，尽量使用少的技术）

　　　　回顾JDBC底层实现查询结果，将结果集封装到对象中

　　查询的具体实现：

　　　　1.返回某一个值

　　　　　　queryForObject(sql, requiredType) 返回类型，如Integer.class(统计记录数)

　　　　2.返回一个对象

　　　　　　jdbcTemplate.queryForObject(sql, rowMapper, args)

　　　　　　第二个是结果集的处理，第三个是可变参数

　　　　　　第二个接口可以写匿名内部类，当然也可以单独写个类（更直观）

　　　　RowMapper实现类

　　　　　　class MyRowMapper implements RowMapper{

　　　　　　public User mapRow(ResultSet arg0, int arg1) throws SQLException {

　　　　第二个 int arg1 表示行号（结果集的行号）

　　　　　　return null;

　　　**　3.返回一个集合**

　　　　　　jdbcTemplate.query(sql, rowMapper, args)

　　　　　　第三个是可变参数(当然有可省略的重载方法)，返回的是集合

　　　　　　数据封装也要自己写**（不支持级联属性，毕竟是作为一个小工具，而不是框架）**

　给出一个Demo如下(注意最后给出的实现类)：

package cn.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JDBCDemo02 {
    //演示查询返回某个值
    @Test
    public void count(){
                //创建对象，设置数据库信息
                DriverManagerDataSource dataSource = new DriverManagerDataSource();
                dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                //本机时可以写成jdbc:mysql:///mydb
                dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
                dataSource.setUsername("root");
                dataSource.setPassword("root");
                //创建jdbcTemplate对象，设置数据源
                JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
                String sql = "SELECT COUNT(*) FROM user";
                Integer i = jdbcTemplate.queryForObject(sql, Integer.class);
                System.out.println(i);
    }
    //演示返回对象
    @Test
    public void obj(){
        //创建对象，设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        //本机时可以写成jdbc:mysql:///mydb
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        //创建jdbcTemplate对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "select * from user where username=?";
        //和dbutils类似，也是new一个处理器，不过这里需要自己实现
        User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "mary");
        System.out.println(user);
    }
    //返回对象集合
    @Test
    public void objlist(){
        //创建对象，设置数据库信息
                DriverManagerDataSource dataSource = new DriverManagerDataSource();
                dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                //本机时可以写成jdbc:mysql:///mydb
                dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
                dataSource.setUsername("root");
                dataSource.setPassword("root");
                //创建jdbcTemplate对象，设置数据源
                JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
                String sql = "select * from user";
                List<User> list = jdbcTemplate.query(sql, new MyRowMapper());
                for (User user : list) {
                    System.out.println(user.getUsername());
                }
    }
}
//属性封装需要自己实现
class MyRowMapper implements RowMapper<User>{
    public User mapRow(ResultSet rs, int num) throws SQLException {
        String username = rs.getString("username");//使用索引更高效
        String password = rs.getString("password");
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        return user;
    }   
}

三、spring配置连接池和dao使用jdbcTemplate

　　导包：

　　　　c3p0的两个jar包 c3p0 和依赖包 mchange

　　　　在配置连接池（原始方式见数据库连接池部分）

　　　　ComboPooledDataSource这个类本身里面就有属性和相关的set()方法

　　　　可以使用之前学的属性注入！属性注入注入的属性就是参考set()方法命名规范

bean1.xml配置文件：

　　可以创建service dao 进行稍微正式的测试，顺便复习属性注入

　　给JdbcTemplate需要传入dataSource ,需要注意注意这个

　　service注入dao

　　dao注入jdbcTemplate

　　jdbcTemplate注入dataSource

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> 
    <!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 进行属性注入 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!-- 在配置中配置依赖注入 -->
    <bean id="userService" class="cn.c3p0.UserService">
        <!-- service中注入dao -->
        <property name="dao" ref="dao"></property>
    </bean>
    <bean id="dao" class="cn.c3p0.UserDao">
        <!-- dao中注入jdbcTemplate -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!-- 创建模板对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 给模板注入dataSource，具体可以看源码了解（set()方法等） -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

//常用的RowMapper，列映射器，有默认实现类 BeanPropertiesRowMapper

UserDao:【更新】：这里可以使用@Autowired进行注入（底层是byType）（可以用在属性，用在set方法，用在构造器）

　　extends jdbcDaoSupport 不推荐（不能使用注解）

package cn.c3p0;
import org.springframework.jdbc.core.JdbcTemplate;
public class UserDao {
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    public void add() {
        //在这里使用jdbcTemplate new模板对象的过程都交给spring
        String sql = "insert into user values(?,?)";
        int i = jdbcTemplate.update(sql, "lilei","112");
        System.out.println(i);
    }
}

UserService:

package cn.c3p0;
public class UserService {
    private UserDao dao;
    public void setDao(UserDao dao) {
        this.dao = dao;
    }
    public void add(){
        System.out.println("service.add");
        dao.add();
    }
}

//可以使用JDBC的具名参数（好处是可读性强了，但带来了代码量）（需要配置相关的bean）

public class JDBCTest {
    private ApplicationContext ctx = null;
    private JdbcTemplate jdbcTemplate;
    private EmployeeDao employeeDao;
    private DepartmentDao departmentDao;
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
        employeeDao = ctx.getBean(EmployeeDao.class);
        departmentDao = ctx.getBean(DepartmentDao.class);
        namedParameterJdbcTemplate = ctx.getBean(NamedParameterJdbcTemplate.class);
    }
    /**
     * 使用具名参数时, 可以使用 update(String sql, SqlParameterSource paramSource) 方法进行更新操作
     * 1. SQL 语句中的参数名和类的属性一致!
     * 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 实现类作为参数. 
     */
    @Test
    public void testNamedParameterJdbcTemplate2(){
        String sql = "INSERT INTO employees(last_name, email, dept_id) "
                + "VALUES(:lastName,:email,:dpetId)";
        Employee employee = new Employee();
        employee.setLastName("XYZ");
        employee.setEmail("xyz@sina.com");
        employee.setDpetId(3);
        SqlParameterSource paramSource = new BeanPropertySqlParameterSource(employee);
        namedParameterJdbcTemplate.update(sql, paramSource);
    }

View Code

四、spring的事务管理

　　（不用像之前Hibernate一样写大堆的事务的代码）

　　　　事务的回顾见JDBC部分

　　　　事务的概念

　　　　事务的特性

　　　　事务的隔离性产生的问题

　　spring的事务管理主要有两种方式：（前面的AOP的原理）

　　　　1.编程式事务管理（自己写代码，用的少）

　　　**　2.声明式事务管理**（配置文件实现，注解方式实现(简单易用)）

　**　相关的API：**

　　　　PlatformTransactionManager :spring的事务管理器接口，为不同的持久化框架提供了不同的实现类

　　　　　　　　　　　　　　　　　　　　例如模板的实现类：dataSourceTransactionManager

　　　　Hibernate的实现类：HibernateTransactionManager

　　无论注解还是配置文件都要配置事务管理器

　　搭建转账的环境演示事务管理的操作：

　　建表，添加一些数据

　　创建service和dao以及注入关系的完成（区分业务层和持久层的区别，业务层只处理业务，持久层只和数据库打交道）

Service:

package cn.acount;
import org.springframework.transaction.annotation.Transactional;
@Transactional
public class AcountService {
    private AcountDao dao;
    public void setDao(AcountDao dao) {
        this.dao = dao;
    }
    //service调dao的方法完成逻辑
    public void acountMoney(){
        dao.decrese();
        //int i = 1/0;
        dao.increse();
    }
}

Dao:

package cn.acount;
import org.springframework.jdbc.core.JdbcTemplate;
public class AcountDao {
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    //减少钱的方法
    public void decrese(){
        String sql = "update acount set money=money+? where name=?";
        jdbcTemplate.update(sql, -1000,"小王");
    }
    //增加钱的方法
    public void increse(){
        String sql = "update acount set money=money+? where name=?";
        jdbcTemplate.update(sql, 1000,"小李");
    }
}

bean2.xml 要引入事务的操作的约束！

一般以后引入四个约束 beans context aop tx 示例见bean2.xml

可以测试无事务操作时可以正确执行

声明式的事务管理：

**　　xml实现：**

（使用的是aop的思想）（jdbc的源码查看dataSourceTransactionManager）

声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。——引自网友博客。

bean2.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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.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">
    <!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 进行属性注入 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!-- 配置service对象 -->
    <bean id="acountService" class="cn.acount.AcountService">
        <!-- service中注入dao -->
        <property name="dao" ref="dao"></property>
    </bean>
    <!-- 配置dao对象 -->
    <bean id="dao" class="cn.acount.AcountDao">
        <!-- dao中注入模板 -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!-- 创建模板对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 模板中注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 事务的配置实现 -->
    <!-- 1.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 2.配置事务增强 ，需要指定事务管理器-->
    <tx:advice id="txadvice" transaction-manager="transactionManager">
        <!-- 做事务操作 -->
        <tx:attributes>
            <!-- 设置进行事务操作的方法匹配规则 -->
            <tx:method name="acount*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 3.配置切面 -->
    <aop:config>
        <!-- 3.1切入点 -->
        <aop:pointcut expression="execution(* cn.acount.AcountService.*(...))" id="pointcut1"/>
        <!-- 3.2切面 -->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/>
    </aop:config>
</beans>

**　　**进行一个简单的测试：

package cn.acount;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test01 {
    @Test
    public void test(){
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean2.xml");
        AcountService service = (AcountService) context.getBean("acountService");
        service.acountMoney();
    }
}

**　　注解实现：**

　　配置事务管理器**（事务管理器本身也是一个bean），它管的是数据源（需要注入数据源）**

　　配置开启注解的操作**（启动事务注解）**

　　在要使用事务的方法所在的类上添加注解@Transactional（类上，方法上）

　　如果不在service上加@Transactional注解，将会报transactional只为可读的500错误！

　　会自动找到@注解后对类里的所有方法进行事务操作（自定义的异常只要搞构造器就可以了！）

此时的配置文件如下：

bean4.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:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.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"> 
    <!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 进行属性注入 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!-- 配置事务管理器-->
    <!-- 1.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 开启事务的注解 ，指定事务管理器-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 配置service对象 -->
    <bean id="acountService" class="cn.acount.AcountService">
        <!-- service中注入dao -->
        <property name="dao" ref="dao"></property>
    </bean>
    <!-- 配置dao对象 -->
    <bean id="dao" class="cn.acount.AcountDao">
        <!-- dao中注入模板 -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!-- 创建模板对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 模板中注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

在类上加注解：完整的类信息见xml配置实现

@Transactional
public class AcountService {

　　使用注解形式开发时，可以使用注解的形式：

//添加事务注解
    //1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
    //如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
    //REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起. 
    //2.使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED
    //3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的
    //属性进行设置. 通常情况下去默认值即可. 
    //4.使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据, 
    //这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true
    //5.使用 timeout 指定强制回滚之前事务可以占用的时间.  
//    @Transactional(propagation=Propagation.REQUIRES_NEW,
//            isolation=Isolation.READ_COMMITTED,
//            noRollbackFor={UserAccountException.class})
    @Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED,
            readOnly=false,
            timeout=3)
    @Override
    public void purchase(String username, String isbn) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {}
        //1. 获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2. 更新数的库存
        bookShopDao.updateBookStock(isbn);
        //3. 更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}