Spring AOP+AspectJ注解实例

最新推荐文章于 2022-12-14 22:14:13 发布
最新推荐文章于 2022-12-14 22:14:13 发布
阅读量324 收藏 1
点赞数 2
分类专栏： Java Spring框架 文章标签： Spring AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34045444/article/details/84838227
版权

Spring AOP+AspectJ注解实例

文章目录


本文展示如何将AspectJ注解集成到Spring AOP框架。在这个Spring AOP+ AspectJ 示例中，让您轻松实现拦截方法。

常见AspectJ的注解：

  1. @Before – 方法执行前运行
  2. @After – 运行在方法返回结果后
  3. @AfterReturning – 运行在方法返回一个结果后，在拦截器返回结果。
  4. @AfterThrowing – 运行方法在抛出异常后，
  5. @Around – 围绕方法执行运行，结合以上这三个通知。

注意

Spring AOP 中没有 AspectJ 支持，请阅读前文AOP面向切面编程。

1. 启用AspectJ

在 Spring 配置文件，把“<aop:aspectj-autoproxy />”，并定义Aspect(拦截)和普通的bean。

File : applicationContext.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.myprj.customer.bo.impl.CustomerBoImpl" />

	<!-- Aspect -->
	<bean id="logAspect" class="com.myprj.aspect.LoggingAspect" />

</beans>

2. AspectJ @Before

在下面例子中，logBefore()方法将在 customerBo接口的 addCustomer()方法的执行之前被执行。

AspectJ的“切入点”是用来声明哪种方法将被拦截]，支持切入点表达式的完整列表。

File : LoggingAspect.java

package com.myprj.aspect;

import org.aspectj.lang.Joinmyprj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

	@Before("execution(* com.myprj.customer.bo.CustomerBo.addCustomer(..))")
	public void logBefore(Joinmyprj joinmyprj) {

		System.out.println("logBefore() is running!");
		System.out.println("hijacked : " + joinmyprj.getSignature().getName());
		System.out.println("******");
	}

}

运行

CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");
customer.addCustomer();

输出结果

logBefore() is running!
hijacked : addCustomer
******
addCustomer() is running

3. AspectJ @After

在下面例子中，logAfter()方法将在 customerBo 接口的 addCustomer()方法的执行之后执行。

File : LoggingAspect.java

package com.myprj.aspect;

import org.aspectj.lang.Joinmyprj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;

@Aspect
public class LoggingAspect {

	@After("execution(* com.myprj.customer.bo.CustomerBo.addCustomer(..))")
	public void logAfter(Joinmyprj joinmyprj) {

		System.out.println("logAfter() is running!");
		System.out.println("hijacked : " + joinmyprj.getSignature().getName());
		System.out.println("******");

	}

}

运行它

CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");
customer.addCustomer();

输出结果

addCustomer() is running 
logAfter() is running!
hijacked : addCustomer
******

4. AspectJ @AfterReturning

在下面例子中，logAfterReturning()方法将在 customerBo 接口的addCustomerReturnValue()方法执行之后执行。此外，还可以截取返回的值使用“returning”属性。

要截取返回的值，对“returning”属性(结果)的值必须用相同的方法参数(结果)。

File : LoggingAspect.java

package com.myprj.aspect;

import org.aspectj.lang.Joinmyprj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class LoggingAspect {

   @AfterReturning(
      pointcut = "execution(* com.myprj.customer.bo.CustomerBo.addCustomerReturnValue(..))",
      returning= "result")
   public void logAfterReturning(Joinmyprj joinmyprj, Object result) {

	System.out.println("logAfterReturning() is running!");
	System.out.println("hijacked : " + joinmyprj.getSignature().getName());
	System.out.println("Method returned value is : " + result);
	System.out.println("******");
   }
}

运行它

CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");
	customer.addCustomerReturnValue();

输出结果

addCustomerReturnValue() is running 
logAfterReturning() is running!
hijacked : addCustomerReturnValue
Method returned value is : abc
******

5. AspectJ @AfterReturning

在下面的例子中，如果 customerBo 接口的addCustomerThrowException()方法抛出异常logAfterThrowing()方法将被执行。

File : LoggingAspect.java

package com.myprj.aspect;

import org.aspectj.lang.Joinmyprj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class LoggingAspect {

   @AfterThrowing(
      pointcut = "execution(* com.myprj.customer.bo.CustomerBo.addCustomerThrowException(..))",
      throwing= "error")
    public void logAfterThrowing(Joinmyprj joinmyprj, Throwable error) {

	System.out.println("logAfterThrowing() is running!");
	System.out.println("hijacked : " + joinmyprj.getSignature().getName());
	System.out.println("Exception : " + error);
	System.out.println("******");

    }
}

运行它

CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");
customer.addCustomerThrowException();

输出结果

addCustomerThrowException() is running 
logAfterThrowing() is running!
hijacked : addCustomerThrowException
Exception : java.lang.Exception: Generic Error
******
Exception in thread "main" java.lang.Exception: Generic Error
	//...

