首页 > 资讯 > 后端开发 > Python >Spring中的AOP操作你了解吗

329

分享到

Spring中的AOP操作你了解吗

2024-04-02 19:04:59 329人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录一、aop操作术语 1. 连接点2. 切入点3. 通知（增强）4. 切面二、AOP操作2.1 切入点表达式2.2 AOP操作（AspectJ 注解方式）2.3 相同切入

一、AOP操作术语

1. 连接点

类里面哪些方法可以被增强，这些可以被增强的方法就称为连接点。

2. 切入点

实际被真正增强的方法，称为切入点。

3. 通知（增强）

（1）实际增强的逻辑部分称为通知（增强）

（2）通知有如下多种类型，如下：

前置通知
后置通知
环绕通知
异常通知
最终通知(finally)

4. 切面

切面是一个动作，指的是将通知应用到切入点的过程，就叫做切面。

二、AOP操作

spring 框架一般都是基于 AspectJ 实现 AOP 操作。AspectJ 不是 Spring 组成部分，而是独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作。

基于AspectJ实现AOP操作有如下两种方式：

基于 xml 配置文件实现
基于注解方式实现（使用）

2.1 切入点表达式

切入点表达式作用：知道对哪个类里面的哪个方法进行增强，语法结构如下所示：

execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

如下图所示：

编写切点示例如下：

1. 如对com.wyf.spring5.Book类中的add进行增强，则切入点表达式如下：

execution(* com.wyf.spring5.Book.add(..))

2. 如对com.wyf.spring5.Book类中所有的方法增强：

execution(* com.wyf.spring5.Book.*(..))

3. 如对 com.wyf.spring5包中的所有类，类中的所有方法都进行加强

execution(* com.wyf.spring5.*.* (..))

2.2 AOP操作（AspectJ 注解方式）

1) 首先我们创建一个类，并添加一个方法：

public class User {    public void add(){        System.out.println("add*****");    }}
public class User {
    public void add(){
        System.out.println("add*****");
    }
}

2）接着我们创建增强类（编写增强逻辑）

在增强类中创建方法，让不同的方法代表不同的通知类型


public class UserProxy {
    
    public void before(){
        System.out.println("before*****");
    }
}

3）进行通知的配置

在spring配置文件中，开启注解扫描。（采用java配置类或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: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.wyf.aopanno"></context:component-scan>    <!-- 开启Aspect 生成代理对象 -->    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>    </beans><?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: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.wyf.aopanno"></context:component-scan>
    <!-- 开启Aspect 生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

使用注解创建User和UserProxy对象(类上面添加创建对象注解，此处为 @Component)
在增强类上面添加注解@Aspect


@Component
public class User {
    public void add(){
        System.out.println("add*****");
    }
}

@Component
@Aspect  //生成代理对象
public class UserProxy {
    
    public void before(){
        System.out.println("before*****");
    }
}

在 spring 配置文件中开启生成代理对象

    <!-- 开启Aspect 生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

开启Aspect生成代理对象，相当扫描带有@Aspect注解的类，并生成该对象的一个代理对象。

4）配置不同类型通知

在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置。


@Component
@Aspect  //生成代理对象
public class UserProxy {
    
    //@Before注解表示其作为前置通知
    //切入点表达式指定该通知为哪个类的哪个方法进行增强。
    @Before(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void before(){
        System.out.println("before*****");
    }
}

测试代码如下：

    @Test
    public void TestAop(){
        //1. 加载spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("beanAop1.xml");
        //得到对象
        User user = context.getBean("user",User.class);
        user.add();
    }

执行结果：

前文只给出了前置通知@Before的代码，下面给出所有5种通知的示例代码，对上例的所有通知情况进行补全。


@Component
@Aspect  //生成代理对象
public class UserProxy {
    
    //@Before注解表示其作为前置通知
    //切入点表达式指定该通知为哪个类的哪个方法进行增强。
    @Before(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void before(){
        System.out.println("before*****");
    }
    
    @AfterReturning(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning*****");
    }
    
    @After(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void after(){
        System.out.println("after*****");
    }
    
    @AfterThrowing(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void afterthrowing(){
        System.out.println("afterthrowing*****");
    }
    
    @Around(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前*****");
        //执行被增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后*****");
    }

代码执行结果如下：

其中，after是在被增强方法之后执行，而afterreturning是在方法返回值之后执行。

2.3 相同切入点的抽取

在上例种，我们编写了被增强方放的5种通知，分别为前置通知、后置通知、异常通知、最终通知以及环绕通知。我们在编写增强类时，在通知注解中通过切入点表达式，指明了通知要对哪个类的哪个方法进行增强。但是，我们会发现，我们对同一方法进行增强时，其切入点表达式是相同的，为了避免重复，我们可以相同切入点进行抽取。

下例中，我们将相同切入点用@Pointcut进行了抽取，代码如下所示：

    //对相同切入点进行抽取
    @Pointcut(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void pointdemo(){
    }

当我们在其他地方要用该切入点表达式时，直接用其方法名称就可以。

如下所示：

@Component
@Aspect
@Order(2)
public class PersonProxy {
    //前置通知
    @Before(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void before(){
        System.out.println("Person Before****");
    }
}

2.4 多个增强类对同一个方法进行增强，设置增强类优先级

假如我们现在又有一个增强类，其中也包含一个before()方法，也对被增强类User的add()方法进行前置增强。那么我们如何设置其增强的顺序呢？

我们通过在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高，来保证增强的顺寻，代码如下：

@Component
@Aspect
@Order(2)
public class PersonProxy {
    //前置通知
    @Before(value = "execution(* com.wyf.aopanno.User.add(..))")
    public void before(){
        System.out.println("Person Before****");
    }
}