AOP面向切面编程
面向切面编程AOP
概述
IoC使软件组件松耦合。AOP让你能够捕捉系统中经常使用的功能，把它转化成组件。
AOP（Aspect Oriented Programming）：面向切面编程，面向方面编程。（AOP是一种编程技术 , 是基于OOP基础之上新的编程思想）
Spring的AOP的底层使用的动态代理：JDK动态代理 + CGLIB动态代理技术 , Spring在这两种动态代理中灵活切换
- 如果是代理接口，会默认使用JDK动态代理
- 如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB
- 当然，你也可以强制通过一些配置让Spring只使用CGLIB
AOP思想
一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。这些系统服务被称为：交叉业务(非业务逻辑代码)
- 这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志、事务管理、安全，这些都是需要做的。
**如果在每一个业务处理过程当中，都掺杂这些交叉业务代码进去的话，存在两方面问题 ** , 使用AOP可以很轻松的解决以上问题
- 第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用。并且修改这些交叉业务代码的话，需要修改多处
- 第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务
AOP的思想
- 将与核心业务无关的代码独立的抽取出来，形成一个独立的组件，然后以横向交叉的方式应用到业务流程当中的过程被称为AOP
AOP的优点
- 第一：代码复用性增强。
- 第二：代码易维护。
- 第三：使开发者更关注业务逻辑。
AOP的七大术语
public class UserService{
public void do1(){
System.out.println("do 1");
}
public void do2(){
System.out.println("do 2");
}
public void do3(){
System.out.println("do 3");
}
public void do4(){
System.out.println("do 4");
}
public void do5(){
System.out.println("do 5");
}
// 核心业务方法
public void service(){
try{
//连接点 Joinpoint
do1();//切点 Pointcut
//连接点 Joinpoint
do2();//切点 Pointcut
//连接点 Joinpoint
do3();//切点 Pointcut
//连接点 Joinpoint
do5();//切点 Pointcut
//连接点 Joinpoint
}
catch(Exception e){
//连接点 Joinpoint
}finally{}
//连接点 Joinpoint
}
}
连接点 Joinpoint: 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。(连接点描述的是位置)
- 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。
- 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。
**切点 Pointcut: **在程序执行流程中，真正织入切面的方法。一个切点对应多个连接点 (切点本质就是方法)
通知 Advice: 通知又叫增强包括五种，就是具体你要织入的增强代码 , 例如事务代码 , 日志代码 , 安全代码。(通知描述的增强的代码 , 以方法的形式出现)
- 前置通知 : 增强代码放在在目标方法之前的连接点上的通知
- 后置通知：增强代码放在在目标方法之后的连接点上的通知
- 环绕通知：增强代码既放在目标方法前又放在目标方法后的连接点上的通知
- 异常通知：在目标方法抛出异常之后 , 放在catch语句块中的连接点的通知
- 最终通知: 放在finally语句块中的连接点的通知
切面 Aspect: 切点 + 通知就是切面。
**织入 Weaving:**把通知应用到目标对象上的过程。
代理对象 Proxy: 一个目标对象被织入通知后产生的新对象。
**目标对象 Target: **被织入通知的对象。
切点表达式
切点表达式用来定义通知（Advice）往哪些方法上切入。就是根据你指定的规则去匹配方法
切入点表达式语法格式：execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])
- 访问控制权限修饰符是可选项。没写表示4个权限都包括。写public就表示只包括公开的方法。
- 返回值类型是必填项。* 表示返回值类型任意。
- 全限定类名是可选项。没写表示所有的类。两个点“…”代表当前包以及子包下的所有类。com… 即表示当前包以及子包下的所有类
- 方法名是必填项。* 表示所有方法。set*表示所有的set方法。
- 形式参数列表是必填项 。() 表示没有参数的方法。(…) 参数类型和个数随意的方法。() 只有一个参数的方法。(, String) 第一个参数类型随意，第二个参数是String的。
- 异常是可选项。没写表示任意异常类型。
通配符
*
- 在全类名中的字符串中一个 * 可以匹配一个或者多个字符
- 在包的路径中一个 * 只能匹配一层路径
- 在形参列表和返回值类型中 , 一个 * 匹配任意一个参数类型
- 在访问修饰符中不能使用 * , 如果不写默认匹配的是public修饰符
…
- 在形参列表中匹配任意数量、任意类型的参数
- 在包所在的路径中能匹配任意多层路径
==“&&”、“||”、“!” ,==连接多个切入点表达式
- && 表示我们要切入的位置满足这两个切点表达式
- || 表示我们要切入的位置满足任意一个切点表达式即可
- ! 表示我们要切入的位置只要不是这个切点表达式都行
理解以下的切点表达式
//service包下所有的类中以delete开始的所有方法
execution(public * com.powernode.mall.service.*.delete*(..))
//mall包下所有的类的所有的方法
execution(* com.powernode.mall..*(..))
// 所有类的所有方法
execution(* *(..))
使用Spring的AOP
实现方式
Spring对AOP的实现包括以下3种方式
- 第一种方式(常用)：Spring框架结合AspectJ框架实现的AOP，基于注解方式。
- 第二种方式(常用)：Spring框架结合AspectJ框架实现的AOP，基于XML方式。
- 第三种方式(了解)：Spring框架自己实现的AOP，基于XML配置方式。
**AspectJ是Eclipse组织的一个支持AOP的框架。AspectJ框架是独立于Spring框架之外的一个框架，Spring框架用了AspectJ **
- AspectJ项目起源于帕洛阿尔托（Palo Alto）研究中心（缩写为PARC）。该中心由Xerox集团资助，Gregor Kiczales领导，从1997年开始致力于AspectJ的开发，1998年第一次发布给外部用户，2001年发布1.0 release。
- 为了推动AspectJ技术和社团的发展，PARC在2003年3月正式将AspectJ项目移交给了Eclipse组织，因为AspectJ的发展和受关注程度大大超出了PARC的预期，他们已经无力继续维持它的发展。
准备工作
使用Spring+AspectJ的AOP需要引入的依赖如下
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>6.0.0-M2version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aopartifactId>
<version>6.0.0-M2version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aspectsartifactId>
<version>6.0.0-M2version>
dependency>
Spring配置文件中添加context命名空间和aop命名空间
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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">
beans>
基于AspectJ的AOP注解式开发
第一步：定义目标类以及目标方法
- 没有写接口 , 底层一定会使用CGLIB的动态代理
// 目标类
public class OrderService {
// 目标方法
public void generate(){
System.out.println("订单已生成！");
}
}
第二步：定义切面类 ,(指定通知方法切入的位置)
- 使用@Aspect注解告诉Spring到底哪个是切面类
- 使用通知注解告诉Spring通知方法切入的位置1
// 切面类
@Aspect
public class MyAspect {
}
第三步：目标类和切面类都纳入spring bean管理
- 在目标类OrderService上添加**@Component**注解。
- 在切面类MyAspect类上添加**@Component**注解。
第四步：在spring配置文件中添加组建扫描
- 开启组件扫描模式: context 名称空间
- 开启基于注解的AOP模式 : AOP名称空间
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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.powernode.spring6.service"/>
beans>
第五步：在切面类中添加通知 , 并在通知上添加切点表达式
- 注解@Before表示前置通知
// 切面类
@Aspect
@Component
public class MyAspect {
// 切点表达式
@Before("execution(* com.powernode.spring6.service.OrderService.*(..))")
// 这就是需要增强的代码（通知）
public void advice(){
System.out.println("我是一个通知");
}
}
第六步：在spring配置文件中启用自动代理
- spring容器在扫描类的时候，查看该类上是否有@Aspect注解，如果有，则给这个类生成代理对象
- proxy-target-class=“true” 表示强制使用cglib动态代理。
- proxy-target-class=“false” 表示使用jdk动态代理。默认值是false。即使写成false，当没有接口的时候，也会自动选择cglib生成代理类。
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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.powernode.spring6.service"/>
<aop:aspectj-autoproxy proxy-target-class="true"/>
beans>
测试程序
public class AOPTest {
@Test
public void testAOP(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-aspectj-aop-annotation.xml");
OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
orderService.generate();
}
}
通知类型及其执行顺序
前置通知：@Before 目标方法执行之前的通知
后置通知：@AfterReturning 目标方法执行之后的通知
环绕通知：@Around 目标方法之前添加通知，同时目标方法执行之后添加通知 , 在中间需要执行目标方法。
- 执行目标方法时需要一个ProceedingJoinPoint 类型的参数连接点 , 调用连接点的 proceed() 来执行目标方法 , 这个连接点在Spring调用这个方法的时候会自动传过来
- 环绕通知(环绕是最大的通知，在前置通知之前，在后置通知之后。)
异常通知：@AfterThrowing 发生异常之后执行的通知
最终通知：@After 放在finally语句块中的通知
注意: 其他通知的连接点都是 JoinPoint 类型的 , 在Spring容器调用这个方法的时候自动传过来
// joinPoint.getSignature()表示获取目标方法的签名。通过方法的签名可以获取到一个方法的具体信息。
// 通过签名获取目标方法的方法名。
System.out.println("目标方法的方法名：" + joinPoint.getSignature().getName());
定义目标类及目标方法(没有抛出异常)
// 目标类
@Component
public class OrderService {
// 目标方法
public void generate(){
System.out.println("订单已生成！");
}
}
**定义切面类 **
// 切面类
@Component
@Aspect
public class MyAspect {
@Around("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
// 执行目标方法。
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
@Before("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void beforeAdvice(){
System.out.println("前置通知");
}
@AfterReturning("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterReturningAdvice(){
System.out.println("后置通知");
}
@AfterThrowing("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterThrowingAdvice(){
System.out.println("异常通知");
}
@After("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterAdvice(){
System.out.println("最终通知");
}
}
测试程序
public class AOPTest {
@Test
public void testAOP(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-aspectj-aop-annotation.xml");
OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
orderService.generate();
}
}
目标类的目标方法发生异常
- 当发生异常之后，最终通知也会执行，因为最终通知@After会出现在finally语句块中。出现异常之后，后置通知和环绕通知的结束部分不会执行。
// 目标类
@Component
public class OrderService {
// 目标方法
public void generate(){
System.out.println("订单已生成！");
if (1 == 1) {
throw new RuntimeException("模拟异常发生");
}
}
}
切面的先后顺序
我们知道，业务流程当中不一定只有一个切面，可能有的切面控制事务，有的记录日志，有的进行安全控制，如果多个切面的话，顺序如何控制
- 可以使用@Order注解来标识切面类，为@Order注解的value指定一个整数型的数字，数字越小，优先级越高
再定义一个切面类YourAspect , 并设置优先级
@Aspect
@Component
@Order(1) //设置优先级
public class YourAspect {
@Around("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("YourAspect环绕通知开始");
// 执行目标方法。
proceedingJoinPoint.proceed();
System.out.println("YourAspect环绕通知结束");
}
@Before("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void beforeAdvice(){
System.out.println("YourAspect前置通知");
}
@AfterReturning("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterReturningAdvice(){
System.out.println("YourAspect后置通知");
}
@AfterThrowing("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterThrowingAdvice(){
System.out.println("YourAspect异常通知");
}
@After("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterAdvice(){
System.out.println("YourAspect最终通知");
}
}
设置切面类MyAspect的优先级
// 切面类
@Component
@Aspect
@Order(2) //设置优先级
public class MyAspect {
@Around("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
// 执行目标方法。
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
@Before("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void beforeAdvice(){
System.out.println("前置通知");
}
@AfterReturning("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterReturningAdvice(){
System.out.println("后置通知");
}
@AfterThrowing("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterThrowingAdvice(){
System.out.println("异常通知");
}
@After("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void afterAdvice(){
System.out.println("最终通知");
}
}
YourAspect的优先级高
MyAspect的优先级高
抽取可重用的切点表达式
随便声明一个没有实现的返回void的空方法 , 方法名随意 , 方法体中也不需要写任何代码, 这个方法只是起到一个能够让@Pointcut注解编写的位置的作用
- 在其他通知方法使用方法名引入切点表达式 , , 切点表达式得到复用 , 实现改一处即改所有
注意: 在本类中可以直接使用通用切点表达式的方法名 , 如果跨类使用需要补全通用表达式前面的全限定类名
// 切面类
@Component
@Aspect
@Order(2)
public class MyAspect {
// 通用的切点表达式
@Pointcut("execution(* com.powernode.spring6.service.OrderService.*(..))")
public void pointcut(){}
@Around("pointcut()")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
// 执行目标方法。
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
@Before("pointcut()")
public void beforeAdvice(){
System.out.println("前置通知");
}
@AfterReturning("pointcut()")
public void afterReturningAdvice(){
System.out.println("后置通知");
}
@AfterThrowing("pointcut()")
public void afterThrowingAdvice(){
System.out.println("异常通知");
}
@After("pointcut()")
public void afterAdvice(){
System.out.println("最终通知");
}
}
AOP的实际案例
编程式事务处理
项目中的事务控制是在所难免的。在一个业务流程当中，可能需要多条DML语句共同完成，为了保证数据的安全，这多条DML语句要么同时成功，要么同时失败。这就需要添加事务控制的代码。
- 可以看到，这些业务类中的每一个业务方法都是需要控制事务的，而控制事务的代码又是固定的格式 这个控制事务的代码就是和业务逻辑没有关系的“交叉业务”。
- 交叉业务的代码没有得到复用，并且如果这些交叉业务代码需要修改，那必然需要修改多处，难维护，
class 业务类1{
public void 业务方法1(){
try{
// 开启事务
startTransaction();
// 执行核心业务逻辑
step1();
step2();
step3();
....
// 提交事务
commitTransaction();
}catch(Exception e){
// 回滚事务
rollbackTransaction();
}
}
public void 业务方法2(){
try{
// 开启事务
startTransaction();
// 执行核心业务逻辑
step1();
step2();
step3();
....
// 提交事务
commitTransaction();
}catch(Exception e){
// 回滚事务
rollbackTransaction();
}
}
}
class 业务类2{
public void 业务方法1(){
try{
// 开启事务
startTransaction();
// 执行核心业务逻辑
step1();
step2();
step3();
....
// 提交事务
commitTransaction();
}catch(Exception e){
// 回滚事务
rollbackTransaction();
}
}
}
//......
可以采用AOP思想解决。可以把以上控制事务的代码作为环绕通知，切入到目标类的方法当中 , 定义两个业务类
@Component
// 业务类
public class AccountService {
// 转账业务方法
public void transfer(){
System.out.println("正在进行银行账户转账");
}
// 取款业务方法
public void withdraw(){
System.out.println("正在进行取款操作");
}
}
@Component
// 业务类
public class OrderService {
// 生成订单
public void generate(){
System.out.println("正在生成订单");
}
// 取消订单
public void cancel(){
System.out.println("正在取消订单");
}
}
使用AOP来完成给以上两个业务类的4个方法添加事务控制代码到一个事务切面类中
- 这个事务控制代码是不是只需要写一次就行了，并且修改起来也没有成本
@Aspect
@Component
// 事务切面类
public class TransactionAspect {
@Around("execution(* com.powernode.spring6.biz..*(..))")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
try {
System.out.println("开启事务");
// 执行目标
proceedingJoinPoint.proceed();
System.out.println("提交事务");
} catch (Throwable e) {
System.out.println("回滚事务");
}
}
}
编写测试程序可以看到，所有的业务方法都添加了事务控制的代码。
public class AOPTest2 {
@Test
public void testTransaction(){
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);
OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
// 生成订单
orderService.generate();
// 取消订单
orderService.cancel();
// 转账
accountService.transfer();
// 取款
accountService.withdraw();
}
}
安全日志
项目开发结束了，已经上线了。运行正常。客户提出了新的需求：凡事在系统中进行修改操作的，删除操作的，新增操作的，都要把这个人记录下来。因为这几个操作是属于危险行为。
定义业务类和业务方法
@Service
//用户业务
public class UserService {
public void getUser(){
System.out.println("获取用户信息");
}
public void saveUser(){
System.out.println("保存用户");
}
public void deleteUser(){
System.out.println("删除用户");
}
public void modifyUser(){
System.out.println("修改用户");
}
}
// 商品业务类
@Service
public class ProductService {
public void getProduct(){
System.out.println("获取商品信息");
}
public void saveProduct(){
System.out.println("保存商品");
}
public void deleteProduct(){
System.out.println("删除商品");
}
public void modifyProduct(){
System.out.println("修改商品");
}
}
接下来我们使用AOP来解决上面的需求：编写一个负责安全的切面类
@Component
@Aspect
public class SecurityAspect {
// 抽取可重用的切点表达式
@Pointcut("execution(* com.powernode.spring6.biz..save*(..))")
public void savePointcut(){}
@Pointcut("execution(* com.powernode.spring6.biz..delete*(..))")
public void deletePointcut(){}
@Pointcut("execution(* com.powernode.spring6.biz..modify*(..))")
public void modifyPointcut(){}
@Before("savePointcut() || deletePointcut() || modifyPointcut()")
public void beforeAdivce(JoinPoint joinpoint){
System.out.println("XXX操作员正在操作"+joinpoint.getSignature().getName()+"方法");
}
}
@Test
public void testSecurity(){
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);
UserService userService = applicationContext.getBean("userService", UserService.class);
ProductService productService = applicationContext.getBean("productService", ProductService.class);
userService.getUser();
userService.saveUser();
userService.deleteUser();
userService.modifyUser();
productService.getProduct();
productService.saveProduct();
productService.deleteProduct();
productService.modifyProduct();
}
