【Spring】AOP实现的两种方向

已于 2022-08-11 18:19:50 修改
阅读量262 收藏
点赞数 1
分类专栏： Spring学习博客 文章标签： spring java 后端
于 2022-08-08 23:39:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53635765/article/details/126233846
版权

什么是Spring的AOP？

AOP在spring中又叫“面向切面编程”，它可以说是对传统我们面向对象编程的一个补充，从字面上顾名思义就可以知道，它的主要操作对象就是“切面”，所以我们就可以简单的理解它是贯穿于方法之中，在方法执行前、执行时、执行后、返回值后、异常后要执行的操作。

相当于是将我们原本一条线执行的程序在中间切开加入了一些其他操作一样。

在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应用在哪里，以什么方式应用，并且不必修改受核心业务类。这样一来横切关注点就被模块化到业务逻辑类里——这样的类我们通常就称之为“切面”。

例如下面这个图就是一个AOP切面的模型图，是在某一个方法执行前后执行的一些操作，并且这些操作不会影响程序本身的运行。
在这里插入图片描述

AOP切面编程的专业术语

术语含义
横切关注点非核心业务，与业务逻辑无关的，需要关注的方法或功能，如日志，安全，缓存，事务
切面(Aspect)封装横切关注点的类
通知(Advice)切面必须要完成的各个具体工作（切面的方法）
目标(Target)被通知的对象
代理(proxy)向目标对象应用通知之后创建的代理对象
连接点(Joinpoint)横切关注点在程序代码中的具体体现，对应程序执行的某个特定位置。
切入点(pointcut)执行或找到连接点的一些方式

现在大概的了解了AOP切面编程的基本概念，接下来就是实际操作了。

基于XML配置的AOP实现

方式一：基于spring的API实现（如MethodBeforeAdvice ）

在bean配置文件中，所有的Spring AOP配置都必须定义在< aop:config>元素内部。对于每个切面而言，都要创建一个< aop:aspect>元素来为具体的切面实现引用后端bean实例。

切面bean必须有一个标识符，供< aop:aspect>元素引用。

1.导入aspectj依赖

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

2.定义切面实现advice

MethodBeforeAdvice ，AfterReturningAdvice分别是前置通知与返回后通知

public class BeforeLog implements MethodBeforeAdvice {
    @Override
    /*method要执行目标对象的方法
     target目标对象
     args参数
    */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被调用");
    }
}

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("调用了"+method.getName()+" 返回值："+returnValue);
    }
}

定义了一个BeforeLog 和AfterLog类 ，它们是一个类，我们叫切面。
前置日志和后置日志这样的功能，他们不属于核心业务，属于横切关注点，
当这些切面下的方法（通知）切到核心业务逻辑方法的某个特定的位置如之前或者之后，就是aop面向切面的体现。

3.配置xml

  1. 注册bean
  2. 配置Aop
<?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: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/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userManager" class="com.kxy.service.UserManagerImpl" name="manager"/>
    <bean id="beforeLog" class="com.kxy.log.BeforeLog"/>
    <bean id="afterLog" class="com.kxy.log.AfterLog"/>
    <!--配置Aop-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.kxy.service.UserManagerImpl.*(..))"/>
        <!--执行环绕通知-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

4.测试运行

以add方法和del方法为例

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationBeans.xml");
        UserManager userManagerImpl = (UserManager) context.getBean("manager");
        userManagerImpl.addUser();
        System.out.println("=============");
        userManagerImpl.delUser();
    }
}

在这里插入图片描述

其实质还是动态代理。所以AOP切面编程思想体现仍然是动态代理。

总结一下通过XML配置实现AOP切面编程的过程：

  1. 开启基于注解的AOP功能
  2. 将目标类和切面类加入到容器中 相当于注解@component
  3. 声明哪个类是切面类，相当于注解@Aspect
  4. 在配置文件中配置通知方法，告诉切面类中的方法都何时运行

方式二：基于自定义切面实现（aspect）

同样也是四步：

  1. 导入aspectj依赖
  2. 定义切面
  3. 配置xml
  4. 测试运行

2. 定义切面

public class DiyAspect {//切面
    public void BeforeLog(){//通知
        System.out.println("方法执行前打印日志......");
    }
    public void AfterLog(){
        System.out.println("方法执行后打印日志......");
    }
}

