011-Spring AOP入门

最新推荐文章于 2024-09-09 17:27:01 发布
最新推荐文章于 2024-09-09 17:27:01 发布
阅读量539 收藏
点赞数
分类专栏： 人在江湖之Spring基础 文章标签： spring spring boot spring 5 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forlinkext/article/details/118902704
版权
本文深入解析了AOP的核心概念，如切面、链接点、切入点、通知和目标对象，展示了Spring AOP如何通过JDK/CGLIB动态代理实现织入。通过实例演示了切面类的编写和在Spring中的应用，以及不同通知类型的使用场景。
摘要由CSDN通过智能技术生成

AOP相关术语

  • 切面(Aspect)：切面是对象操作过程中的截面。实际上"切面"就是一段代码，这段代码将被"植入"到程序流程中。
  • 链接点(Join Point)：连接点是对象操作过程中的某个阶段点（代码的某个位置，如某个方法执行前或执行后）。它实际上是对象的一个操作，例如：对象调用某个方法，读写对象的实例，或者某个方法抛出了异常等等。
  • 切入点(Pointcut)：切入点是连接点的集合，它是"切面"注入到程序中的位置，换句话说，"切面"是通过切入点被"注入"的。程序中可以有很多个切入点。
  • 通知(Advice)：通知是某个切入点被横切后，所采取的处理逻辑。在"切入点"处拦截程序后，通过通知来执行切面。
  • 目标对象(Target)：所有被通知的对象(也可以理解为被代理的对象)都是目标对象。目标对象被AOP所关注。AOP会注意目标对象的变动，随时准备向目标对象"注入切面"。
  • 织入(Weaving)：织入是将切面功能应用到目标对象的过程。AOP织入的方式有3种：编译时(Compile time)织入、类加载时期(Classload time)织入、执行期(Runtime)织入。Spring AOP一般多见于执行期织入。

AOP原理

Spring AOP默认使用JDK动态代理。如果被代理的类没有实现接口，则使用CGLIB动态代理。

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

入门示例

pom引入aspectjweaver依赖

<dependency>
   	<groupId>org.aspectj</groupId>
   	<artifactId>aspectjweaver</artifactId>
</dependency>

注意：我们的示例是使用@Aspect注解，需要AspectJ 的aspectjweaver.jar库。此示例是在系列文章的基础上继续的，所以其他依赖项请自行补足。

编写需要织入切面的bean

package com.yyoo.boot.aop.beans;

import org.springframework.stereotype.Component;

@Component
public class TestBean1 {

    public void test1(String str){
        System.out.println("参数str："+str);
    }

}

编写切面类

package com.yyoo.boot.aop.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component // 需要把@Aspect（切面）类也交由Spring容器管理
public class AspectBean1 {

    // 切入点表达式（此处表示com.yyoo.boot.aop.beans包下的所有方法）
    @Pointcut("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void pointCut(){}

    // 前置通知
    @Before("com.yyoo.boot.aop.aspect.AspectBean1.pointCut()")
    public void around(){
        System.out.println("切面执行程序");
    }

}

编写AppConfig

package com.yyoo.boot.aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;


// 配置类中没有定义@bean所以我们没有添加@Configuration注解
@ComponentScan("com.yyoo.boot.aop")
@EnableAspectJAutoProxy // 使用@EnableAspectJAutoProxy注解启用@AspectJ支持
public class AppConfig {



}

示例程序

package com.yyoo.boot.aop;


import com.yyoo.boot.aop.beans.TestBean1;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Demo1 {

    @Test
    public void test(){

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        TestBean1 bean1 = context.getBean(TestBean1.class);
        System.out.println(bean1);
        bean1.test1("当前参数");

    }

}

程序结构图

在这里插入图片描述
在这里插入图片描述

执行结果

com.yyoo.boot.aop.beans.TestBean1@76b1e9b8
切面执行程序
参数str：当前参数

我们示例中的切面类定义的切点（@Pointcut）注解了一个空方法，实际上我们的切面类可以简化为如下使用

package com.yyoo.boot.aop.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component // 需要把@Aspect（切面）类也交由Spring容器管理
public class AspectBean1 {

    // 前置通知(直接月切点表达式一起使用)
    @Before("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void around(){
        System.out.println("切面执行程序");
    }

}

切入点表达式

execution：用来匹配连接点的执行方法，这是Spring中使用的最主要的切入点定义方法

  • execution(public * *(..))：匹配任意公共方法。
  • execution(* set*(..))：匹配任何以"set"开头的方法。
  • execution(* com.yyoo.boot.service.*.*(..))：匹配service包中的任意方法。
  • execution(* com.yyoo.boot.service..*.*(..))：匹配service包及其子包中的任意方法。

within：通过类型来匹配连接点的执行方法

