Spring整合SpringAOP（基于aspectj）

最新推荐文章于 2024-03-29 15:37:53 发布
最新推荐文章于 2024-03-29 15:37:53 发布
阅读量841 收藏 1
点赞数
分类专栏： # Spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JngKang/article/details/127611698
版权

Spring引入Spring AOP：面向切面编程（基于aspectj）

应用场景：环绕增强可以用来解决事务问题，前置/后置/返回值/异常增强可以用来添加日志处理

1、导包

 <!-- Spring AOP -->
 <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjrt</artifactId>
     <version>1.9.9.1</version>
 </dependency>
 <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjtools</artifactId>
     <version>1.9.9.1</version>
 </dependency>
 <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjweaver</artifactId>
     <version>1.9.9.1</version>
 </dependency>
 <dependency>
     <groupId>aopalliance</groupId>
     <artifactId>aopalliance</artifactId>
     <version>1.0</version>
 </dependency>
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aspects</artifactId>
     <version>5.3.18</version>
 </dependency>

2、在Spring配置文件中配置信息

 <!--使AspectJ注解起作用：为匹配的类自动生成代理对象-->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3、待增强类

接口

 public interface Calculator {
     int add(int a, int b);
     int sub(int a, int b);
     int div(int a, int b);
     int mut(int a, int b);
 }

实现类

 import org.springframework.stereotype.Component;
 ​
 @Component("calculator")
 public class CalculatorImpl implements Calculator {
 ​
     @Override
     public int add(int a, int b) {
         System.out.println("add方法被调用");
         return a + b;
     }
 ​
     @Override
     public int sub(int a, int b) {
         System.out.println("sub方法被调用");
         return a - b;
     }
 ​
     @Override
     public int div(int a, int b) {
         System.out.println("div方法被调用");
         return a / b;
     }
 ​
     @Override
     public int mut(int a, int b) {
         System.out.println("mut方法被调用");
         return a * b;
     }
 }

4、增强类

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.AfterThrowing;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.springframework.stereotype.Component;
 ​
 import java.util.Arrays;
 ​
 @Component  //为切面加入Spring自动扫描支持
 @Aspect  //加入AspectJ支持，声明类为切面
 public class LogAspect {
 ​
     /**
      * 前置增强
      */
     @Before("execution(public int com.xxx.demo.Calculator.*(int,int))")
     public void beforeMethod() {
         System.out.println("前置增强");
     }
 ​
     /**
      * 后置增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      */
     @After("execution(public int com.xxx.demo.Calculator.*(int,int))")
     public void afterMethod(JoinPoint joinPoint) {
         // 获取方法名称
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法传入的参数
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         System.out.println("后置增强");
     }
 ​
     /**
      * 返回增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      * @param result    获取该方法的返回值
      */
     @AfterReturning(value = "execution(public int com.xxx.demo.Calculator.*(int,int))", returning = "result")
     public void afterReturningMethod(JoinPoint joinPoint, int result) {
         // 获取方法名称
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法传入的参数
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         // 获取该方法执行的返回值
         System.out.println("方法返回值：" + result);
         System.out.println("返回增强");
     }
 ​
     /**
      * 异常增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      * @param ex        该方法所产生的异常
      */
     @AfterThrowing(value = "execution(public int com.xxx.demo.Calculator.*(int,int))", throwing = "ex")
     public void afterThrowingMethod(JoinPoint joinPoint, ArithmeticException ex) {
         // 获取方法抿成
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法所传入的返回值
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         // 获取该方法产生的异常
         System.out.print("方法产生的异常：" + ex);
         System.out.println("异常增强");
     }
 ​
     /**
      * 环绕增强
      *
      * @param pjp 可以通过pjp获取方法名称、获取传入的参数以及可以通过proceed调用目标方法
      * @return java.lang.Object 返回目标方法执行后的结果
      */
     @Around(value = "execution(public int com.xxx.demo.Calculator.*(int,int))")
     public Object AroundMethod(ProceedingJoinPoint pjp) {
         Object res = null;
         String methodName = pjp.getSignature().getName();
         Object[] args = pjp.getArgs();
         try {
             System.out.println("环绕增强-->前置");
             //调用目标方法
             res = pjp.proceed();
             System.out.println("返回值:" + res);
             System.out.println("环绕增强-->返回");
         } catch (Throwable throwable) {
             System.out.println("环绕增强-->异常");
             throw new RuntimeException(throwable);
         }
         System.out.println("环绕增强-->后置");
         return res;
     }
 }

