Spring基于AspectJ实现AOP操作

超、凢脫俗 2023-01-08 02:30 214阅读 0赞

### 基于AspectJ实现AOP操作 ###

*  准备工作
 *   *  在项目工程里面引入 AOP 相关依赖。
     *  如果是maven项目，使用pom.xml代替引入jar包的过程（注意）
     *  学会使用切入点表达式
     *  AOP 操作（AspectJ 注解）
     *   *  1、创建类，在类里面定义方法
         *  2、创建增强类（编写增强逻辑），在增强类里面，创建方法，让不同方法代表不同通知类型
         *  3、进行通知的配置
         *  4、配置不同类型的通知
     *  相同的切入点抽取
     *  有多个增强类多同一个方法进行增强，设置增强类优先级
     *  完全使用注解开发
     *  代码结构
     *  测试代码

> **Spring 框架一般都是基于 AspectJ 实现 AOP 操作。**  
> **需要注意的是：AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作。**

> **基于 AspectJ 实现 AOP 操作有两种方式：  
> （1）基于 xml 配置文件实现  
> （2）基于注解方式实现（普遍使用）**

# 准备工作 #

## 在项目工程里面引入 AOP 相关依赖。 ##

**需要以下这些依赖：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]

## 如果是maven项目，使用pom.xml代替引入jar包的过程（注意） ##

**pom.xml：**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.Keafmd</groupId>
        <artifactId>day04_eesy_01jdbctemplate</artifactId>
        <version>1.0-SNAPSHOT</version>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>7</source>
                        <target>7</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
        <packaging>jar</packaging>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.6.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.46</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.9</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    
    
    </project>

## 学会使用切入点表达式 ##

**切入点表达式作用（通俗的讲）：知道对哪个类里面的哪个方法进行增强。**  
**语法结构： execution(\[权限修饰符\] \[返回类型\] \[类全路径\] \[方法名称\] (\[参数列表\]) )**

> **例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强  
> execution( \* com.atguigu.dao.BookDao.add(…))**

> **例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强  
> execution( \* com.atguigu.dao.BookDao. \* (…))**

> **例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强  
> execution( \* com.atguigu.dao. \* . \* (…))**

## AOP 操作（AspectJ 注解） ##

### 1、创建类，在类里面定义方法 ###

**User类：**

package com.Keafmd.spring5.aopanno;
    
    import org.springframework.stereotype.Component;
    
    /** * Keafmd * * @ClassName: User * @Description: 基于注解 被增强的类 * @author: 牛哄哄的柯南 * @date: 2021-01-18 13:54 */
    @Component
    public class User { 
    
        public void add(){ 
    // int i = 10/0;
            System.out.println("add....");
        }
    
    }

### 2、创建增强类（编写增强逻辑），在增强类里面，创建方法，让不同方法代表不同通知类型 ###

**UserProxy 类：**