  • within(com.yyoo.boot.service.*)：匹配service包中的任意方法
  • within(com.yyoo.boot.service…*)：匹配service包及其子包中的任意方法。

this：用于匹配特定类型的连接点，但它是代理对象的范围内进行匹配

  • this(com.yyoo.boot.service.AccountService)：匹配代理对象中类型为AccountService的Java对象内的连接点。

target：也是用于匹配特定类型的连接点，但它是在目标对象的范围内进行匹配

  • target(cn.hxex.springcore.service.AccountService)：匹配目标对象中类型为AccountService的Java对象内的连接点

args：通过参数的类型来匹配特定的连接点

  • args(java.io.Serializable)：匹配只有一个参数并且该参数实现了Serializable接口的连接点

通过注解指定连接点

@target：匹配目标对象中的连接点

  • @target(org.springframework.transaction.annotation.Transactional)：匹配使用了@Transactional注解的目标对象中的连接点

@args：用于匹配参数实现特定注解的连接点

  • @args(com.yyoo.boot.service.Classified)：匹配只有一个参数并且该参数实现了@Classified注解的连接点

@within：匹配有指定注解的目标对象类型中的连接点

  • @within(org.springframework.transaction.annotation.Transactional)：匹配与指定了@Transactional注解的对象中类型相同的对象中的连接点

@annotation：用于匹配具有指定类型注解的连接点

  • @annotation(org.springframework.transaction.annotation.Transactional)：匹配任何有@Transactional注解的连接点

运算符

切入点表达式也可以使用&&(and)、||(or) 和!(negation) 运算符，如：
execution(* set*(…)) && execution(* com.yyoo.boot.aop.beans….(…))

Spring AOP advice通知类型

  • @Before：前置通知，在切点执行之前执行
  • @AfterReturning：返回后通知，在切点方法返回之后（在return之后）执行
  • @AfterThrowing：异常后通知，在切点方法抛出异常后执行
  • @After：后置通知，在切点方法有结果后（无论是异常结果还是正常结果）返回
  • @Around：环绕通知，我们可以在切点方法执行前后添加代码逻辑。

@Before前置通知

    @Before("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void before(){
        System.out.println("切面执行程序");
    }

执行结果

com.yyoo.boot.aop.beans.TestBean1@f78a47e
切面执行程序
参数str：当前参数

@AfterReturning返回后通知

    @AfterReturning("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void afterReturning(){
        System.out.println("切面执行程序");
    }

执行结果

com.yyoo.boot.aop.beans.TestBean1@f78a47e
参数str：当前参数
切面执行程序

在切面中获取返回结果

修改TestBean1的方法如下

    public String test1(String str){
        System.out.println("参数str："+str);
        return "rs-" + str;
    }

给我们的示例方法加入返回值
修改切面代码

    @AfterReturning(value = "execution(* com.yyoo.boot.aop.beans..*.*(..))",returning = "rs")
    public void afterReturning(String rs){
        System.out.println("切面执行程序");
        System.out.println("方法返回结果："+rs);
    }

注意：returning属性的名称要与方法上对应的参数名称一致

执行结果

com.yyoo.boot.aop.beans.TestBean1@6892b3b6
参数str：当前参数
切面执行程序
方法返回结果：rs-当前参数

@AfterThrowing异常后通知

我们再次修改TestBean1的方法

    public String test1(String str){
        System.out.println("参数str："+str);
        int a = 3/0;
        return "rs-" + str;
    }

就添加了一个除数为0的代码

    @AfterThrowing(value = "execution(* com.yyoo.boot.aop.beans..*.*(..))",throwing = "ex")
    public void afterThrowing(Exception ex){
        System.out.println("切面执行程序");
        System.out.println("方法返回结果："+ex);
    }

执行结果

com.yyoo.boot.aop.beans.TestBean1@2a265ea9
参数str：当前参数
切面执行程序
方法返回结果：java.lang.ArithmeticException: / by zero
异常打印....

@After后置通知

    @After("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void after(){
        System.out.println("切面执行程序");
    }

执行结果


com.yyoo.boot.aop.beans.TestBean1@740cae06
参数str：当前参数
切面执行程序

异常打印....

@Around环绕通知

我们先将TestBean1的除数为0异常去掉

    public String test1(String str){
        System.out.println("参数str："+str);
        return "rs-" + str;
    }

编写切面方法

