Spring AOP + AspectJ Annotation Example

最新推荐文章于 2025-08-17 06:45:00 发布
转载 最新推荐文章于 2025-08-17 06:45:00 发布 · 1.1k 阅读 · 0
文章标签：

#Annotation #JavaEE #web开发 #Spring #Aspect

本文介绍如何在Spring框架中集成AspectJ注解实现方法拦截。通过具体示例展示了@Before、@After、@AfterReturning、@AfterThrowing及@Around等注解的使用方法。

原文地址：http://www.mkyong.com/spring3/spring-aop-aspectj-annotation-example/

In this tutorial, we show you how to integrate AspectJ annotation with Spring AOP framework. In simple, Spring AOP + AspectJ allow you to intercept method easily.

Common AspectJ annotations :

  1. @Before – Run before the method execution
  2. @After – Run after the method returned a result
  3. @AfterReturning – Run after the method returned a result, intercept the returned result as well.
  4. @AfterThrowing – Run after the method throws an exception
  5. @Around – Run around the method execution, combine all three advices above.
    1. Directory Structure

    See directory structure of this example.

    directory structure of this example
    2. Project Dependencies

    To enable AspectJ, you need aspectjrt.jar, aspectjweaver.jar and spring-aop.jar. See following Maven pom.xml file.

    AspectJ supported since Spring 2.0
    This example is using Spring 3, but the AspectJ features are supported since Spring 2.0.

    File : pom.xml

    [html]  view plain copy
    1. <project ...>  
    2.    
    3.     <properties>  
    4.         <spring.version>3.0.5.RELEASE</spring.version>  
    5.     </properties>  
    6.    
    7.     <dependencies>  
    8.    
    9.         <dependency>  
    10.             <groupId>org.springframework</groupId>  
    11.             <artifactId>spring-core</artifactId>  
    12.             <version>${spring.version}</version>  
    13.         </dependency>  
    14.    
    15.         <dependency>  
    16.             <groupId>org.springframework</groupId>  
    17.             <artifactId>spring-context</artifactId>  
    18.             <version>${spring.version}</version>  
    19.         </dependency>  
    20.    
    21.         <!-- Spring AOP + AspectJ -->  
    22.         <dependency>  
    23.             <groupId>org.springframework</groupId>  
    24.             <artifactId>spring-aop</artifactId>  
    25.             <version>${spring.version}</version>  
    26.         </dependency>  
    27.    
    28.         <dependency>  
    29.             <groupId>org.aspectj</groupId>  
    30.             <artifactId>aspectjrt</artifactId>  
    31.             <version>1.6.11</version>  
    32.         </dependency>  
    33.    
    34.         <dependency>  
    35.             <groupId>org.aspectj</groupId>  
    36.             <artifactId>aspectjweaver</artifactId>  
    37.             <version>1.6.11</version>  
    38.         </dependency>  
    39.    
    40.     </dependencies>  
    41. </project>  

    3. Spring Beans

    Normal bean, with few methods, later intercept it via AspectJ annotation.

    [java]  view plain copy
    1. package com.mkyong.customer.bo;  
    2.    
    3. public interface CustomerBo {  
    4.    
    5.     void addCustomer();  
    6.    
    7.     String addCustomerReturnValue();  
    8.    
    9.     void addCustomerThrowException() throws Exception;  
    10.    
    11.     void addCustomerAround(String name);  
    12. }  

    [java]  view plain copy
    1. package com.mkyong.customer.bo.impl;  
    2.    
    3. import com.mkyong.customer.bo.CustomerBo;  
    4.    
    5. public class CustomerBoImpl implements CustomerBo {  
    6.    
    7.     public void addCustomer(){  
    8.         System.out.println("addCustomer() is running ");  
    9.     }  
    10.    
    11.     public String addCustomerReturnValue(){  
    12.         System.out.println("addCustomerReturnValue() is running ");  
    13.         return "abc";  
    14.     }  
    15.    
    16.     public void addCustomerThrowException() throws Exception {  
    17.         System.out.println("addCustomerThrowException() is running ");  
    18.         throw new Exception("Generic Error");  
    19.     }  
    20.    
    21.     public void addCustomerAround(String name){  
    22.         System.out.println("addCustomerAround() is running, args : " + name);  
    23.     }  
    24. }  

    4. Enable AspectJ

    In Spring configuration file, put “<aop:aspectj-autoproxy />“, and define your Aspect (interceptor) and normal bean.

    File : Spring-Customer.xml

    [java]  view plain copy
    1. <beans xmlns="http://www.springframework.org/schema/beans"  
    2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    3.     xmlns:aop="http://www.springframework.org/schema/aop"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
    5.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
    6.     http://www.springframework.org/schema/aop   
    7.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">  
    8.    
    9.     <aop:aspectj-autoproxy />  
    10.    
    11.     <bean id="customerBo" class="com.mkyong.customer.bo.impl.CustomerBoImpl" />  
    12.    
    13.     <!-- Aspect -->  
    14.     <bean id="logAspect" class="com.mkyong.aspect.LoggingAspect" />  
    15.    
    16. </beans>  

    4. AspectJ @Before

    In below example, the logBefore() method will be executed before the execution of customerBo interface, addCustomer()method.

    Note
    AspectJ “pointcuts” is used to declare which method is going to intercept, and you should refer to this  Spring AOP pointcuts guide  for full list of supported pointcuts expressions.

    File : LoggingAspect.java
    [java]  view plain copy
    1. package com.mkyong.aspect;  
    2.    
    3. import org.aspectj.lang.JoinPoint;  
    4. import org.aspectj.lang.annotation.Aspect;  
    5. import org.aspectj.lang.annotation.Before;  
    6.    
    7. @Aspect  
    8. public class LoggingAspect {  
    9.    
    10.     @Before("execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))")  
    11.     public void logBefore(JoinPoint joinPoint) {  
    12.    
    13.         System.out.println("logBefore() is running!");  
    14.         System.out.println("hijacked : " + joinPoint.getSignature().getName());  
    15.         System.out.println("******");  
    16.     }  
    17.    
    18. }  

    Run it(applicationContext.xml)
    [java]  view plain copy
    1. public static void main(String args[]){  
    2.     ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");  
    3.     CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");  
    4.     customer.addCustomer();  
    5. }  

    5. AspectJ @After

    In below example, the logAfter() method will be executed after the execution of customerBo interface, addCustomer()method.

    File : LoggingAspect.java

    .
    [java]  view plain copy
    1. package com.mkyong.aspect;  
    2.    
    3. import org.aspectj.lang.JoinPoint;  
    4. import org.aspectj.lang.annotation.Aspect;  
    5. import org.aspectj.lang.annotation.After;  
    6.    
    7. @Aspect  
    8. public class LoggingAspect {  
    9.    
    10.     @After("execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))")  
    11.     public void logAfter(JoinPoint joinPoint) {  
    12.    
    13.         System.out.println("logAfter() is running!");  
    14.         System.out.println("hijacked : " + joinPoint.getSignature().getName());  
    15.         System.out.println("******");  
    16.    
    17.     }  
    18.    
    19. }  

    Run it
    [java]  view plain copy
    1. CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");  
    2. customer.addCustomer();  

    6. AspectJ @AfterReturning

    In below example, the logAfterReturning() method will be executed after the execution of customerBo interface,addCustomerReturnValue() method. In addition, you can intercept the returned value with the “returning” attribute.

    To intercept returned value, the value of the “returning” attribute (result) need to be same with the method parameter (result).

    File : LoggingAspect.java

    [java]  view plain copy
    1. package com.mkyong.aspect;  
    2.    
    3. import org.aspectj.lang.JoinPoint;  
    4. import org.aspectj.lang.annotation.Aspect;  
    5. import org.aspectj.lang.annotation.AfterReturning;  
    6.    
    7. @Aspect  
    8. public class LoggingAspect {  
    9.    
    10.    @AfterReturning(  
    11.       pointcut = "execution(* com.mkyong.customer.bo.CustomerBo.addCustomerReturnValue(..))",  
    12.       returning= "result")  
    13.    public void logAfterReturning(JoinPoint joinPoint, Object result) {  
    14.    
    15.     System.out.println("logAfterReturning() is running!");  
    16.     System.out.println("hijacked : " + joinPoint.getSignature().getName());  
    17.     System.out.println("Method returned value is : " + result);  
    18.     System.out.println("******");  
    19.    
    20.    }  
    21.    
    22. }  

    Run it
    [java]  view plain copy
    1. CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");  
    2. customer.addCustomerReturnValue();  

    7. AspectJ @AfterReturning

    In below example, the logAfterThrowing() method will be executed if the customerBo interface,addCustomerThrowException() method is throwing an exception.

    File : LoggingAspect.java

    [java]  view plain copy
    1. package com.mkyong.aspect;  
    2.    
    3. import org.aspectj.lang.JoinPoint;  
    4. import org.aspectj.lang.annotation.Aspect;  
    5. import org.aspectj.lang.annotation.AfterThrowing;  
    6.    
    7. @Aspect  
    8. public class LoggingAspect {  
    9.    
    10.    @AfterThrowing(  
    11.       pointcut = "execution(* com.mkyong.customer.bo.CustomerBo.addCustomerThrowException(..))",  
    12.       throwing= "error")  
    13.     public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {  
    14.    
    15.     System.out.println("logAfterThrowing() is running!");  
    16.     System.out.println("hijacked : " + joinPoint.getSignature().getName());  
    17.     System.out.println("Exception : " + error);  
    18.     System.out.println("******");  
    19.    
    20.     }  
    21. }  

    Run it
    [java]  view plain copy
    1. CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");  
    2. customer.addCustomerThrowException();  
    Output
    [java]  view plain copy
    1. addCustomerThrowException() is running   
    2. logAfterThrowing() is running!  
    3. hijacked : addCustomerThrowException  
    4. Exception : java.lang.Exception: Generic Error  
    5. ******  
    6. Exception in thread "main" java.lang.Exception: Generic Error  
    7.     //...  
    8. AspectJ @Around

    In below example, the logAround() method will be executed before the customerBo interface, addCustomerAround()method, and you have to define the “joinPoint.proceed();” to control when should the interceptor return the control to the original addCustomerAround() method.

    File : LoggingAspect.java
    [java]  view plain copy
    1. package com.mkyong.aspect;  
    2.    
    3. import org.aspectj.lang.ProceedingJoinPoint;  
    4. import org.aspectj.lang.annotation.Aspect;  
    5. import org.aspectj.lang.annotation.Around;  
    6.    
    7. @Aspect  
    8. public class LoggingAspect {  
    9.    
    10.    @Around("execution(* com.mkyong.customer.bo.CustomerBo.addCustomerAround(..))")  
    11.    public void logAround(ProceedingJoinPoint joinPoint) throws Throwable {  
    12.    
    13.     System.out.println("logAround() is running!");  
    14.     System.out.println("hijacked method : " + joinPoint.getSignature().getName());  
    15.     System.out.println("hijacked arguments : " + Arrays.toString(joinPoint.getArgs()));  
    16.    
    17.     System.out.println("Around before is running!");  
    18.     joinPoint.proceed(); //continue on the intercepted method  
    19.     System.out.println("Around after is running!");  
    20.    
    21.     System.out.println("******");  
    22.    
    23.    }  
    24.    
    25. }  

    Run it
    [java]  view plain copy
    1. CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");  
    2. customer.addCustomerAround("mkyong");  

    Output
    [java]  view plain copy
    1. logAround() is running!  
    2. hijacked method : addCustomerAround  
    3. hijacked arguments : [mkyong]  
    4. Around before is running!  
    5. addCustomerAround() is running, args : mkyong  
    6. Around after is running!  
    7. ******  
