Spring 框架的 AOP

这孩子叫逆

已于 2024-10-29 16:31:07 修改

阅读量674

点赞数 15

分类专栏： Spring 文章标签： java 开发语言

于 2024-10-29 16:29:57 首次发布

本文链接：https://blog.youkuaiyun.com/zhzjn/article/details/143333323

版权

Spring 专栏收录该内容

9 篇文章

订阅专栏

Spring AOP是什么？

Spring 框架的 AOP

Aspect Oriented Programming：面向切面编程

什么时候会出现面向切面编程的需求？按照软件重构的思想，如果多个类中出现重复的代码，就应该考虑定义一个共同的抽象类，将这些共同的代码提取到抽象类中，比如Teacher,Student都有username，那么就可以把username及相关的get、set方法抽取到SysUser中，这种情况，我们称为纵向抽取。但是如果，我们的情况是以下情况，又该怎么办？给所有的类方法添加性能检测，事务控制，该怎么抽取？ PerformanceMonitor TransactionManager AOP就是希望将这些分散在各个业务逻辑代码中的相同代码，通过横向切割的方式抽取到一个独立的模块中，让业务逻辑类依然保存最初的单纯。

主要功能

日志记录，性能统计，安全控制，事务处理，异常处理等等。

AOP术语

连接点（Joinpoint)	程序执行的某个特定位置，如某个方法调用前，调用后，方法抛出异常后，这些代码中的特定点称为连接点。简单来说，就是在哪加入你的逻辑增强
切点（PointCut）	每个程序的连接点有多个，如何定位到某个感兴趣的连接点，就需要通过切点来定位。切点用于来限定Spring-AOP启动的范围，通常我们采用表达式的方式来设置，所以关键词是范围
增强（Advice）	增强是织入到目标类连接点上的一段程序代码。在Spring中，像BeforeAdvice等还带有方位信息。通知(或业务增强)是直译过来的结果，对照代码就是拦截器定义的相关方法，通知分为如下几种：前置通知(before):在执行业务代码前做些操作，以在方法中传入JoinPoint对象，用来获得切点信息后置通知(after):在执行业务代码后做些操作，无论是否发生异常，它都会执行异常通知（afterThrowing）:在执行业务代码后出现异常，需要做的操作，比如回滚事务返回通知(afterReturning),在执行业务代码后无异常，会执行的操作环绕通知(around)，在建议方法调用之前和之后，执行通知。
目标对象（Target）	需要被加强的业务对象
织入（Weaving）	织入就是将增强添加到对目标类具体连接点上的过程。
代理类（Proxy）	一个类被AOP织入增强后，就产生了一个代理类。
切面（Aspect）	切面由切点和增 zx强组成，它既包括了横切逻辑的定义，也包括了连接点的定义，SpringAOP就是将切面所定义的横切逻辑织入到切面所制定的连接点中。

基于 XML配置

1、引入maven

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
     <version>1.9.9.1</version>
</dependency>

2、引入 aop 命名空间标签

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/util
        http://www.springframework.org/schema/util/spring-util.xsd"></beans>

3、声明一个切面

<aop:config>
    <aop:aspect id="myAspect" ref="adviceBean">
        ...
    </aop:aspect>
</aop:config>
<bean id="adviceBean" class="...">   <!--adviceBean 既增强  包含要加入到目标类的代码 (可以有多个方法)-->
    ...
</bean>

4、声明一个切入点

<aop:config>
    <aop:aspect id="myAspect" ref="adviceBean">
        <aop:pointcut id="businessService"
                      expression="execution(* com.beiyou.service.*.*(..))"/>
        ...
    </aop:aspect>
</aop:config>
<bean id="adviceBean" class="...">
    ...
</bean>

4.1、切入点表达式

//表达式格式
execution(modifiers? ret-type?  name(param) throws?)
以上所有部分除了ret-type和name以及paramter之外都是可选的returning类型决定了匹配的方法必须要有指定的返回类型,可以使用*表示任意返回类型
只有当方法返回指定类型时,完全限定的类名才会被匹配,name匹配方法名,可以使用*匹配全部或部分方法名
parameters匹配就复杂一下：() 匹配一个无形参的方法,(..)匹配任意数量的形参方法(0~n),(*)匹配带一个任意类型的形参方法
(*,String)匹配带两个形参,第一个任意类型,第二个必须是String类型