6. AspectJ @Around

在下面例子中，logAround()方法将在customerBo接口的addCustomerAround()方法执行之前执行， 必须定义“joinmyprj.proceed();” 控制何时拦截器返回控制到原来的addCustomerAround()方法。

File : LoggingAspect.java

package com.myprj.aspect;

import org.aspectj.lang.ProceedingJoinmyprj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;

@Aspect
public class LoggingAspect {

   @Around("execution(* com.myprj.customer.bo.CustomerBo.addCustomerAround(..))")
   public void logAround(ProceedingJoinmyprj joinmyprj) throws Throwable {

	System.out.println("logAround() is running!");
	System.out.println("hijacked method : " + joinmyprj.getSignature().getName());
	System.out.println("hijacked arguments : " + Arrays.toString(joinmyprj.getArgs()));
		
	System.out.println("Around before is running!");
	joinmyprj.proceed(); //continue on the intercepted method
	System.out.println("Around after is running!");
		
	System.out.println("******");

   }
	
}

运行它

CustomerBo customer = (CustomerBo) appContext.getBean("customerBo");
customer.addCustomerAround("myprj");

输出结果

logAround() is running!
hijacked method : addCustomerAround
hijacked arguments : [myprj]
Around before is running!
addCustomerAround() is running, args : myprj
Around after is running!
******

总结

如今总是建议采用最少 AspectJ 注解。这是关于Spring AspectJ 的一篇相当长的文章。进一步的解释和例子，请访问下面的参考链接。

Spring AOP+AspectJ在XML配置实例

在下文中，我们将向你展示如何转换上文中 Spring AOP+AspectJ注解转成基于XML的配置。

对于那些不喜欢注释，使用JDK1.4，则可以基于XML，而不使用 AspectJ。

完整的 XML 实例

查看完整的基于XML的 AspectJ 配置文件。

<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.myprj.customer.bo.impl.CustomerBoImpl" />

<!-- Aspect -->
<bean id="logAspect" class="com.myprj.aspect.LoggingAspect" />

<aop:config>

  <aop:aspect id="aspectLoggging" ref="logAspect">

    <!-- @Before -->
    <aop:pointcut id="pointCutBefore"
      expression="execution(* com.myprj.customer.bo.CustomerBo.addCustomer(..))" />

    <aop:before method="logBefore" pointcut-ref="pointCutBefore" />

    <!-- @After -->
    <aop:pointcut id="pointCutAfter"
       expression="execution(* com.myprj.customer.bo.CustomerBo.addCustomer(..))" />

    <aop:after method="logAfter" pointcut-ref="pointCutAfter" />

    <!-- @AfterReturning -->
    <aop:pointcut id="pointCutAfterReturning"
       expression="execution(* com.myprj.customer.bo.CustomerBo.addCustomerReturnValue(..))" />

    <aop:after-returning method="logAfterReturning"
      returning="result" pointcut-ref="pointCutAfterReturning" />

    <!-- @AfterThrowing -->
    <aop:pointcut id="pointCutAfterThrowing"
      expression="execution(* com.myprj.customer.bo.CustomerBo.addCustomerThrowException(..))" />

    <aop:after-throwing method="logAfterThrowing"
      throwing="error" pointcut-ref="pointCutAfterThrowing" />

    <!-- @Around -->
    <aop:pointcut id="pointCutAround"
      expression="execution(* com.myprj.customer.bo.CustomerBo.addCustomerAround(..))" />

    <aop:around method="logAround" pointcut-ref="pointCutAround" />

  </aop:aspect>

</aop:config>

