AOP面向切面编程：主要是通过切面类来提高代码的复用，降低业务代码的耦合性，从而提高开发效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
AOP实现原理：aop是通过cglib的动态代理实现的。
jdk动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
cglib动态代理：将代理对象类的class文件加载进来，通过ASM字节码技术修改其字节码生成子类来处理。
区别：JDK动态代理只能对实现了接口的类生成代理，而不能针对类 。CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 。因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。
一：AOP运行过程
项目结构
1.1 导入相关包
<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> <!-- 数据库连接池 --> <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>
1.2 配置包扫描和切面代理
<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" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 扫描指定路径 --> <context:component-scan base-package="com.wulei"/> <!-- 开启切面代理 --> <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>
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(); //} } } =================== 【控制台输出】 此时查看数据库可以发现，触发异常通知回滚所以没有插入数据。 开启事务 插入成功 回滚当前事务
注意：在环绕通知中begin()开启了事务，如果程序出现了异常，环绕通知就不会commit()提交事务，若此时异常被try捕捉，异常通知又无法rollback()来回滚，若不手动回滚就会造成事务失效。