AOP面向切面编程

已于 2024-08-30 19:31:36 修改
阅读量428 收藏 7
点赞数 7
文章标签： java spring boot 开发语言
于 2024-08-30 19:27:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52007179/article/details/141725435
版权

AOP面向切面编程

1 什么是AOP？
  • AOP 是面向切面编程，是 Spring Framework 的核心子模块；
  • 是一种设计思想，在不修改源代码的情况下给程序统一添加额外功能的一种技术。
2 AOP的作用？
  • 代码重用：将一些通用的功能（比如日志记录、安全控制等）抽象出来，形成可重用的模块；
  • 简化开发：使开发人员将关注点从业务逻辑中分离出来，使得开发更加简单明了；
  • 提高系统可扩展性：在系统需求变化时，只需要修改AOP模块而不是修改业务逻辑，这可以使得系统更加易于扩展和维护；
  • 降低代码耦合度：将不同的关注点分离开来，这可以避免代码之间的紧耦合。
3 使用AOP的流程？

  • 第1步：添加依赖，刷新 Maven；

    • <!--引入aop依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

  • 第2步：创建切面类，添加 @Aspect 注解；

    • @Aspect
@Component
public class LogAspect {
    /**
     * Before注解: 前置通知,在目标方法执行之前执行;
     * value参数: 切入点表达式,指定哪些方法需要被植入增强逻辑;
     */
    @Before(value = "execution(public int cn.tedu._07springaop.aop.CalculatorImpl.*(..))")
    public void beforeMethod(){
        //前置通知的增强逻辑
    }
}

  • 第3步：编写切入点表达式，使用各种通知注解对目标函数进行功能增强。

4 什么是切入点表达式？

在 AOP 中，切入点表达式指定了哪些方法需要被植入增强逻辑。它是一个表达式，用于 匹配目标对象中的方法，并提供切入点的精确定义，比如：

execution(public int cn.tedu._07springaop.aop.CalculatorImpl.*(..))
5 五种通知类型

1、**前置通知：**目标方法执行前执行 @Before

2、**返回通知：**目标方法成功结束后执行 @AfterReturning

3、**异常通知：**目标方法出现异常时执行 @AfterThrowing

4、**环绕通知：**环绕通知是环绕一个目标方法，环绕通知需要携带ProceedingJoinPoint类型的参数，该参数可以决定是否执行目标方法，环绕通知必须有返回值，返回值必须和目标方法的返回值一致 @Around

5、**后置通知：**目标方法执行后执行 @After

返回通知和后置通知区别：

1、执行时机

前置通知和返回通知的区别：前置通知在目标方法执行前执行，返回通知在目标方法执行后执行

2、权限不同

返回通知可以拿到目标方法的返回值(returning 参数)，

后置通知无法拿到目标方法的返回值

示例：
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * Aspect注解
 * 1、表示当前类是一个切面类
 * 2、可以定义切面方法，为目标方法进行功能增强；
 *
 * 通知类型
 * 1、前置通知：目标方法执行前执行  @Before
 * 2、返回通知：目标方法成功结束后执行 @AfterReturning
 * 3、异常通知：目标方法出现异常时执行 @AfterThrowing
 * 4、环绕通知：环绕通知，环绕通知是环绕一个目标方法，环绕通知需要携带ProceedingJoinPoint类型的参数，
 *      该参数可以决定是否执行目标方法，环绕通知必须有返回值，返回值必须和目标方法的返回值一致  @Around
 * 5、后置通知：目标方法执行后执行  @After
 *
 * 返回通知和后置通知区别：
 * 执行时机
 *     前置通知和返回通知的区别：前置通知在目标方法执行前执行，返回通知在目标方法执行后执行
 * 权限不同
 *      返回通知可以拿到目标方法的返回值(returning 参数)，
 *      后置通知无法拿到目标方法的返回值
 */
@Aspect
@Component
public class LogAspect {

    // 开始日志的方法

