引述
1.spring事务是基于AOP的编程理念设计的,更细致点说就是spring的事务是基于AOP环绕和异常通知来实现的。
2.Spring的事务是分为编程式事务(手动式,自己begin,commit和rollback)和声明式(自动式扫包注解)的事务。而声明式的事务其实就是在底层对于编程式的事务的封装。
注:AOP面向前面的编程思想,实际上就是提取各个业务逻辑中的公共模块,进行开发。避免了一些不必要的重复操作。如下图:
传统编程:
基于AOP编程思想:
同时AOP我们也必须明确几个概念:
关注点:
关注点,重复代码就叫做关注点;
切面:
关注点形成的类,就叫切面(类)!
面向切面编程,就是指 对很多功能都有的重复的代码抽取,再在运行的时候网业务方法上动态植入“切面类代码”。
切入点:
执行目标对象方法,动态植入切面代码。
可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。
AOP原理:
AOP实际上是通过代理模式实现的,代理模式又分为动态代理和静态代理,动态代理不需要生成目标代理对象。
动态代理分为cglib和jdk动态代理,cglib是通过asm字节码包装的一个类库,而jdk动态代理是基于反射的原理实现的。
SpringAOP的使用
1.拷贝依赖Jar包
<dependencies>
<!-- 引入Spring-AOP等相关Jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>3.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>3.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.1_2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
</dependencies>
2.须知注解:
<aop:aspectj-autoproxy></aop:aspectj-autoproxy> 开启事物注解权限
@Aspect 指定一个类为切面类
@Pointcut("execution(* com.itmayiedu.service.UserService.add(..))") 指定切入点表达式
@Before("pointCut_()") 前置通知: 目标方法之前执行
@After("pointCut_()") 后置通知:目标方法之后执行(始终执行)
@AfterReturning("pointCut_()") 返回后通知: 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
@Around("pointCut_()") 环绕通知: 环绕目标方法执行
3.切面类的编写:
@Component
@Aspect
public class AopLog {
// 前置通知
@Before("execution(* com.xx.service.UserService.add(..))")
public void begin() {
System.out.println("前置通知");
}
//
// 后置通知
@After("execution(* com.xx.service.UserService.add(..))")
public void commit() {
System.out.println("后置通知");
}
// 运行通知
@AfterReturning("execution(* com.xx.service.UserService.add(..))")
public void returning() {
System.out.println("运行通知");
}
// 异常通知
@AfterThrowing("execution(* com.xx.service.UserService.add(..))")
public void afterThrowing() {
System.out.println("异常通知");
}
// 环绕通知
@Around("execution(* com.xx.service.UserService.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
}
4.具体应用:
5.执行结果:
手写Spring事务-编程式事务
事务工具类
@Component
public class TransactionUtils {
//之所以我们能使用这个类实际上就是spring.xml配置了该bean
@Autowired
private DataSourceTransactionManager dataSourceTransactionManager;
// 开启事务
public TransactionStatus begin() {
TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
return transaction;
}
// 提交事务
public void commit(TransactionStatus transactionStatus) {
dataSourceTransactionManager.commit(transactionStatus);
}
// 回滚事务
public void rollback(TransactionStatus transactionStatus) {
dataSourceTransactionManager.rollback(transactionStatus);
}
}
spring.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:p="http://www.springframework.org/schema/p"
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">
<context:component-scan base-package="com.itmayiedu"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!-- 开启事物注解 -->
<!-- 1. 数据源对象: 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/test"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 2. JdbcTemplate工具类实例 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 3.配置事务 -->
<bean id="dataSourceTransactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
具体应用
@Service
public class UserService {
@Autowired
private UserDao userDao;
@Autowired
private TransactionUtils transactionUtils;
public void add() {
TransactionStatus transactionStatus = null;
try {
transactionStatus = transactionUtils.begin();
userDao.add("wangmazi", 27);
int i = 1 / 0;
System.out.println("我是add方法");
userDao.add("zhangsan", 16);
transactionUtils.commit(transactionStatus);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (transactionStatus != null) {
transactionStatus.rollbackToSavepoint(transactionStatus);
}
}
}
}
其实这样我们就能实现基本的编程式事务了,不过你会发现其实这样会特别麻烦,每个service都会需要去相应的代码。
解决方式:使用aop编程来解决上述问题。
//切面类 基于手手动事务封装
@Component
@Aspect
public class AopTransaction {
@Autowired
private TransactionUtils transactionUtils;
// TransactionUtils 不要实现为单例子: 如果为单例子的话可能会发生线程安全问题
// // 异常通知
@AfterThrowing("execution(* com.xx.service.UserService.add(..))")
public void afterThrowing() {
System.out.println("回滚事务");
// 获取当前事务 直接回滚,解决了transactionStatus无法传递给rollback的问题。
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
// 环绕通知 在方法之前和之后处理事情
@Around("execution(* com.xx.service.UserService.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
// 调用方法之前执行
System.out.println("开启事务");
TransactionStatus transactionStatus = transactionUtils.begin();
proceedingJoinPoint.proceed();// 代理调用方法 注意点: 如果调用方法抛出溢出不会执行后面代码
// 调用方法之后执行
System.out.println("提交事务");
transactionUtils.commit(transactionStatus);
}
}
这样我们就轻松实现了事务代码与原来代码的解耦!