手写spring事务框架, 揭秘AOP实现原理。

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

AOP面向切面编程：主要是通过切面类来提高代码的复用，降低业务代码的耦合性，从而提高开发效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

AOP实现原理：aop是通过cglib的动态代理实现的。

jdk动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

cglib动态代理：将代理对象类的class文件加载进来，通过ASM字节码技术修改其字节码生成子类来处理。

区别：JDK动态代理只能对实现了接口的类生成代理，而不能针对类。CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。

一：AOP运行过程

项目结构

1.1 导入相关包

<dependencies>

<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>

<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>
</dependencies>

1.2 配置包扫描和切面代理

1.3 编写AOP切面

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Component//注入到spring
@Aspect//申明切面类
public class AopLog { // aop 编程里面有几个通知：前置通知后置通知运行通知异常通知环绕通知
@Before("execution(* com.wulei.service.UserService.add(..))")
public void before() {
System.out.println("前置通知: 在方法之前执行...");
} // 后置通知在方法运行后执行
@After("execution(* com.wulei.service.UserService.add(..))")
public void after() {
System.out.println("后置通知: 在方法之后执行...");
} // 运行通知
@AfterReturning("execution(* com.wulei.service.UserService.add(..))")
public void returning() {
System.out.println("运行通知:");
} // 异常通知
@AfterThrowing("execution(* com.wulei.service.UserService.add(..))")
public void afterThrowing() {
System.out.println("异常通知: 异常抛出执行");// 异常被try()cacth{}捕捉到则不执行。
} // 环绕通知在方法之前和之后处理事情
@Around("execution(* com.wulei.service.UserService.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
// 调用方法之前执行
System.out.println("环绕通知: 调用方法之前执行");
proceedingJoinPoint.proceed();
/* 代理调用方法 , 如果调用方法抛出异常就不会执行后面代码。
*
* 在使用spring事务的时候 service最好不要try, 将异常抛出给aop 异常通知处理回滚!
* 否则业务逻辑出错,而aop却正常执行,就会造成事务失效的情况。
*/ // 调用方法之后执行
System.out.println("环绕通知: 调用方法之后执行");
}
}

1.4 编写Service

@Service
public class UserService {
public void add() {
System.out.println("正在添加数据");
int i = 1/0;
// 如果出现异常就会触发AOP异常通知,如果异常被try()catch{}住,则会不触发异常通知继续走完环绕通知。
}
}

1.5 测试

public class Main {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.add();
}
}

=================
【控制台输出】
前置通知: 在方法之前执行...
Exception in thread "main" 环绕通知: 调用方法之前执行
正在添加数据
后置通知: 在方法之后执行...
异常通知: 异常抛出执行
java.lang.ArithmeticException: / by zero
at com.wulei.service.UserService.add(UserService.java:16)

二：手写编程式事务

2.1 在spring.xml配置好自己的数据源。
2.2 编写dao层

/*
CREATE TABLE `t_users` (
`name` varchar(20) NOT NULL,
`age` int(5) DEFAULT NULL,
PRIMARY KEY (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
*/
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate; public int add(String name, Integer age) {
String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";
int result = jdbcTemplate.update(sql, name, age);
System.out.println("插入成功");
return result;
}
}

2.3 手写编程式事务具体逻辑

@Component
public class MyTransaction { // 获取数据源
@Autowired
private DataSourceTransactionManager dataSourceTransactionManager; // 开启事务
public TransactionStatus begin() {
// getTransaction()这里的参数是用的事务默认的传播属性
TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
System.out.println("开启事务");
// 得到事务状态
return transaction;
} // 提交事务
public void commit(TransactionStatus transaction) {
dataSourceTransactionManager.commit(transaction);
System.out.println("提交事务");
} // 回滚事务
public void rollback(TransactionStatus transaction) {
dataSourceTransactionManager.rollback(transaction);
System.out.println("事务回滚");
}
}

2.4 编写service，然后运行测试。

@Service
public class UserService { @Autowired
private UserDao userDao;
@Autowired
private MyTransaction myTransaction; public void add() {
TransactionStatus transactionStatus = null;
try {
//1. 开启事务
transactionStatus = myTransaction.begin();
userDao.add("test001", 20);
int i = 1 / 0;
userDao.add("test002", 21);
//2. 执行成功就提交事务
myTransaction.commit(transactionStatus);
} catch (Exception e) {
//3. 出现异常就回滚
myTransaction.rollback(transactionStatus);
}
}
}

========================
【控制台输出】此时查看数据库可以发现，由于我们手动回滚所以没有插入数据。
前置通知: 在方法之前执行...
环绕通知: 调用方法之前执行
开启事务
插入成功
事务回滚
后置通知: 在方法之后执行...
环绕通知: 调用方法之后执行
运行通知:

三：AOP重构编程式事务

3.1 通过aop实现spring事务

@Component
@Aspect
// 基于AOP的环绕通知和异常通知实现Spring事务
public class AopTransaction { @Autowired
private MyTransaction myTransaction; // 环绕通知在方法之前和之后处理事情
@Around("execution(* com.wulei.service.UserService.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { // 开启事务调用方法之前执行
TransactionStatus transactionStatus = myTransaction.begin();
proceedingJoinPoint.proceed();// 代理调用方法注意点：如果调用方法抛出溢出不会执行后面代码
// 提交事务调用方法之后执行
myTransaction.commit(transactionStatus);
}
// 异常通知
@AfterThrowing("execution(* com.wulei.service.UserService.add(..))")
public void afterThrowing() {
System.out.println("回滚当前事务");
// 获取当前事务直接回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
}

3.2 编写service, 然后运行测试

@Service
public class UserService { @Autowired
private UserDao userDao; public void add() { userDao.add("test001", 20);
int i = 1 / 0;
userDao.add("test002", 21);//try {
// userDao.add("test001", 20);
// int i = 1 / 0;
// userDao.add("test002", 21);
//} catch (Exception e) {
// // 回滚当前事务。
// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//}
}
}
===================
【控制台输出】此时查看数据库可以发现，触发异常通知回滚所以没有插入数据。
开启事务
插入成功
回滚当前事务