3.配置xml

<aop:config >Aop配置双标签下包裹<aop:pointcut >切入点，<aop:advisor >通知者 <aop:aspect >切面
<aop:aspect >切面标签，同样双标签，用来包裹通知如 <aop:before >

<?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: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/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userManager" class="com.kxy.service.UserManagerImpl" name="manager"/>
    <bean id="diyAspect" class="com.kxy.aspect.DiyAspect"/>
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.kxy.service.UserManagerImpl.*(..))"/>
        <!--切面-->
        <aop:aspect id="Aspect" ref="diyAspect">
            <!--通知-->
            <aop:before method="BeforeLog" pointcut-ref="pointcut"/>
            <aop:after method="AfterLog" pointcut-ref="pointcut" />
        </aop:aspect>
    </aop:config>
</beans>

4.测试运行(代码在方式一.4)

运行结果：
在这里插入图片描述

很显然这种方式它不能够像基于spring的API例如MethodBeforeadvice通知的方式那样通过反射的确定方法名和具体类，所以它不够强大。

基于注解的AOP实现

1.开启aspectj的注解支持和component扫描

我们在基于xml的第二种方式自定义切面基础上，原来的接口和实现类不变，改变xml和切面类。开启了对component注解的扫描以及aspectj包下的注解支持。

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启对扫描com.kxy下的所有component注解支持：关联xml-->
    <context:component-scan base-package="com.kxy"/>
    <!--开启对类似于before通知注解的支持：关联xml-->
    <aop:aspectj-autoproxy/>
</beans>

把注解支持打开了，LogUtil下的@Component和@Aspect,@Before等才会生效

2.使用注解

@Component//LogUtil类注册Bean到Spring容器 相当于原xml里 <Bean id='logUtil' class=com.kxy.util.LogUtil/>
@Aspect//切面，相当于原来xml里的  <aop:aspect ref="logUtil"/>
public class LogUtil {//横切关注点：日志
    
    @Pointcut("execution(* com.kxy.service.UserManagerImpl.*(..))")
    public void pointcut() {
    }
    /*前置通知，相当于xml里的  <aop:before method="BeforeLog" pointcut-ref="pointcut"/>*/
    @Before("pointcut()")
    public void beforeLog(JoinPoint joinPoint) {
        System.out.println("方法执行前打印日志...");
    }
    @After("pointcut()")
    public void AfterLog(JoinPoint joinPoint) {
        System.out.println("方法执行后打印日志...");
    }
}

@Component:LogUtil类注册Bean到Spring容器 相当于原xml里

< Bean id='logUtil' class=com.kxy.util.LogUtil />

@Aspect:切面，相当于原来xml里的

 <aop:aspect ref="logUtil"/>

@Before(“pointcut()”)：前置通知，相当于xml里的

<aop:before method="BeforeLog" pointcut-ref="pointcut"/>*/




@Pointcut("execution(* com.kxy.service.UserManagerImpl.*(..))")
    public void pointcut() {
    }

等价于

<aop:pointcut id="pointcut" expression="execution(* com.kxy.service.UserManagerImpl.*(..))"/>

其实注解的方式，只是简化和优化了我们xml实现AOP的方式，本质上两者效果是一样的。

3.运行结果：

在这里插入图片描述

其他常用注解用法

@AfterReturning

@AfterReturning注解表示通知方法是在目标方法正常执行完之后执行的。

在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。returning属性的值即为用来传入返回值的参数名称，但是注意必须在通知方法的签名中添加一个同名参数。

在运行时Spring AOP会通过这个参数传递返回值，由于我们可能不知道返回值的类型，所以一般将返回值的类型设置为Object型。

切面下的返回后通知:

	@AfterReturning(pointcut = "execution(* com.kxy.service.UserManagerImpl.*(..))",returning = "result")
    public void LogReturn(JoinPoint joinPoint,Object result){
        System.out.println("方法名："+ joinPoint.getSignature().getName() + "返回值：" + result);
    }

业务里：

    public int checkLoginIn(){
        System.out.println("UserManagerImpl.check");
        return 1;
    }

joinPoint.getSignature():获得方法签名
joinPoint.getSignature().getName:获得方法名