5、测试

 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.stereotype.Component;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 ​
 import javax.annotation.Resource;
 ​
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration({"/spring.xml", "/mybatis.xml"})
 @Component
 public class DemoTest {
 ​
     @Resource
     private Calculator calculator;
 ​
     @Test
     void fun() {
         System.out.println(calculator.add(3, 2));
         System.out.println(calculator.sub(3, 2));
         System.out.println(calculator.div(3, 0));
         System.out.println(calculator.mut(3,2));
     }
 ​
 }

以下测试是对LogAspect.java中的增强方式依次单个或多个进行测试，单个时是将其他的增强方法注释掉

测试前置增强：

测试后置增强

测试返回增强

测试异常增强

测试正常环绕增强

测试异常环绕增强

异常时，环绕增强执行了环绕增强的前置增强和环绕增强的异常增强

所有增强均开始，测试执行顺序

无异常时，先执行环绕前置增强-->前置增强-->环绕增强调用方法-->返回增强-->后置增强-->环绕返回增强-->环绕后置增强

异常时，环绕前置增强-->前置增强-->环绕增强调用方法-->异常增强-->后置增强-->环绕异常增强

方式二：通过xml配置文件实现增强（不建议使用）

1、导入依赖，同上

2、在Spring配置文件中配置相关信息，同上

3、待增强类，同上

4、增强类

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 ​
 import java.util.Arrays;
 ​
 public class LogAspect2 {
 ​
     /**
      * 前置增强
      */
     public void beforeMethod() {
         System.out.println("前置增强");
     }
 ​
     /**
      * 后置增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      */
     public void afterMethod(JoinPoint joinPoint) {
         // 获取方法名称
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法传入的参数
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         System.out.println("后置增强");
     }
 ​
     /**
      * 返回增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      * @param result    获取该方法的返回值
      */
     public void afterReturningMethod(JoinPoint joinPoint, int result) {
         // 获取方法名称
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法传入的参数
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         // 获取该方法执行的返回值
         System.out.println("方法返回值：" + result);
         System.out.println("返回增强");
     }
 ​
     /**
      * 异常增强
      *
      * @param joinPoint 可以通过joinPoint获取所执行的方法以及该方法传入的参数
      * @param ex        该方法所产生的异常
      */
     public void afterThrowingMethod(JoinPoint joinPoint, ArithmeticException ex) {
         // 获取方法抿成
         String methodName = joinPoint.getSignature().getName();
         System.out.println("方法名称：" + methodName);
         // 获取该方法所传入的返回值
         Object[] args = joinPoint.getArgs();
         System.out.println("方法参数：" + Arrays.toString(args));
         // 获取该方法产生的异常
         System.out.print("方法产生的异常：" + ex);
         System.out.println("异常增强");
     }
 ​
     /**
      * 环绕增强
      *
      * @param pjp 可以通过pjp获取方法名称、获取传入的参数以及可以通过proceed调用目标方法
      * @return java.lang.Object 返回目标方法执行后的结果
      */
     public Object AroundMethod(ProceedingJoinPoint pjp) {
         Object res = null;
         String methodName = pjp.getSignature().getName();
         Object[] args = pjp.getArgs();
         try {
             System.out.println("环绕增强-->前置");
             //调用目标方法
             res = pjp.proceed();
             System.out.println("返回值:" + res);
             System.out.println("环绕增强-->返回");
         } catch (Throwable throwable) {
             System.out.println("环绕增强-->异常");
             throw new RuntimeException(throwable);
         }
         System.out.println("环绕增强-->后置");
         return res;
     }
 }

5、增强xml配置

 
<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns="http://www.springframework.org/schema/beans"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
 ​
     <bean class="com.xxx.demo.CalculatorImpl" id="calculator"></bean>
     <bean class="com.xxx.demo.LogAspect2" id="logAspect"></bean>
 ​
     <aop:config>
         <aop:pointcut id="pointcut"
                       expression="execution(public int com.xxx.demo.Calculator.*(int,int))"/>
         <aop:aspect ref="logAspect" order="1">
             <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
             <aop:after method="afterMethod" pointcut-ref="pointcut"/>
             <aop:after-returning method="afterReturningMethod" pointcut-ref="pointcut"
                                  returning="result"/>
             <aop:after-throwing method="afterThrowingMethod" pointcut-ref="pointcut"
                                 throwing="ex"/>
             <aop:around method="AroundMethod" pointcut-ref="pointcut"/>
         </aop:aspect>
     </aop:config>
 </beans>

6、测试

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.stereotype.Component;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import javax.annotation.Resource;

@ExtendWith(SpringExtension.class)
@ContextConfiguration({"/spring.xml", "/mybatis.xml", "/aspectj.xml"})
@Component
public class DemoTest2 {