    /*  1、前置通知
    @Before(value = "") 前置通知 表示在目标方法执行前执行该方法
    比如调用add方法之前执行beforeMethod方法
    value参数 ：切入点表达式  确定哪些方法需要被植入增强逻辑

    切入点表达式：
    value = "execution(* cn.practice._07springaop.aop.CalculatorImpl.*(..))"
    固定格式：execution(方法修饰符 返回值 方法所在包名.类名.方法名(参数列表))"

    JoinPoint：连接点，即被增强的方法 拦截到的的方法
    1、JoinPoint可以获取方法名，方法参数，方法所在包名，方法所在类名
     */
//    @Before(value = "execution(public int cn.practice._07springaop.aop.CalculatorImpl.*(..))")
//    public void beforeMethod(JoinPoint joinPoint){
//        // 从方法中获取方法名
//        String methodName = joinPoint.getSignature().getName();
//        // 从方法中获取参数
        Object[] args = joinPoint.getArgs();
//        String args = Arrays.toString(joinPoint.getArgs());
//
//        System.out.println("[前置通知]"+ methodName + "方法开始，参数为:" + args);
//    }


    /*
    2、返回通知：目标方法  成功结束后执行
    @AfterReturning(value = "execution(* cn.practice._07springaop.aop.CalculatorImpl.*(..))",returning = "result")
    returning:获取目标方法的返回值
     */
//    @AfterReturning(value = "execution(public int cn.practice._07springaop.aop.CalculatorImpl.*(..))",returning = "result")
//    public void afterReturningMethod(JoinPoint joinPoint,Object result){
//        // 从方法中获取方法名
//        String methodName = joinPoint.getSignature().getName();
//
//        System.out.println("[返回通知]"+ methodName + "方法结束，结果为：" + result);
//    }

    /*
    3、后置通知：目标方法成功结束和异常都会执行一般用于释放资源
     */
//    @After(value = "execution(public int cn.practice._07springaop.aop.CalculatorImpl.*(..))")
//    public void afterMethod(JoinPoint joinPoint){
//        // 从方法中获取方法名
//        String methodName = joinPoint.getSignature().getName();
//
//        System.out.println("[后置通知]"+ methodName + "方法彻底执行结束");
//    }

    /*
       4、异常通知
       @AfterThrowing(value = "execution(* cn.practice._07springaop.aop.CalculatorImpl.*(..))",throwing = "ex")
        */
//    @AfterThrowing(value = "execution(public int cn.practice._07springaop.aop" +
//            ".CalculatorImpl.*(..))",throwing = "ex")
//    public void afterThrowingMethod(JoinPoint joinPoint,Throwable ex){
//        // 从方法中获取方法名
//        String methodName = joinPoint.getSignature().getName();
//
//        System.out.println("[异常通知]"+ methodName + "方法出现异常：" + ex.getMessage());
//    }

