Spring基于AspectJ实现AOP操作

程序员文章站 2022-06-24 15:04:55

基于AspectJ实现AOP操作准备工作在项目工程里面引入 AOP 相关依赖。学会使用切入点表达式AOP 操作（AspectJ 注解）1、创建类，在类里面定义方法2、创建增强类（编写增强逻辑），在增强类里面，创建方法，让不同方法代表不同通知类型3、进行通知的配置4、配置不同类型的通知相同的切入点抽取有多个增强类多同一个方法进行增强，设置增强类优先级完全使用注解开发代码结构测试代码Spring 框架一般都是基于 AspectJ 实现 AOP 操作。需要注意的是：AspectJ 不是 Spring 组成部...

基于AspectJ实现AOP操作

准备工作

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

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

准备工作

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

需要以下这些依赖：
Spring基于AspectJ实现AOP操作

学会使用切入点表达式

切入点表达式作用（通俗的讲）：知道对哪个类里面的哪个方法进行增强。
语法结构： 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>

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


</beans>

4、配置不同类型的通知

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

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...");
    }

}

相同的切入点抽取

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

//相同的切入点抽取
    @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 {
}

代码结构

Spring基于AspectJ实现AOP操作

测试代码

测试代码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操作的全部内容。

看完如果对你有帮助，感谢点赞支持！
如果你是电脑端的话，看到右下角的 “一键三连” 了吗，没错点它[哈哈]
Spring基于AspectJ实现AOP操作

加油！

共同努力！

Keafmd

本文地址：https://blog.csdn.net/weixin_43883917/article/details/112792362

上一篇：视频剪辑软件哪个好？七款非常好用的视频剪辑软件推荐

下一篇：记一次jsch ssh登录失败 End of IO Stream Read 异常的处理

Spring基于AspectJ实现AOP操作

基于AspectJ实现AOP操作

准备工作

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

学会使用切入点表达式

AOP 操作（AspectJ 注解）

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

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

3、进行通知的配置

4、配置不同类型的通知

相同的切入点抽取

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

完全使用注解开发

代码结构

测试代码

基于spring如何实现事件驱动实例代码

Spring AOP + 注解实现统一注解功能

Java基于迭代器模式实现的访问人员列表操作示例

spring boot+自定义 AOP 实现全局校验的实例代码

Java基于分治算法实现的线性时间选择操作示例

详解Spring AOP 实现“切面式”valid校验

C#实现的基于二进制读写文件操作示例

Spring Aop之AspectJ注解配置实现日志管理的方法

spring AOP自定义注解方式实现日志管理的实例讲解

Spring AOP + 注解实现统一注解功能