package com.Keafmd.spring5.aopanno;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /** * Keafmd * * @ClassName: UserPtoxy * @Description: 增强类 * @author: 牛哄哄的柯南 * @date: 2021-01-18 13:56 */
    @Component
    @Aspect //生成代理对象
    @Order(3)
    public class UserProxy { 
    
    
        //相同的切入点抽取
        @Pointcut(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void pointdemo(){ 
    
        }
    
        //前置通知
        //@Before注解就表示前置通知
        @Before(value = "pointdemo()")
        public void beafor(){ 
            System.out.println("before...");
        }
    
        //最终通知
        @After(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void after(){ 
            System.out.println("after...");
        }
    
        //后置通知（返回通知）
        @AfterReturning(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void afterReturning(){ 
            System.out.println("afterReturning...");
        }
    
        //异常执行
        @AfterThrowing(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void afterThrowing(){ 
            System.out.println("afterThrowing...");
        }
    
        //环绕通知
        @Around(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
            System.out.println("around-before...");
    
            //被增强的方法执行
            proceedingJoinPoint.proceed();
    
            System.out.println("around-after...");
        }
    
    
    
    }

### 3、进行通知的配置 ###

> **（1）在 spring 配置文件中，开启注解扫描  
> （2）使用注解创建 User 和 UserProxy 对象  
> （3）在增强类上面添加注解 @Aspect  
> （4）在 spring 配置文件中开启生成代理对象**

**bean2.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.Keafmd.spring5.aopanno"></context:component-scan>
    
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    
    </beans>

### 4、配置不同类型的通知 ###

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

**UserProxy 类：**

## 相同的切入点抽取 ##

> **写个方法然后调用这样就可以把相同接入点抽取出来了。**

//相同的切入点抽取
        @Pointcut(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void pointdemo(){ 
    
        }
    
        //前置通知
        //@Before注解就表示前置通知
        @Before(value = "pointdemo()")
        public void beafor(){ 
            System.out.println("before...");
        }

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

> **在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高。**

@Component
    @Aspect //生成代理对象
    @Order(3)
    public class UserProxy {

**PersonProxy类：**

package com.Keafmd.spring5.aopanno;
    
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /** * Keafmd * * @ClassName: PersonProxy * @Description: 第二个增强类 * @author: 牛哄哄的柯南 * @date: 2021-01-18 14:39 */
    @Component
    @Aspect
    @Order(1) //越小优先级越高
    public class PersonProxy { 
    
        //前置通知
        //@Before注解就表示前置通知
        @Before(value = "execution(* com.Keafmd.spring5.aopanno.User.add(..))")
        public void beafor(){ 
            System.out.println("Person before...");
        }
    
    }

> **通过@Order设置后PersonProxy 的前置通知就会比UserProxy 的前置通知先执行。**

## 完全使用注解开发 ##

> **创建配置类，这样就不需要使用 xml 配置文件了。**

**ConfigAop类：**

package com.Keafmd.spring5.config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    /** * Keafmd * * @ClassName: ConfigAop * @Description: 配置类，完全注解，替代bean2.xml * @author: 牛哄哄的柯南 * @date: 2021-01-18 15:12 */
    @Configuration
    @ComponentScan(basePackages = { "com.Keafmd"})  //开启注解扫描
    @EnableAspectJAutoProxy(proxyTargetClass = true)  //开启AspectJ生成代理对象
    public class ConfigAop { 
    }

## 代码结构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]

## 测试代码 ##

**测试代码TestAop：**

package com.Keafmd.spring5.test;
    
    import com.Keafmd.spring5.aopanno.User;
    import com.Keafmd.spring5.config.ConfigAop;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /** * Keafmd * * @ClassName: TestAop * @Description: * @author: 牛哄哄的柯南 * @date: 2021-01-18 14:15 */
    public class TestAop { 
    
        @Test
        public void testAOPnno(){ 
            ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
            User user = context.getBean("user",User.class);
            user.add();
        }
    
        //完全注解
        @Test
        public void testAOPnno2(){ 
            ApplicationContext context = new AnnotationConfigApplicationContext(ConfigAop.class);
            User user = context.getBean("user",User.class);
            user.add();
        }
    }

**输出结果：**

Person before...
    around-before...
    before...
    add....
    around-after...
    after...
    afterReturning...
    
    Process finished with exit code 0

> **testAOPnno和testAOPnno2的结果是相同的testAOPnno2采用是的完全注解开发，代替了xml配置文件。通过运行结果我们可以很轻清楚地看到不同类型通知的执行顺序，以及增强类的优先级。**

> **以上就是基于AspectJ实现AOP操作的全部内容。**

**看完如果对你有帮助，感谢点赞支持！  
如果你是电脑端的话，看到右下角的 “一键三连” 了吗，没错点它\[哈哈\]**  
![在这里插入图片描述][20210115230629703.gif_pic_center]

**加油！**

**共同努力！**

**Keafmd**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]: /images/20221119/621053363a8540efb5dee9723644cab7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]: /images/20221119/f7682027b4a04cf9ba0e22e3507fec69.png
[20210115230629703.gif_pic_center]: https://img-blog.csdnimg.cn/20210115230629703.gif#pic_center