    /**
     * 5.环绕通知[Around注解]:
     *   1.目标方法执行前后都执行
     *   2.目标方法抛出异常时也会执行
     *   3.可以获取到目标方法得返回值
     *   4.可以获取到一擦汗给你对象
     *   环绕通知 == 前置通知+返回通知+异常通知+后置通知
     *
     *
     *   ProceedingJoinPoint是JoinPoint的子类：连接点，即被增强的方法
     */
    @Around(value = "execution(public int cn.practice._07springaop.aop.CalculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        // 异常捕获
        Object result = null;
        try{
            // 获取目标方法
            // 前置通知
            System.out.println("111 - 前置通知");
            // 执行目标方法  具体执行的方法的返回值
            result = joinPoint.proceed();

            // 如果没有抛出异常    返回通知
            System.out.println("333 - 返回通知");


        }catch (Throwable e){
            // 抛出异常    异常通知
            System.out.println("222 - 异常通知");
            throw new RuntimeException(e);

        }finally {
            // 后置通知
            System.out.println("444 - 后置通知");
        }

        return result;
    }
}
6 AOPDEMO 👉参看
ღ᭄ꦿ࿐Never say never꧂
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringAOP面向切面编程
trong_ 的烂笔头
09-09 2190
介绍面向切面编程的思想（AOP），AOP的组成，SpringAOP的简单演示使用，SpringAOP基于动态代理的实现原理。
【Spring】 AOP面向切面编程
Orion
02-23 1438
横切关注点从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。有十个附加功能，就有十个横切关注点。AOP核心关注点和横切关注点。业务处理的主要流程是核心关注点，非核心代码是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。(分离核心业务代码与非核心代码通知(增强)每一个横切关注点。
【SSM直击大厂】第十章：Spring AOP面向切面编程
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
04-11 3203
🙊🙊作者主页：🔗求不脱发的博客 📔📔 精选专栏：🔗SSM直击大厂 📋📋 精彩摘要：SpringAOP面向切面编程是Java OOP面向对象编程的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍 生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序 的可重用性，同时提高了开发的效率。 💞💞觉得文章还不错的话欢迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞 📚 📖 📝1️⃣ 2️⃣ 3️⃣ 4️⃣ 5️⃣ 6️⃣ ..
SpringBoot之AOP面向切面编程实例
weixin 19953181360
11-20 2991
目录1.引入pom依赖2.切入点表达式——组成——逻辑运算符——通配符——范例3. 启动类配置4.通知类型4.1 @Before : 标注当前方法作为前置通知4.1.1 创建自定义注解(用于使用注解作为切入点)4.1.2 设置切面类以及Before切面方法4.1.3 @Before : 标注当前方法作为前置通知测试4.1.3.1 Controller层4.1.3.2 service层4.1.3.3 serviceimpl层@Before标注当前方法作为前置通知测试结果：4.2 @After : 标注当
MVC AOP面向切面编程简单介绍及实例
08-31
面向切面编程（AOP，Aspect Oriented Programming）是一种编程范式，旨在提供更好的模块化和组织代码的方式，尤其在处理系统中横切关注点时。MVC（Model-View-Controller）架构模式则是一种用于构建Web应用程序的...
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
AOP面向切面编程总结
08-22
### AOP面向切面编程详解 #### 一、AOP概览 AOP（Aspect-Oriented Programming，面向切面编程）是一种编程思想和技术，它作为OOP（面向对象编程）的一种补充，主要解决了OOP在处理横切关注点方面的不足。在传统的...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 3483
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 3484
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 3832
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 1955
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2076
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 1702
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 1202
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1971
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
秋夫人
08-26 842
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
JVM 内存参数
iOS逆向与安全
08-29 300
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
AOP面向切面编程的测试代码
07-20
以下是一个简单的AOP面向切面编程的测试代码示例，使用Spring框架实现： 首先，创建一个切面类 `LoggingAspect`，用于定义切面逻辑： ```java import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; @Aspect @Component public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void beforeAdvice(JoinPoint joinPoint) { System.out.println("Before method: " + joinPoint.getSignature().getName()); } @After("execution(* com.example.service.*.*(..))") public void afterAdvice(JoinPoint joinPoint) { System.out.println("After method: " + joinPoint.getSignature().getName()); } } ``` 然后，创建一个测试服务类 `UserService`，用于演示AOP的应用： ```java import org.springframework.stereotype.Service; @Service public class UserService { public void createUser(String username) { System.out.println("Creating user: " + username); } public void deleteUser(String username) { System.out.println("Deleting user: " + username); } } ``` 最后，创建一个Spring Boot应用程序，并在启动类中进行配置： ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.EnableAspectJAutoProxy; @SpringBootApplication @EnableAspectJAutoProxy public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); UserService userService = context.getBean(UserService.class); userService.createUser("John"); userService.deleteUser("John"); } } ``` 在上述示例中，`LoggingAspect` 切面类使用 `@Before` 和 `@After` 注解分别定义了在目标方法执行前和执行后的逻辑。切面逻辑会应用于 `UserService` 类中的所有方法。 当运行应用程序时，可以看到切面逻辑在方法执行前和执行后打印了相应的日志消息。 这是一个简单的AOP面向切面编程的示例，你可以根据实际需求进行更复杂的切面逻辑定义和应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值