Spring AOP + AspectJ annotation example
来源:互联网 发布:linux中vim如何退出 编辑:程序博客网 时间:2024/05/22 03:34
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
– Run before the method execution@After
– Run after the method returned a result@AfterReturning
– Run after the method returned a result, intercept the returned result as well.@AfterThrowing
– Run after the method throws an exception@Around
– Run around the method execution, combine all three advices above.
1. Directory Structure
See 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
<project ...> <properties> <spring.version>3.0.5.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <!-- Spring AOP + AspectJ --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.6.11</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.6.11</version> </dependency> </dependencies></project>
3. Spring Beans
Normal bean, with few methods, later intercept it via AspectJ annotation.
package com.mkyong.customer.bo;public interface CustomerBo { void addCustomer(); String addCustomerReturnValue(); void addCustomerThrowException() throws Exception; void addCustomerAround(String name);}
package com.mkyong.customer.bo.impl;import com.mkyong.customer.bo.CustomerBo;public class CustomerBoImpl implements CustomerBo { public void addCustomer(){ System.out.println("addCustomer() is running "); } public String addCustomerReturnValue(){ System.out.println("addCustomerReturnValue() is running "); return "abc"; } public void addCustomerThrowException() throws Exception { System.out.println("addCustomerThrowException() is running "); throw new Exception("Generic Error"); } public void addCustomerAround(String name){ System.out.println("addCustomerAround() is running, args : " + name); }}
4. Enable AspectJ
In Spring configuration file, put “<aop:aspectj-autoproxy />
“, and define your Aspect (interceptor) and normal bean.
File : Spring-Customer.xml
<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-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd "> <aop:aspectj-autoproxy /> <bean id="customerBo" class="com.mkyong.customer.bo.impl.CustomerBoImpl" /> <!-- Aspect --> <bean id="logAspect" class="com.mkyong.aspect.LoggingAspect" /></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.
File : LoggingAspect.java
package com.mkyong.aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;@Aspectpublic class LoggingAspect { @Before("execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("logBefore() is running!"); System.out.println("hijacked : " + joinPoint.getSignature().getName()); System.out.println("******"); }}
Run it
CustomerBo customer = (CustomerBo) appContext.getBean("customerBo"); customer.addCustomer();
Output
logBefore() is running!hijacked : addCustomer******addCustomer() is running
5. AspectJ @After
In below example, the logAfter()
method will be executed after the execution of customerBo
interface, addCustomer()
method.
File : LoggingAspect.java
package com.mkyong.aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.After;@Aspectpublic class LoggingAspect { @After("execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))") public void logAfter(JoinPoint joinPoint) { System.out.println("logAfter() is running!"); System.out.println("hijacked : " + joinPoint.getSignature().getName()); System.out.println("******"); }}
Run it
CustomerBo customer = (CustomerBo) appContext.getBean("customerBo"); customer.addCustomer();
Output
addCustomer() is running logAfter() is running!hijacked : 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
package com.mkyong.aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterReturning;@Aspectpublic class LoggingAspect { @AfterReturning( pointcut = "execution(* com.mkyong.customer.bo.CustomerBo.addCustomerReturnValue(..))", returning= "result") public void logAfterReturning(JoinPoint joinPoint, Object result) { System.out.println("logAfterReturning() is running!"); System.out.println("hijacked : " + joinPoint.getSignature().getName()); System.out.println("Method returned value is : " + result); System.out.println("******"); }}
Run it
CustomerBo customer = (CustomerBo) appContext.getBean("customerBo"); customer.addCustomerReturnValue();
Output
addCustomerReturnValue() is running logAfterReturning() is running!hijacked : addCustomerReturnValueMethod returned value is : abc******
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
package com.mkyong.aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterThrowing;@Aspectpublic class LoggingAspect { @AfterThrowing( pointcut = "execution(* com.mkyong.customer.bo.CustomerBo.addCustomerThrowException(..))", throwing= "error") public void logAfterThrowing(JoinPoint joinPoint, Throwable error) { System.out.println("logAfterThrowing() is running!"); System.out.println("hijacked : " + joinPoint.getSignature().getName()); System.out.println("Exception : " + error); System.out.println("******"); }}
Run it
CustomerBo customer = (CustomerBo) appContext.getBean("customerBo"); customer.addCustomerThrowException();
Output
addCustomerThrowException() is running logAfterThrowing() is running!hijacked : addCustomerThrowExceptionException : java.lang.Exception: Generic Error******Exception in thread "main" java.lang.Exception: Generic Error //...
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
package com.mkyong.aspect;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Around;@Aspectpublic class LoggingAspect { @Around("execution(* com.mkyong.customer.bo.CustomerBo.addCustomerAround(..))") public void logAround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("logAround() is running!"); System.out.println("hijacked method : " + joinPoint.getSignature().getName()); System.out.println("hijacked arguments : " + Arrays.toString(joinPoint.getArgs())); System.out.println("Around before is running!"); joinPoint.proceed(); //continue on the intercepted method System.out.println("Around after is running!"); System.out.println("******"); }}
Run it
CustomerBo customer = (CustomerBo) appContext.getBean("customerBo"); customer.addCustomerAround("mkyong");
Output
logAround() is running!hijacked method : addCustomerAroundhijacked arguments : [mkyong]Around before is running!addCustomerAround() is running, args : mkyongAround after is running!******
Conclusion
It’s always recommended to apply the least power AsjectJ annotation.
- Spring AOP + AspectJ Annotation Example
- Spring AOP + AspectJ Annotation Example
- Spring AOP + AspectJ Annotation Example
- spring aop + aspectj annotation example
- Spring AOP + AspectJ annotation example
- Spring AOP + AspectJ annotation example
- Spring AOP + AspectJ annotation example
- Spring AOP + AspectJ annotation
- Spring AspectJ Aop Annotation
- Spring AOP - AspectJ - @Before example
- Spring AOP - AspectJ - @After example
- Spring AOP - AspectJ - @AfterReturning example
- Spring AOP - AspectJ - @AfterThrowing example
- Spring AOP + AspectJ in XML configuration example
- Spring AOP + AspectJ in XML configuration example
- Spring基于annotation的AOP(AspectJ)
- Spring-AOP @AspectJ切点函数之@annotation()
- 【Spring 基础篇四】annotation+aspectj实现AOP
- android代码获取网站图标
- test3.10
- Oracle数据库的分页使用
- 移除父控件的所有子控件
- Java中的StringUtils类
- Spring AOP + AspectJ annotation example
- json格式化工具
- VB截取中英文混合字符串中若干半角单位长字串的函数
- flask环境
- 电脑开启自动启动程序,单任务启动程序。
- log4j + flume
- QT中监控全局键盘鼠标事件
- TCP三次握手和四次挥手
- 【设计模式】从菜鸟到大鸟之23个模式整体观