</beans>
JankoWilliam
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP+AspectJ
02-10
虽然Spring AOP提供了方便的注解式编程，但有时我们需要更复杂的切入点表达式或者更灵活的控制，这时AspectJ就派上用场了。AspectJ是一个独立的AOP框架，它的切入点表达式更为强大，支持类型匹配、方法参数匹配等。 ...
详解Spring Aop实例之AspectJ注解配置
08-30
在本篇文章中，我们将重点讨论如何使用AspectJ注解在Spring AOP中配置切面。AspectJ注解提供了更简洁、更直观的方式来声明切点(Pointcut)和通知(Advice)。 首先，我们需要了解`@Aspect`注解。这个注解用于标记一个...
java spring aop实例_Spring AOP+AspectJ注解实例
weixin_39669761的博客
02-24 118
常见AspectJ的注解：@Before–方法执行前运行@After–运行在方法返回结果后@AfterReturning–运行在方法返回一个结果后，在拦截器返回结果。@AfterThrowing–运行方法在抛出异常后，@Around–围绕方法执行运行，结合以上这三个通知。注意SpringAOP 中没有 AspectJ 支持，请阅读内置 SpringAOP 例子。1. 目录...
Spring AOP + AspectJ in XML configuration example
09-06 300
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
SpringAOP和AspectJ详解
weixin_38944107的博客
09-21 568
对Spring框架中面向切面编程进行深度解剖。 介绍了面向切面编程思想， 阐述了OOP和AOP的区别， 列举了Proxy和cglib动态代理的实例， 分别对AOP和AspectJ进行了详细的阐述
SpringAOP的Aspectj方式*
wyy的博客
05-28 172
SpringAOP的Aspectj介绍 问题: 目前我们已经能够使用SpringAOP的SchemaBased方式来实现功能扩展。在使用SchemaBased方式实现功能扩展时，发现一个扩展代码就需要声明对应的实现了指定的接口的类，这样造成代码的结构体系过于繁杂。一个通知一个类。 解决: 在一个类中声明所有的通知方法。这样又会造成Spring容器无法区分该类中的方法那些是前置，那些是后置，那些是环绕，那些是异常了，怎么办？在配置文件中的切面配置中，指明哪些方法是前置，哪些是后置即可。 实现: Sp
Spring AOP @AspectJ 入门实例
04-18
本实例将带你深入理解并实践Spring AOP与@AspectJ的结合使用。 首先，了解AOP的基本概念。面向切面编程是一种编程范式，它允许程序员定义“切面”，即跨越多个对象的行为或责任。这些切面可以包含业务逻辑、日志、...
spring aop注解配置代码实例
08-26
本文将深入探讨Spring AOP的注解配置，并通过具体的代码实例来阐述其使用方法。 首先，Spring AOP的核心概念包括切面（Aspect）、连接点（Join Point）、通知（Advice）和代理（Proxy）。在注解配置中，我们主要...
Spring AOP 基于注解详解及实例代码
01-08
Spring AOP 基于注解详解及实例代码 1.启用spring对@AspectJ注解的支持: <beans xmlns:aop=http://www.springframework.org/schema/aop...> <!--启动支持--> <aop> 也可以配置...
Spring使用AOP的方式配合注解完成接口操作日志记录
Johnson_7的博客
12-14 428
Spring使用AOP的方式配合注解完成接口操作日志记录
基于注解的Spring AOP的配置和使用
05-27 283
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。 我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(也即
关于Execution 表达式
Leon_Jinhai_Sun的博客
11-10 320
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) modifiers-pattern：方法的操作权限 ret-type-pattern：返回值【必填】 declaring-type-pattern：方法所在的包 name-pattern：方法名【必填】 parm-pattern：参数名 throws-pattern：.
Spring之—— AspectJ AOP 完整示例
冰河的专栏
11-09 5806
这里我们用一个完整的例子演示spring aspectj aop的使用。 首先新建一个maven项目，在项目的pom.xml中添加spring aop相关的依赖项： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schem
oxygen 文档的生成和管理
cherry 的专栏
06-14 1164
http://www.cocoachina.com/ios/20150629/12298.html http://www.stack.nl/~dimitri/doxygen/manual/docblocks.html
SpringAop与AspectJ的联系与区别
热门推荐
yzgyjyw的博客
05-19 1万+
SpringAop与AspectJ的联系与区别区别AspectJAspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。spring aopSpring提供了四种类型的Aop支持 * 基于经典的SpringAOP * 纯POJO切面 * @ASpectJ注解驱动的切面 * 注入式Asp
Java Web工程中的web.xml配置文件
sinat_34045444的博客
12-18 8674
Java Web工程中的web.xml配置文件 前言 1. xml文件 xml文件：Extentsible Markup Language即可扩展标记语言，是用来定义其它语言的一种元语言，其前身是SGML(标准通用标记语言)。xml文件是互联网数据传输的重要工具，因为不受编程语言和操作系统的限制，所以可以跨越互联网的任何平台，非常适合Web传输。XML提供统一的方法来描述和交换独立于应用程序或供应...
Java操作MongoDB数据库CRUD（增删查改）
sinat_34045444的博客
12-01 6463
Java操作MongoDB数据库CRUD（增删查改） 借助mongo-java-driver包，对MongoDB数据库的集合（DataTable）及文档（BSON对象数据）进行增删查改操作。本文的核心在于查询操作，善用mongo-java-driver包下的Iterable迭代器、fing()方法、aggregate()方法，理解Document对象映射BSON对象的底层实现，可完成类似窗口命令行...
Spring xml 配置详解
sinat_34045444的博客
12-19 1948
Spring xml 配置详解 前言 ​ 我们使用的Spring框架作为Bean的管理容器，其最经典最基础的Bean配置方式就是纯XML配置，这样做使得结构清晰明了，适合大型项目使用。Spring的XML配置虽然很繁琐，而且存在简洁的注解方式，但读懂XML配置文件对我们来说依然很重要，尚且对于老系统维护必不可少的面对XML配置。 ​ Spring的xml配置文件是其IOC容器启动时传入的重要配置文...
spring aspectj 注解实例 生成唯一ID
最新发布
04-24
Spring AspectJ 注解可以通过 @Aspect 注解和 @Around 注解来实现生成唯一ID的功能。其中，@Aspect 注解用于定义切面，@Around 注解用于定义通知，通知则是实现具体业务逻辑的类方法。 以下是一个示例代码： 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值