@AfterThrowing

我们需要将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。

如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行。

    @AfterThrowing(value = "pointcut()",throwing = "e")
    public void LogError(JoinPoint joinPoint,Object e){
        System.out.println("方法名为："+ joinPoint.getSignature().getName() + "的异常为：" + e);
    }

@Around

环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。

对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。

在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。这就意味着我们需要在方法中传入参数ProceedingJoinPoint来接收方法的各种信息。

注意：
环绕通知的方法需要返回目标方法执行之后的结果，即调用joinPoint.proceed();的返回值，否则会出现空指针异常。具体使用可以看下面这个实例：

/**
	 * 环绕通知方法
	 * 使用注解@Around()
	 * 需要在方法中传入参数proceedingJoinPoint 来接收方法的各种信息
	 * 使用环绕通知时需要使用proceed方法来执行方法
	 * 同时需要将值进行返回,环绕方法会将需要执行的方法进行放行
	 * *********************************************
	 * @throws Throwable 
	 * */
	@Around("public int com.spring.inpl.*.*(int, int)")
	public Object MyAround(ProceedingJoinPoint pjp) throws Throwable {
		
//		获取到目标方法内部的参数
		Object[] args = pjp.getArgs();
		
		System.out.println("【方法执行前】");
//		获取到目标方法的签名
		Signature signature = pjp.getSignature();
		String name = signature.getName();
		Object result= null;
		try {
//			进行方法的执行
			result= pjp.proceed();
			System.out.println("方法返回时");
		} catch (Exception e) {
			System.out.println("方法异常时" + e);
		}finally{
			System.out.println("后置方法");
		}
		
		//将方法执行的返回值返回
		return result;
	}

4.通知注解的执行顺序

那么现在这五种通知注解的使用方法都已经介绍完了，
我们来总结一下这几个通知注解都在同一个目标方法中时的一个执行顺序。

在正常情况下执行：
@Before(前置通知)—>@After(后置通知)---->@AfterReturning(返回通知)

在异常情况下执行：
@Before(前置通知)—>@After(后置通知)---->@AfterThrowing(异常通知)

当普通通知和环绕通知同时执行时：
执行顺序是：
环绕前置----普通前置----环绕返回/异常----环绕后置----普通后置----普通返回/异常

