Spring AOP + AspectJ注释示例

最新推荐文章于 2024-08-12 16:47:32 发布
最新推荐文章于 2024-08-12 16:47:32 发布
阅读量115 收藏
点赞数
文章标签： java

在本教程中，我们向您展示如何将AspectJ注释与Spring AOP框架集成在一起。 简单来说，Spring AOP + AspectJ使您可以轻松地拦截方法。

常见的AspectJ注释：

  1. @Before –在方法执行之前运行
  2. @After –在方法返回结果之后运行
  3. @AfterReturning –在方法返回结果之后运行，也拦截返回的结果。
  4. @AfterThrowing –在方法引发异常之后运行
  5. @Around –运行方法执行，结合以上所有三个建议。

注意
对于没有AspectJ支持的Spring AOP，请阅读此内置Spring AOP示例 。

1.目录结构

请参阅本示例的目录结构。

directory structure of this example

2.项目依赖

要启用AspectJ中，你需要aspectjrt.jar，aspectjweaver.jar和弹簧aop.jar。 请参阅以下Maven pom.xml文件。

从Spring 2.0开始支持AspectJ
此示例使用的是Spring 3，但自Spring 2.0开始支持AspectJ功能。

档案：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.四季豆

普通bean，几乎没有方法，后来通过AspectJ注释拦截了它。 

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.启用AspectJ

在Spring配置文件中，放入“ <aop:aspectj-autoproxy /> ”，然后定义您的Aspect（拦截器）和普通bean。

文件：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 @之前

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

注意
AspectJ“切入点”用于声明将要拦截的方法，您应该参考此Spring AOP切入点指南以获取所支持的切入点表达式的完整列表。

文件：LoggingAspect.java 

package com.mkyong.aspect;

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

@Aspect
public 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("******");
	}

}

运行 

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

输出量 

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

5. AspectJ @之后

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

文件：LoggingAspect.java 

package com.mkyong.aspect;

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

@Aspect
public 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("******");

	}

}

运行 

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

输出量 

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

6. AspectJ @AfterReturning

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

要拦截返回的值，“ returning”属性（结果）的值必须与方法参数（结果）相同。

文件：LoggingAspect.java 

package com.mkyong.aspect;

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

@Aspect
public 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("******");

   }

}

运行 

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

输出量 

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

7. AspectJ @AfterReturning

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

文件：LoggingAspect.java 

package com.mkyong.aspect;

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

@Aspect
public 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("******");

    }
}

运行 

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
	//...

8. AspectJ @Around

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

文件：LoggingAspect.java 

package com.mkyong.aspect;

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

@Aspect
public 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("******");

   }
	
}

运行 

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

输出量 

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

结论

始终建议使用功耗最低的AsjectJ批注。 关于Spring的AspectJ的文章很长。 有关更多说明和示例，请访问下面的参考链接。

反注释还是使用JDK 1.4？
不用担心，AspectJ也支持XML配置，请阅读此Spring AOP + AspectJ XML示例 。

下载源代码

下载它– Spring3-AOP-AspectJ-Example.zip （8 KB）

参考文献

  1. AspectJ编程指南
  2. Spring AOP + AspectJ参考
标签：

翻译自: https://mkyong.com/spring3/spring-aop-aspectj-annotation-example/

cyan20115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringAOP+AspectJ
02-10
**Spring AOP与AspectJ详解** 在现代软件开发中，面向切面编程（Aspect-Oriented Programming，简称AOP）是一种强大的设计模式，它允许我们分离关注点，将横切关注点（如日志、事务管理、权限控制等）与核心业务...
基于AspectJ的简单AOP例子
qq_37054816的博客
09-08 154
基于XML的声明式Aspectj 目标类UserDao package com.ssm.aspectj; public interface UserDao { public void addUser(); public void deleteUser(); } package com.ssm.aspectj; public class UserDaoImpl implements ...
Spring的AOP和AspectJ 实现AOP
athga的博客
05-07 349
1、AOP 什么？ AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操...
Spring AOP AspectJ 代码实例
weixin_30344795的博客
03-10 100
本文参考来源 http://examples.javacodegeeks.com/enterprise-java/spring/aop/spring-aop-aspectj-example/http://oss.org.cn/ossdocs/framework/spring/zh-cn/aop.html 概念 面向方面编程 (AOP) 提供从另一个角度来考虑程序结构以...
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
AspectJ AOP 简单示例2
lihongwang435的专栏
04-28 438
转自 http://blog.sina.com.cn/s/blog_46d0362d0100mmzy.html 有时候调试一些程序会牵涉到第三方的类库，但由于它们都是以class或者jar形式发布的，不大可能改变其行为，所以不是特别方便。这个时候唯一可以利用的就是AOP的技术，常用的就是AspectJ 首先是几个概念： 1.aspect（层面） 2.pointcut（切入点） 3.advi
Spring AOP + AspectJ in XML 配置示例
04-03
这篇博客“Spring AOP + AspectJ in XML配置示例”旨在指导开发者如何在XML配置中实现Spring AOP和AspectJ的结合。 首先，我们需要理解AOP的基本概念。AOP通过将关注点（如日志、事务管理）与业务逻辑分离，提高了...
Spring AOP + AspectJ annotation example
04-03
在IT行业中，Spring框架是Java企业级应用开发的首选，而Spring AOP（面向切面编程）...在压缩包文件`Spring3Example`中，可能包含了一些关于Spring AOP和AspectJ注解的示例代码，这将有助于进一步理解和实践这些概念。
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
Spring AOP的AspectJ支持jar包
01-05
Spring AOP的AspectJ支持jar包； 包括： com.springsource.net.sf.cglib-2.2.0.jar com.srpingsource.org.aopalliance-1.0.0.jar com.srpingsource.org.aspectj.weaver-1.68.RELEASE.jar
AOP之使用AspectJ案例
不会写代码的丝丽
09-12 760
这篇文章作为自己学习笔记: 国内翻译教程AOP翻译过来 “面向切面”。如果非要用一句话来理解的话：”在程序编译或者运行时，在代码某处切入另一段代码”。AOP的出现是弥补OOM的不足。 作者：知乎用户 链接：https://www.zhihu.com/question/24863332/answer/48376158 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2677
Java面试篇（JVM相关专题）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 311
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 282
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 824
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
集合（1）
supercool7的博客
08-12 447
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
反射和注解
supercool7的博客
08-08 277
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
m0_75257168的博客
08-10 355
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 443
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 296
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值