实例：
execution(public * *(..)):任意public方法
execution(* set*(..)):方法名以set开头的任意方法
execution(* com.xyz.service.AccountService.*(..))：AccountService 接口下的任意方法 
execution(* com.beiyou.service.*.*(..))：service包下的任意类任意方法
重点：：execution(* com.xyz.service..*.*(..))：service包或子包下的任意类任意方法
execution(public void MyClass.myMethod(String)) :MyClass 类的myMethod方法,方法public访问权限,void返回值,形参只有一个并为String

execution(void MyClass.myMethod(..)):MyClass 类的myMethod方法,任意访问权限,返回值void,任意形参
execution(* MyClass.myMethod(..)):MyClass 类的myMethod方法,任意返回值,任意形参
execution(* MyClass.myMethod*(..)):MyClass 类的以myMethod开头的方法,任意返回值,任意形参
execution(* MyClass.myMethod*(String,..)):MyClass 类的以myMethod开头的方法,任意返回值,第一个形参类型是String
execution(* *.myMethod(..)):任意类下myMethod方法 execution(MyClass.new()):任意MyClass类的无参构造器
execution(MyClass.new(..)):任意MyClass类的任意有参构造器 execution(MyClass+.new(..)):任意MyClass或其子类构造器
execution(public * com.mycompany..*.*(..)):com.mycompany包下任意子包的所有类的所有public 方法

//Spring AOP只能切方法(也就是任意连接点中的方法),AspectJ可以切任意成员(任意连接点,包括类/对象初始化块,field,方法,构造器)
within(com.xyz.service.*)：service包下任意连接点
within(com.xyz.service..*)：service包或子包下任意连接点
this(com.xyz.service.AccountService)：AccountService接口的代理实现里的任意连接点

target(com.xyz.service.AccountService):目标对象实现了AccountService接口的任意连接点

args(java.io.Serializable)：只有一个参数且参数在运行时是Serializable类型的任意连接点
@target(org.springframework.transaction.annotation.Transactional)：目标对象有一个@Transactional注解任意连接点
@within(org.springframework.transaction.annotation.Transactional)：目标对象的声明类型有一个@Transactional注解任意连接点
@annotation(org.springframework.transaction.annotation.Transactional)：执行方法有一个@Transactional注解的任意连接点
@args(com.xyz.security.Classified)：只有一个参数且参数在运行时参数有@Classified注解的任意连接点
bean(tradeService)：Spring bean 名称是tradeService的任意连接点
bean(*Service)：Spring bean的名称以Service结尾的任意连接点
//表达式可以使用|| && !进行组合  在XML下就是 or and not
execution(* com.xyz.myapp.service..(..)) and this(service)//xml

execution(* com.xyz.myapp.service..(..)) && this(service)//java

5、声明通知

<aop:config>
    <aop:aspect id="myAspect" ref="adviceBean">
        <aop:pointcut id="businessService"
                      expression="execution(* com.by.service.*.*(..))"/>
        <aop:before method="目标方法" pointcut-ref="businessService"/>
        <aop:after method="目标方法" pointcut-ref="businessService"/>
        <aop:after-returning method="目标方法" pointcut-ref="businessService" returning="retVal"/>
        <aop:after-throwing method="目标方法" pointcut-ref="businessService" throwing="ex"/>
        <aop:around method="目标方法" pointcut-ref="businessService"/>
        ...
    </aop:aspect>
</aop:config>
<bean id="adviceBean" class="...">
    ...
</bean>

6、完整代码：

 public static void main( String[] args )
    {
  
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        OrderService bean = context.getBean(OrderService.class);
        bean.test();

    }

<?xml version="1.0" encoding="UTF-8"?>

<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        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">
  
    <aop:config>
        <aop:aspect id="myAspect" ref="logCut">
            <aop:pointcut id="pointcut1"  expression="execution(* com.beiyou.service.*.*(..))"/>
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <aop:after method="after" pointcut-ref="pointcut1"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut1" returning="retVal"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut1" throwing="ex"/>
            <aop:around method="around" pointcut-ref="pointcut1"/>

        </aop:aspect>
    </aop:config>
    <bean id="logCut" class="com.beiyou.LogCut">

    </bean>

    <bean id="orderService" class="com.beiyou.service.OrderService">

    </bean>