❀༊烟花易冷ღ
关注
专栏目录
SpringBoot 系列教程(八十六)：Spring Boot使用AOP打印接口请求日志
Thinkingcao的专栏
12-26 928
一、前言 AOP被称作面向切面编程，OOP面向对象编程，其实由于OOP的一些局限性，AOP是对OOP的一种补充，是两种编程模式，Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——...
SpringAOP源码解析
Mr.xing的博客
10-06 703
aop源码解析
关于面向切面编程AOP
qq_42354304的博客
10-27 139
什么是AOP AOP Aspect Oriented Programing 面向切面编程 AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存） Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码 AspecJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对A...
AOP实现接口限流
liuerchong的博客
05-26 868
前言 限流方案 Java限流及常用解决方案 Guawa限流应用 @Slf4j @RestController @RequestMapping("/limit") public class LimitController { /** * 限流策略 ： 1秒钟2个请求 */ private final RateLimiter limiter = RateLimiter.create(2.0); private DateTimeFormatter dtf = Date
Spring Boot利用AOP切面实现接口监控
最新发布
Congee_porridge的博客
04-04 2502
利用Spring Boot的AOP切面实现接口监控，便于后续对接口的性能进行优化……
Spring_Aop_切入点
一条咸鱼
05-27 1110
Aop_通知_切入点 1，概述： 若目标类中有多个目标方法，则会将通知织入到每一个方法中。如何将通知织入到指定方法中。使用切入点：指定切面织入到目标对象的具体的位置，即织入到哪些目标类的哪些目标方法中。 2，若要定义切入点，就要定义一个Pointcut接口的实现类。Pointcut接口的完整定义如下： public interface Pointcut { public ClassFil
Spring源码——AOP
等一杯咖啡的博客
10-21 2273
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
spring aop (面向切面编程)实现事务管理(^_^^_^)
jaryle的专栏
03-23 2974
事务嵌套，不回滚的问题描述： 要想事务起作用，必须是主方法名上有@Transactional注解，方法体内不能用try catch；如果用try catch，则catch中必须用throw new RuntimeException(); @Transactional注解应该只被应用到public方法上，不要用在protected、private等方法上，即使用了也将被忽略，不起作用。这是由Sp...
接口防刷限流：利用Spring AOP实现高效机制
[接口防刷限流：利用Spring AOP实现高效机制](https://img-blog.csdnimg.cn/20201205183621246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pHTF9...
Spring AOP与Spring Boot整合秘籍
![Spring AOP与Spring Boot整合秘籍](https://img-blog.csdnimg.cn/20201205183621246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text...Spring AOP是Spring框架的一个重要模块，提供了面
Spring AOP切入点表达式
流楚丶格念的博客
07-24 1491
问题1按照上面的形式去编写切入点，一个两个还行，要是该类中的很多方法都要编写AOP是十分麻烦的，那么我们该如何简化切入点表达式中包名和参数类型书写？还是刚才的update函数，虽然我们编程是按照接口编程，但是最后运行还是实现类，所以下面两个对于接口与实现类的update描述方式都是对的。例如匹配com.yyl包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法。例如匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法。......
Spring——AOP理论
不怕万人阻挡，只怕自己投降
09-09 256
AOP（Aspect Orient Programming），面向切面编程，是面向对象编程 OOP 的一种补充。面向对象编程是从静态角度考虑程序的结构，而面向切面编程是从动态角度考虑程序运行过程。 AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB 的动态代理。 面向切面编程，就是将交叉业务逻辑封装成切面，利用 AOP 容器的功能将切面织入到主业务逻...
AOP切面编程（必须实现统一接口），spring中的配置示例
caixen的专栏
03-27 326
   &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans"              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"              xmlns...
Spring AOP（切面面向接口）
weixin_45127932的博客
02-25 3743
1.什么是AOP？ AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的...
【SpringBoot随笔】SpringBoot中Aop切入接口记录参数信息
qq_44299928的博客
04-29 417
第一步：引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 第二步：创建切面类 /** * @author yangyang * @version 1.0 *
Spring学习4-面向切面（AOP）之Spring接口方式
salonzhou的专栏
12-25 2710
一、初识AOP    关于AOP的学习可以参看帮助文档：spring-3.2.0.M2\docs\reference\html目录下index.html的相关章节       1、AOP：Aspect-Oriented Programming。AOP是OOP的补充，是GOF的延续。说到AOP，我们就不得不来提一下软件的纵向和横向问题。从纵向结构来看就是我们软件系统的各个模块，它主要负责处理
java中基于spring aop(切面)的接口调用重试实现
huang007guo的专栏
11-23 1886
java中基于spring aop(切面)的接口调用重试实现. 在项目中需要调用第三方接口,但调用三方接口时可能出现网络错误等外部问题导致的接口调用失败,现需要在此场景下重新尝试调用,并指定重试(错误)的最大次数,超过最大次数后发送邮件通知
Spring AOP 介绍与基于接口的实现
weixin_33858249的博客
11-23 315
面向切面编程，缩写为 AOP，在程序开发中主要用来解决一些系统层面上的问题，比如日志、事务、权限等。在阿里体系中，AOP 广泛应用于天梭日志、本地缓存、doom 增强等场景。 AOP基本概念 为什么需要面向切面编程？面向对象编程解决了封装问题，但同时也带来了新问题，如何增强对象的方法？比如，一个接口 A 可能有多个实现类 A1、A2、******、An，如何为多个实现类的同一个方法打印日志或者做权...
Spring自定义日志实现（5）——日志完成
xcxy2015的博客
03-30 332
经过前4部分的学习，我们很容易就能做一个日志的功能，代码如下： 注解类： @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface SelfLog { String aim() default ""; String comment() defa...
仿写Spring框架实现IOC与AOP及解决循环依赖研究
资源摘要信息:"Spring简单仿写，实现基本IOC，依赖注入和AOP 未解决循环依赖" 知识点： 1. Spring框架基础： Spring是一个开源的Java平台，它提供了全面的编程和配置模型，用于现代基于Java的企业的应用程序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

❀༊烟花易冷ღ

觉得博客写的不错就打赏一下吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值