夯实Spring（三） | Spring Aop 与 AspectJ
qq_38425803的博客
11-02 593
前言          谈起spring，Aop当然是其中的重中之重。本文简要讲解Aop理论知识，以及根据demo着重讲解Aspectj的基本用法。spring Aop 的语法这里不作介绍。 Aop是什么？        Aop是面向切面编程，它通过动态代理的方式为程序添加统一的功能，集中解决一些公共问题。如日志处理，事务控制等等。  &n
Spring AOP的注解实现（自定义注解实现日志管理）
qq_41860765的博客
05-14 1271
AOP： Aspect Oriented Programming（⾯向方⾯编程）。是一种对某一类事情集中处理的思想。 Spring AOP： 就是对AOP思想的一种实现。引入依赖： 写AOP实现： 三、详解Spring AOP 3.1 Spring AOP 核心概念 Spring AOP 核心概念：切点，连接点，通知，切面。我们以上面的代码来介绍。切点：就是告诉程序哪些方法需要使用到接下来的功能。 上面的@Around注解的参数就是切点表达式。 连接点：满⾜切点表达式规则的⽅法，就是连接点。也就是可以AOP
Spring AOP + AspectJ annotation example
qq_26847293的博客
09-17 325
In this tutorial, we show you how to integrate AspectJ annotation with Spring AOP framework. In simple, Spring AOP + AspectJ allow you to intercept method easily.Common AspectJ annotations : @Before –
Spring AOP + AspectJ Annotation Example---reference
11-25 138
In this tutorial, we show you how to integrate AspectJ annotation with Spring AOP framework. In simple, Spring AOP + AspectJ allow you to intercept method easily. Common AspectJ annotations : ...
spring aop + aspectj annotation example
www.hohode.com
09-23 532
http://www.mkyong.com/spring3/spring-aop-aspectj-annotation-example/
Spring AOP 和 AspectJ的区别
一个public的class的博客
03-20 993
Spring AOP 是 Spring 框架内置的 AOP 实现方式，基于动态代理技术（JDK 动态代理或 CGLIB）。尽管 Spring AOP 和 AspectJ 是两种不同的 AOP 实现方式，但它们可以结合使用。Spring 提供了对 AspectJ 的支持，允许开发者在 Spring 应用中使用 AspectJ 的功能。Spring AOP 和 AspectJ 是两种常见的面向切面编程（AOP）实现方式，它们在设计目标、实现原理、功能特性等方面存在显著区别。
JavaEE AOP详解(从原理到实践 基于Spring AOP + AspectJ，附完整代码实例)
m0_73690328的博客
03-12 844
传统OOP编程中，重复的逻辑（如日志、事务、权限）会散落在各业务方法中，造成。将这些公共功能抽取成独立模块（切面），实现解耦。
Spring AOP + AspectJ注释示例
一名可爱的技术搬运工
05-26 177
在本教程中，我们向您展示如何将AspectJ注释与Spring AOP框架集成在一起。 简单来说，Spring AOP + AspectJ使您可以轻松地拦截方法。 常见的AspectJ注释： @Before –在方法执行之前运行 @After –在方法返回结果之后运行 @AfterReturning –在方法返回结果之后运行，也拦截返回的结果。 @AfterThrowing...
Spring AOP + AspectJ in XML configuration example
09-06 353
For those don’t like annotation or using JDK 1.4, you can use AspectJ in XML based instead.Review last customerBo interface again, with few methods, later you will learn how to intercept it via AspectJ
深入解析Spring AOP与AspectJ：对比与集成
zuiyuelong的博客
08-17 822
在Java企业级开发领域，面向切面编程(AOP)已成为解决横切关注点的关键技术。作为2025年最主流的两种AOP实现方案，Spring AOP和AspectJ各有其独特的设计理念和应用价值，并在最新技术演进中展现出新的应用场景。
Spring AOP与AspectJ注解实例解析
标题：“Spring AOP + AspectJ annotation example” 中蕴含的知识点涵盖了面向切面编程（AOP）的核心概念，以及如何在Spring框架中使用AspectJ注解进行切面编程。在深入探讨之前，我们首先需要对AOP和AspectJ有个...
9、Spring AOP 中 AspectJ 支持详解
vulkan6gpu的博客
07-19 123
本文详细介绍了 Spring AOP 中对 AspectJ 的支持，包括基于注解和 XML 配置的多种通知类型（@Before、@AfterReturning、@AfterThrowing、@After 和 @Around），并深入解析了切入点表达式的语法与使用场景。通过实际案例演示了如何利用 AOP 实现日志记录和性能监控功能。同时，文章还介绍了引入（Introduction）机制以及注意事项和最佳实践，帮助开发者更好地掌握 Spring AOP 与 AspectJ 的结合应用。
8、Spring AOP 中 AspectJ 的支持与应用
vulkan6gpu的博客
07-18 81
本文详细介绍了在 Spring AOP 中集成和使用 AspectJ 的方法与技巧，涵盖了 AspectJ 注解、切入点（Pointcut）定义、通知（Advice）类型、参数绑定等内容，并通过具体示例展示了不同类型通知的应用场景。文章还探讨了如何通过逻辑运算符组合切入点，实现更灵活的拦截逻辑，最后总结了使用 Spring AOP 和 AspectJ 的最佳实践，以帮助开发者提升代码的可维护性和可重用性。
eclipse-oniro-openharmony_kernel_common_modules_newip_43952_1767856292267.zip
01-08
eclipse-oniro-openharmony_kernel_common_modules_newip_43952_1767856292267.zip
含冰蓄冷空调的冷热电联供型微网多时间尺度优化调度（Matlab代码实现）
01-08
含冰蓄冷空调的冷热电联供型微网多时间尺度优化调度（Matlab代码实现）内容概要：本文介绍了含冰蓄冷空调的冷热电联供型微网多时间尺度优化调度的Matlab代码实现方法，重点围绕电力系统中考虑楼宇空间布局的集群划分与优化调度问题展开，涵盖冷、热、电多能协同供应与储能调节机制。通过多时间尺度（如日前、日内、实时）的优化模型，实现能源利用效率提升与运行成本降低的目标。文中还提及相关智能优化算法的应用，如改进灰狼算法、多目标粒子群算法等，用于解决复杂的非线性调度问题，并提供了完整的Matlab仿真资源与案例复现支持。; 适合人群：具备一定电力系统、能源工程或自动化背景的研究生、科研人员及从事微网优化、综合能源系统设计的工程技术人员，熟悉Matlab编程与基本优化算法者更佳。; 使用场景及目标：①用于科研项目中冷热电联供微网系统的建模与仿真；②支撑论文复现与算法改进，特别是在多时间尺度调度、需求响应、储能优化等领域；③辅助实际工程中微网能量管理系统的设计与决策分析； 阅读建议：建议结合文档提供的网盘资源进行代码实践，重点关注模型构建逻辑与算法实现细节，配合YALMIP+CPLEX等工具包调试优化问题，同时参考文中列举的SCI/EI论文复现案例深化理解。
cunweizhao_python-mysql_37488_1767856636664.zip
01-08
cunweizhao_python-mysql_37488_1767856636664.zip
AwesomeTkinter:漂亮的Tkinter小部件
01-08
先展示下效果 https://pan.quark.cn/s/a4b39357ea24 PyPI PyPI - Downloads Downloads last 6 month PyPI - License -- Official website: https://customtkinter.tomschimansky.com/ CustomTkinter is a python UI-library based on Tkinter, which provides new, modern and fully customizable widgets. They are created and used like normal Tkinter widgets and can also be used in combination with normal Tkinter elements. The widgets and the window colors either adapt to the system appearance or the manually set mode (&#39;light&#39;, &#39;dark&#39;), and all CustomTkinter widgets and windows support HighDPI scaling (Windows, macOS). With CustomTkinter you&#39;ll get a consistent and modern look across all desktop platforms (Windows, macOS, Linux). | on Windows 11 with dark mode ...
【FHSS信号识别】一种基于矩形滤波器的改进型卷积神经网络用于跳频扩频信号分类【附MATLAB代码】.zip
最新发布
01-08
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值