</beans>

public class OrderService {

    public  String  test(){

        return "我是orderservice发回值";
    }
}

package com.beiyou;

import org.aspectj.lang.ProceedingJoinPoint;

public class LogCut {

    // 前置通知
    public void before() {
        System.out.println("前置");
    }
    // 后置通知 始终会执行
    public void after() {
        System.out.println("后置");
    }
    // 环绕通知
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        Object result = pjp.proceed();
        System.out.println("环绕后");
        return result;
    }
    // 后置 正常返回
    public void afterReturning(Object retVal) {
        System.out.println("After returning 后置");
        
    }
    // 发生异常
    public void afterThrowing(Exception ex) {
        System.out.println("发生异常了");
       
    }
}

  public static void main( String[] args )
    {
      
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        OrderService bean = context.getBean(OrderService.class);
        bean.test();

    }

基于注解 @AspectJ

1、启用@AsjectJ支持

1.1、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:util="http://www.springframework.org/schema/util"
       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-4.3.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd
       http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-4.3.xsd"
>
 <!--下面可以不用，通过注解注册也行-->
    <!--下面配置与注解@EnableAspectJAutoProxy 二选一-->
    <aop:aspectj-autoproxy/>    
    <bean id="logCut" class="com.beiyou.LogCut">
    </bean>
    <bean id="orderService" class="com.beiyou.service.OrderService">
    </bean>
</beans>

1.2 注解启用

@Aspect
public class LogCut {

    // 定义切入点
    @Pointcut("execution(* com.beiyou.service.*.*(..))")
    public void point() {}
    // 前置通知
    @Before("point()")
    public void before() {
        System.out.println("前置");
    }
    // 后置通知 始终会执行
    @After("point()")
    public void after() {
        System.out.println("后置");
    }
    // 环绕通知
    @Around("point()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        Object result = pjp.proceed();
        System.out.println("环绕后");
        return result;
    }
    // 后置 发生异常时不会执行
    @AfterReturning(pointcut="point()",returning="retVal")
    public void afterReturning(Object retVal) {
        System.out.println("返回值是："+retVal);
        System.out.println("After returning 后置");
    }
    // 发生异常
    @AfterThrowing(pointcut="point()",throwing="ex")
    public void afterThrowing(Exception ex) {
        System.out.println("发生异常了");
    }
}

1.3 完整示例

 public static void main( String[] args )
    {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
       // ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        OrderService bean = context.getBean(OrderService.class);
        bean.test();
      
    }

@ComponentScan
@EnableAspectJAutoProxy
public class Config {
    
}

@Aspect
@Component
public class LogCut {

    // 定义切入点
    @Pointcut("execution(* com.beiyou.service..*.*(..))")
    public void point() {}
    // 前置通知
    @Before("point()")
    public void before() {
        System.out.println("前置");
    }
    // 后置通知 始终会执行
    @After("point()")
    public void after() {
        System.out.println("后置");
    }
    // 环绕通知
    @Around("point()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        Object result = pjp.proceed();
        System.out.println("环绕后");
        return result;
    }
    // 后置 发生异常时不会执行
    @AfterReturning(pointcut="point()",returning="retVal")
    public void afterReturning(Object retVal) {
        System.out.println("返回值是："+retVal);
        System.out.println("After returning 后置");
    }
    // 发生异常
    @AfterThrowing(pointcut="point()",throwing="ex")
    public void afterThrowing(Exception ex) {
        System.out.println("发生异常了");
    }
}

@Component
public class OrderService {

    public  String  test(){
        return "我是orderservice返回值";
    }
}

💡

定义增强类 (相当于切面，包含切点和增强)

增强类上增加注解：

@Aspect 说明该类是一个切面

等同于<aop:aspect id="log" ref="logAspect"></aop:aspect>

@Component 将增强类注入到ioc容器中

@EnableAspectJAutoProxy 启用注解支持

等同于 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>