    @Around("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("切面前置逻辑代码");
        try {
            pjp.proceed(); // 执行原方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("切面后置逻辑代码");
    }

执行结果

com.yyoo.boot.aop.beans.TestBean1@f78a47e
切面前置逻辑代码
参数str：当前参数
切面后置逻辑代码

pjp.proceed();这里还有个重载的方法pjp.proceed(Object[]);如果我们要在切面类中覆盖原来的参数，可以使用该方法

    @Around("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("切面前置逻辑代码");
        try {
            pjp.proceed(new Object[]{"更改后的参数"}); // 执行原方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("切面后置逻辑代码");
    }

执行结果

com.yyoo.boot.aop.beans.TestBean1@f78a47e
切面前置逻辑代码
参数str：更改后的参数
切面后置逻辑代码

@AfterReturning、@AfterThrowing、@After的区别

@AfterReturning：只在切点方法正确执行返回之后才执行。
@AfterThrowing：只在切点方法抛出异常后才执行。
@After：无论切点方法是否正确返回均会执行（类似于异常的finally块）

切面方法的参数JoinPoint

所有类型的通知，其通知方法的第一个参数为JoinPoint（如果要使用JoinPoint，那么它必须是第一个参数）。只有环绕通知@Around第一个参数是ProceedingJoinPoint，ProceedingJoinPoint是JoinPoint的子类。

JoinPoint常用方法

  • getArgs()：返回方法参数。
  • getThis(): 返回代理对象。
  • getTarget(): 返回目标对象。
  • getSignature()：返回所建议的方法的描述。

示例

    @Around("execution(* com.yyoo.boot.aop.beans..*.*(..))")
    public void afterReturning(ProceedingJoinPoint pjp){
        System.out.println("切面前置逻辑代码");
        try {
            pjp.proceed(new Object[]{"更改后的参数"}); // 执行原方法

            Object[] args = pjp.getArgs();
            if(args != null){
                for(int i = 0; i< args.length;i++){
                    System.out.print("\t参数["+i+"]："+args[i]);
                }
            }else {
                System.out.print("\t无参数");
            }
            System.out.println();

            System.out.println(pjp.getSignature().getName());
            System.out.println(pjp.getTarget());
            System.out.println(pjp.getThis());

        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("切面后置逻辑代码");
    }

本章只介绍了注解方式实现的Spring AOP，目前使用的更多的方式。Spring也提供了xml配置的方式，有兴趣可以自行到官网查看https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-schema

上一篇：010-Spring 资源Resource接口
下一篇：012-Spring DAO 数据访问对象

AOP(四)之After增强处理
qq_40179479的博客
12-01 1264
After增强处理 使用@After可以修饰After增强处理，它与AfterReturning增强处理有点相似，但也有区别： AfterReturing增强处理只有在目标方法成功完成后才会被织入。 After增强处理不管目标方法如何结束（包括成功完成和遇到异常中止两种情况），它都会被织入。 测试 实现类方法 @Override public void testAfter1()...
AOP切面使用
xzy的博客
04-29 1515
文章目录AOP切面使用首先定义一个@Aspect类然后通过execution写切点方法几个注解execution表达式的一些规则 AOP切面使用 首先定义一个@Aspect类 然后通过execution写切点方法 几个注解 @Around：在目标方法的前面和后面都执行我们的切点方法 @Before:只在目标方法的前面执行我们的切点方法 @After:只在目标方法的后面执行我们的切点方法 这里需要注意一下使用@Around的环绕通知和前置后置通知的一个最大的区别，环绕通知里面需要执行一个procced
AOP之后置通知@After、返回通知@AfterReturning、异常通知@AfterThrowing
最新发布
忽胖忽瘦的博客
09-09 470
以上两种写法都表明监听com.example.demo.service.impl.AccountServiceImpl类下的aopBeforeMsg函数。需要注意的是，该注解只能抓捕未被自己代码处理的异常，加入在业务逻辑中对代码进行了try…以上写法表示监听AccountServiceImpl类与OrderService类中get开头的函数。以上写法表明监听AccountServiceImpl类下所有get开头函数。以上表明监听AccountServiceImpl类下的所有函数。
Spring的AOP
wangyj1992的博客
04-06 396
Spring的AOP，先来了解下英文翻译：Aspect Oriented Programming。中文翻译即为面向切面编程。 Java是面向对象编程，即处理的时候是根据对象进行处理。 AOP是面向切面编程，即处理的时候是相当于一个横切面，部分符合条件的程序都需要经过这个横切面进行处理。 面向对象和面向切面编程是相辅相成的。   先来介绍一下面向切面编程AOP的三个关键概念：Pointcu...
关于AOP
weixin_43777799的博客
02-06 100
AOP(Aspect Oriented Programming) Aop面向切面编程，是Spring技术体系中的两大核心思想之一，它解决了垂直方向面向对象思想想要完成例如日志、性能检测等系统代码太过冗余不易维护的问题，底层使用了动态代理和反射的机制。 Aop三种实现方式： 使用spring自己的aop ①定义通知类，实现“通知”接口，例如MethodBeforeAdvice(前置通知)、AfterReturningAdvice(后置通知)、MethodInterceptor(环绕通知、拦截器)，重写对应
死磕spring源码系列-SpringAop十分钟快速入门
08-30
死磕spring源码系列-SpringAop十分钟快速入门
拿捏面试官-Spring AOP IOC源码笔记
01-30
7. **AOP入门** - **cglib代理**：Spring AOP使用动态代理技术，如JDK动态代理和CGLIB，实现切面编程。 - **手动实现AOP**：编写切面类，定义通知方法。 - **AOP的概述**：AOP用于封装横切关注点，如日志、事务、...
jdk6.0从入门到精通-----chapter16反射机制-spring AOP
05-28
本章我们将深入探讨“反射机制”以及如何结合Spring AOP（面向切面编程）进行应用。反射是Java中的一种强大工具，允许程序在运行时检查类、接口、字段和方法的信息，甚至可以动态创建对象和调用方法。Spring AOP则是...
Spring AOP入门Demo分享
08-28
在本文中，我们将通过一个简单的入门Demo来了解如何在Spring中使用AOP。首先，我们需要创建一个Maven项目，并添加相关的依赖。在`pom.xml`文件中，我们需要引入Spring的核心库、Spring的上下文库、Spring的AOP库以及...
Spring原理与源码分析系列（六）- Spring AOP入门与概述
noaman_wgs的博客
03-20 794
一、AOP 1、什么是AOP AOP ：Aspect-Oriented Programming，面向切面编程的简称。 在我们的项目代码中，有大量与日志、事务、权限（AOP称之为横切关注点）相关的代码镶嵌在业务代码当中，造成大量代码的重复与代码的冗余。 虽然可以将这些重复的代码封装起来再进行调用，但是这样的调用方式比较单一，不够灵活，无法更好地以模块化的方式，对这些横切关注点进...
Spring-AOP链式调用@After、@Before、@AfterReturning、@Around、@AfterThrowing
dhylanyu1的博客
08-07 720
这里写目录标题一级目录 一级目录
AOP
weixin_54262071的博客
04-08 124
AOP简介 概念 切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。 连接点（Joinpoint） ：程序执行过程中的某一行为。 通知（Advice） ：“切面”对于某个“连接点”所产生的动作。 切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。 目标对象（Target Object） ：被一个或者多个切面所通知的对象。 AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。
Spring Spring 实现AOP时切入点表达时的多种写法
qq_35677589的博客
03-08 169
一、修饰符可以不写 二、可以用*..来代替包名 三、将do开头的所有方法前面执行myBefore方法 四、在方法前面执行两个方法 五、包中所有的类的do开头的所有方法之前执行MyBefore2方法 六、注意不能省略参数类型列表 执行的结果 ...
Spring AOP @After,@Around,@Before执行的顺序以及可能遇到的问题
热门推荐
lmx125254的博客
11-23 7万+
AOP中有@Before，@After，@Around，@AfterRunning注解等等。 首先上下自己的代码，定义了切点的定义 @Aspect @Component public class LogApsect { private static final Logger logger = LoggerFactory.getLogger(LogApsect.class); ...
Spring之AOP
Ann257725的博客
11-12 334
AOP中关键性概念 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出. 目标(Target)：被通知(被代理)的对象 注1：完成具体的业务逻辑 通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理) 注2：完成切面编程 代理(Proxy)：将通知应用到目标对象后创建的对象(...
学习笔记：AOP(before、after)
digga2012
01-05 680
代码(转bea) applicationContext.xml [code] mypack.IBusinessLogic theTracingBeforeAdvisor theTracingAfterAdvisor ...
【Spring第九篇】AOP
...
04-13 869
文章目录AOP核心概念AOP:切点表达式AOP:使用切点表达式@annotation通知分类获取被增强方法相关信息【不使用自动注入】AOP方式一：使用配置文件方法【不使用自动注入】AOP方式二：自定义切点【不使用自动注入】AOP方式三:使用注解方法 导包 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId&gt
Spring框架|AOP面向切面编程的十个细节
匿名攻城狮
03-26 2335
文章目录一、IoC容器中保存的是组件的代理对象二、切入点表达式的写法三、通知方法的执行顺序四、JoinPoint获取目标方法的信息五、throwing、returning指定哪个参数用来接收异常、返回值六、Spring对通知方法的约束七、抽取可重用的切入点表达式八、环绕通知实际上就是动态代理九、同时声明环绕通知和普通通知时的执行顺序十、多切面运行顺序 一、IoC容器中保存的是组件的代理对象 假设...
"拿捏面试官-Spring AOP IOC源码笔记
本文是关于Spring AOP IOC源码的笔记，通过对Spring的入门和IOC的介绍，深入分析了Spring的核心模块以及Bean对象的创建细节和对象依赖注入。文章通过解释Spring的侵入式和松耦合概念，引出了Spring的核心模块IOC的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值