    @Resource
    private Calculator calculator;

    @Test
    void fun() {
        //System.out.println(calculator.add(3, 2));
        //System.out.println(calculator.sub(3, 2));
        System.out.println(calculator.div(3, 0));
        //System.out.println(calculator.mut(3,2));
    }

}

JngKang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring.html
03-23
修改默认代理方法:<aop:aspectj-autoproxy proxy-target-class="true"/> 增强种类 前置通知 后置通知 异常通知 最终通知 环绕通知 注意:使用注解的方式,最终通知和后置通知顺序换了,建议使用环绕通知...
@aspect注解_Spring中基于注解@AspectJ的AOP实现
weixin_39762464的博客
11-27 312
@AspectJ 作为通过 Java 5 注释注释的普通的 Java 类，它指的是声明aspects 的一种风格。通过在基于架构的 XML 配置文件中包含以下元素，@AspectJ 支持是可用的。# 大致流程如下：(1) 首先利用注解声明一个Aspect：import org.aspectj.lang.annotation.Aspect;@Aspectpublic class AspectModu...
@Aspect 注解使用详解
热门推荐
fz13768884254的博客
10-30 22万+
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 在s...
spring AOP和AspectJ AOP的区别
最新发布
weixin_41828221的博客
03-29 1158
Spring AOP（Aspect-Oriented Programming）和AspectJ AOP都是实现面向切面编程（AOP）的技术，但它们在实现机制、语法、适用场景等方面存在一些区别。下面分别介绍两者的区别，并给出相应的示例。
Spring AOP技术（基于AspectJ）的Annotation开发
Switch的博客
02-07 1245
Spring AOP技术（基于AspectJ）的Annotation开发@(Spring)[aop, spring, xml, Spring, annotation, aspectJ]Spring AOP技术基于AspectJ的Annotation开发 Spring AOP的Annotation的开发 Spring的基于AspectJ的AOP的Annotation开发 第一步引入jar包 第二步创建
@Aspect注解使用
pany_2017的博客
05-12 987
@Aspect注解及表达式使用
aspectJ框架的使用
qq_49044908的博客
05-24 2706
切面三个关键的要素 1. 切面的功能代码:切面是干什么的 2. 切面的执行时间:使用通知(Advice)表示, 是在目标方法之前还是之后 3. 切面的执行位置:使用切入点(Pointcut)表示切面执行位置 从三要素使用aspectJ框架 1. 切面的功能代码, 这个由开发人员自己定义 2. 切面的执行时间, 在规范中叫Advice(通知, 增强) 注解表示 1. @Before 前置通知 ...
记录使用idea 开发Spring项目正常引入AOP后编译提示org.aspectj.lang.annotation.Aspect找不到问题解决
qq_41974570的博客
04-21 6790
问题：Spring项目正常引入AOP编译后提示org.aspectj.lang.annotation.Aspect类找不到 导入过程： 1.正常导入Aspect依赖包、maven库可以找到Aspect相关的依赖 2. Libraries中也可以找到Aspect相关的依赖 3.Spring配置文件中添加开启AOP注入标签： <aop:aspectj-autoproxy proxy-target-class="true"/> 5.上面的配置没有问题后启动项目...
记录使用idea开发Spring项目正常引入AOP后编译提示org.aspectj.lang.annotation.Aspect报错
weixin_54319871的博客
05-15 922
原本我的版本不是1.9.7,原来的是比这个更低的版本。这个项目是我过了好几天才重新打开运行的，应该是我中途增加了什么依赖，但是我确定我是没有增加的。因为版本低，导致org.aspectj依赖加载不上。1、在pom.xml里面查看报错的依赖（版本原来是1.6.8，这个版本我的会报错，1.9.7是我换了之后没有再报错的）2、在pom.xml里面导入1.9.7版本的依赖，重新加载。以上是我运到该类问题的解决方法，希望能帮到各位哦！，找到对应的依赖，把版本低的依赖删除。3、再次运行，就可以重新登录了。
AspectJ 使用介绍
weixin_43785662的博客
12-27 1949
文章目录AspectJ 使用介绍Compile-Time WeavingPost-Compile WeavingLoad-Time Weaving小结 上一篇文章，我们介绍了 Spring AOP 的各种用法，包括随着 Spring 的演进而发展出来的几种配置方式。 但是我们始终没有使用到 AspectJ，即使是在基于注解的 @AspectJ 的配置方式中，Spring 也仅仅是使用了 AspectJ 包中的一些注解而已，并没有依赖于 AspectJ 实现具体的功能。 本文将介绍使用 AspectJ，介绍
import org.aspectj.lang.JoinPoint接口找不到，系统检测爆红
weixin_42306552的博客
07-19 5632
错误代码位置 package com.xy.aop; import org.aspectj.lang.JoinPoint; public class AspectJAop { //实现五个增强通知的方法 public void beforeHandler(JoinPoint jp){ } public void afterHandler(JoinPoint jp,Object ret){ } public void af
Spring笔记（面试题）md
08-15
9.spring配置文件的整合 10.面向切面编程AOP 11.手写AOP框架 12.Spring支持的AOP的实现 13.AOP常用的术语 14.什么是AspectJ框架 15.AspectJ常见通知类型 16.AspectJ 的切入点表达式(掌握) 17.AspectJ的前置通知@...
Spring框架知识点（二）
10-24
1.spring的bean管理（注解） （1）使用注解创建对象 （2）使用注解注入属性 （3）Xml和注解方式混合使用 2.AOP ...3.spring的aop操作（基于aspectj的xml方式） 4.Log4j介绍 5.Spring整合web项目演示
spring的思维导图
07-25
主要优spring概念、spring的ioc控制反转、spring的di依赖注入、spring的aop（手动aop、半自动aop、传统aop、基于aspectj的aop）、事务管理(事务的概念、事务的四大特征、事务的隔离界别、事务的引发的问题)、spring...
spring4_day03讲义2
08-03
使用`<aop:aspectj-autoproxy/>`开启基于注解的AOP代理，让Spring自动识别并处理带有AspectJ注解的类。 **7. AspectJ注解介绍** - `@Aspect`：标记切面类。 - `@Before`：前置通知，在目标方法执行前执行。 - `@...
Spring 之AOP AspectJ切入点语法详解（最全面、最详细。）
zhengchao1991的博客
11-29 9万+
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹...
解决报错之org.aspectj.lang不存在
m0_64803878的博客
09-03 3113
可以右击项目的根目录中的pom.xml文件，选择Unlink并再次加载Maven项目。例如，可检查是否存在org.aspectj.lang.annotation.Around这个类的相关jar包。引用:java错误-java.lang.ClassNotFoundException: org.aspectj.lang.annotation.Around。总结起来，解决org.aspectj.lang不存在的问题，可以先检查依赖配置，然后确保引入了正确的jar包，最后可以尝试重新加载Maven项目。
Spring系列--AOP
qq_43404873的博客
11-17 658
AOP简介 什么是AOP AOP的全称是 Aspect-Oriented Programming,即面向切面编程。在传统的业务处理代码中，通常都会进行事务处理、日志记录等。虽然使用OOP(面向对象编程)可以通过组合或继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），相同的代码仍然会分散到各个方法中。如果想要关闭某个功能，或者对其进行修改，就必须修改所有相关方法。 为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时再将这些提
AspectJ中的org.aspectj.lang.JoinPoint接口的主要方法及使用
Daz_M的博客
03-06 8411
AspectJ 使用 org.aspectj.lang.JoinPoint 接口表示目标类连接点对象，如果是环绕增强，则使用 org.aspectj.lang.ProceedingJoinPoint 表示连接点对象，ProceedingJoinPoint 类是 JoinPoint 的子接口。 (1) JoinPoint 接口的主要方法： java.lang.Object[] getArg...
spring aop 和 AspectJ aop 有什么不同
02-27
Spring AOP和AspectJ AOP是两种不同的AOP面向切面编程）实现方式。 1. Spring AOP是Spring框架提供的一种轻量级AOP实现，它基于代理模式来实现AOP。Spring AOP只支持方法级别的连接点（Join Point），并且只能在Spring管理的Bean上应用切面。它使用动态代理技术，在运行时生成代理对象，并将切面逻辑织入到目标对象的方法中。 2. AspectJ AOP是一个独立的AOP框架，它提供了更强大和灵活的AOP功能。AspectJ AOP支持更多的连接点类型，包括方法、构造函数、字段等，可以在任何Java类上应用切面。它使用静态织入技术，在编译时或者类加载时将切面逻辑织入到目标类中。 因此，主要的不同点如下： - 连接点支持：Spring AOP只支持方法级别的连接点，而AspectJ AOP支持更多类型的连接点。 - 织入方式：Spring AOP使用动态代理，在运行时生成代理对象并织入切面逻辑；AspectJ AOP使用静态织入，在编译时或者类加载时将切面逻辑织入目标类。 - 依赖关系：Spring AOP依赖于Spring框架，只能在Spring管理的Bean上应用切面；AspectJ AOP是一个独立的框架，可以在任何Java类上应用切面。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值