微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Spring AOP 实现方式

分类：Java作者：mrathena原文地址

博文目录

文章目录

AspectJ

  • 定义了切面表达式的语法和解析机制
  • 提供了强大的织入工具

它是通过织入的方式：直接将切面在【编译时、后】或【JVM加载的时候】进行织入到.class代码中。百度相关示例

Spring AOP

目前 Spring AOP 一共有三种配置方式

  • Spring 1.2 基于接口的配置：最早的 Spring AOP 是完全基于几个接口的，MethodBeforeAdvice,AfterReturningAdvice,MethodInterceptor 等。
  • Spring 2.0 schema-based 配置：Spring 2.0 以后使用 XML 的方式来配置，使用 命名空间
  • Spring 2.0 @AspectJ 配置：使用注解的方式来配置，这种方式最方便

注意: AspectJ 是 AOP 的实现,但不是 Spring AOP 的实现

使用如下的 Calculate 计算类来演示

package com.mrathena.aop.usage;

public interface Calculate {
	int add(int a, int b);
	int subtract(int a, int b);
	int multiply(int a, int b);
	int divide(int a, int b);
}

package com.mrathena.aop.usage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CalculateImpl implements Calculate {
	private static final Logger log = LoggerFactory.getLogger(CalculateImpl.class);
	@Override
	public int add(int a, int b) {
		log.info("CalculateImpl.add");
		return a + b;
	}
	@Override
	public int subtract(int a, int b) {
		log.info("CalculateImpl.subtract");
		return a - b;
	}
	@Override
	public int multiply(int a, int b) {
		log.info("CalculateImpl.multiply");
		return a * b;
	}
	@Override
	public int divide(int a, int b) {
		log.info("CalculateImpl.divide");
		return a / b;
	}
}

基于接口

public class CalculateMethodBeforeAdvice implements MethodBeforeAdvice {
	private static final Logger log = LoggerFactory.getLogger(CalculateMethodBeforeAdvice.class);
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		log.info("{} - CalculateMethodBeforeAdvice.before", getClass());
	}
}

public class CalculateAfterReturningAdvice implements AfterReturningAdvice {
	private static final Logger log = LoggerFactory.getLogger(CalculateAfterReturningAdvice.class);
	@Override
	public void afterReturning(Object returnValue, Method method, Object target) throws Throwable {
		log.info("{} - CalculateAfterReturningAdvice.afterReturning", getClass());
	}
}

/**
 * Interceptor 也是一个 Advice
 * interface MethodInterceptor extends Interceptor
 * interface Interceptor extends Advice
 */
public class CalculateMethodInterceptor implements MethodInterceptor {
	private static final Logger log = LoggerFactory.getLogger(CalculateMethodInterceptor.class);
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object result;
		try {
			log.info("CalculateMethodInterceptor.invoke.before");
			result = invocation.proceed();
			log.info("CalculateMethodInterceptor.invoke.afterReturning");
			return result;
		} catch (Throwable cause) {
			log.info("CalculateMethodInterceptor.invoke.afterThrowing");
			throw new RuntimeException(cause);
		} finally {
			log.info("CalculateMethodInterceptor.invoke.after");
		}
	}
}

Advice 方式

指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public CalculateAfterReturningAdvice calculateAfterReturningAdvice() {
		return new CalculateAfterReturningAdvice();
	}

	@Bean
	public Proxyfactorybean calculateProxy() {
		// 需要通过 Proxyfactorybean 来生产 代理 Calculate
		Proxyfactorybean factorybean = new Proxyfactorybean();
		// 设置拦截链名字(有先后顺序),可以是 advice,也可以是 interceptor(本质上也是 advice),也可以是 advisor
		factorybean.setInterceptorNames("calculateMethodBeforeAdvice", "calculateAfterReturningAdvice");
		factorybean.setTarget(calculate());
		return factorybean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:33:06.937 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:33:06.937 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add
16:33:06.937 [main] INFO com.mrathena.aop.usage.基于接口.CalculateAfterReturningAdvice - CalculateAfterReturningAdvice.afterReturning

16:33:06.938 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:33:06.938 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodInterceptor calculateMethodInterceptor() {
		return new CalculateMethodInterceptor();
	}

	@Bean
	public Proxyfactorybean calculateProxy() {
		// 需要通过 Proxyfactorybean 来生产 代理 Calculate
		Proxyfactorybean factorybean = new Proxyfactorybean();
		// 设置拦截链名字(有先后顺序),也可以是 advisor
		factorybean.setInterceptorNames("calculateMethodInterceptor");
		factorybean.setTarget(calculate());
		return factorybean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", 0);
	}

}

16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.before
16:36:33.083 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add
16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.afterReturning
16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.after

16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.before
16:36:33.084 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.afterThrowing
16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.after
Exception in thread "main" java.lang.RuntimeException: java.lang.ArithmeticException: / by zero

Advisor 方式

Advice: 指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

Advisor: 扩展了 Advice. 指定某个 Bean 的 指定某些方法,使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public NameMatchMethodpointcutAdvisor calculateNameMatchMethodpointcutAdvisor() {
		NameMatchMethodpointcutAdvisor advisor = new NameMatchMethodpointcutAdvisor();
		// 通知(Advice)  ：是我们的通知类
		// 通知者(Advisor)：是经过包装后的细粒度控制方式。
		// Advisor 持有 Advice 和 某个 pointcut
		advisor.setAdvice(calculateMethodBeforeAdvice());
		advisor.setMappednames("add", "subtract");
		return advisor;
	}

	@Bean
	public Proxyfactorybean calculateProxy() {
		Proxyfactorybean factorybean = new Proxyfactorybean();
		// 设置拦截链名字(有先后顺序),也可以是 advisor
		factorybean.setInterceptorNames("calculateNameMatchMethodpointcutAdvisor");
		factorybean.setTarget(calculate());
		return factorybean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", 2);
		System.out.println();
		bean.subtract(1, 2);
		System.out.println();
		bean.multiply(1, 0);
	}

}

16:39:04.690 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:39:04.690 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add

16:39:04.694 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.subtract

16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply

16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

AutoproxyCreator 方式

Advice: 指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

Advisor: 扩展了 Advice. 指定某个 Bean 的 指定某些方法,使用指定的某些 Advice 做增强

AutoproxyCreator: 扩展了 Advisor. 指定某些 Bean 的 某些方法,使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public NameMatchMethodpointcutAdvisor calculateNameMatchMethodpointcutAdvisor() {
		NameMatchMethodpointcutAdvisor advisor = new NameMatchMethodpointcutAdvisor();
		// 通知(Advice)  ：是我们的通知类
		// 通知者(Advisor)：是经过包装后的细粒度控制方式。
		// advisor 持有 advice 和 某个 pointcut
		// advisor 负责决定拦截哪些方法,advice 定义拦截后的逻辑
		advisor.setAdvice(calculateMethodBeforeAdvice());
		advisor.setMappednames("add", "subtract");
		return advisor;
	}

	@Bean
	public RegexpMethodpointcutAdvisor calculateRegexpMethodpointcutAdvisor() {
		RegexpMethodpointcutAdvisor regexpMethodpointcutAdvisor = new RegexpMethodpointcutAdvisor();
		regexpMethodpointcutAdvisor.setAdvice(calculateMethodBeforeAdvice());
		regexpMethodpointcutAdvisor.setPatterns("com.mrathena.aop.usage.CalculateImpl.add", "com.mrathena.aop.usage.CalculateImpl.subtract");
		return regexpMethodpointcutAdvisor;
	}

	/**
	 * BeanNameAutoproxyCreator 和 DefaultAdvisorAutoproxyCreator 二者选一个留下
	 * 需要指定 BeanNames 和 InterceptorNames(advice,interceptor,advisor)
	 */
	@Bean
	public BeanNameAutoproxyCreator calculateBeanNameAutoproxyCreator() {
		BeanNameAutoproxyCreator beanNameAutoproxyCreator = new BeanNameAutoproxyCreator();
		// 设置要创建代理的那些Bean的名字
		beanNameAutoproxyCreator.setBeanNames("calc*");
		// 设置拦截链名字(有先后顺序),也可以是 advisor
		// 拦截器使用 advice,作用于所有方法
		beanNameAutoproxyCreator.setInterceptorNames("calculateMethodBeforeAdvice");
		// 拦截器使用 advisor,作用于指定方法
		beanNameAutoproxyCreator.setInterceptorNames("calculateRegexpMethodpointcutAdvisor", "calculateNameMatchMethodpointcutAdvisor");
		beanNameAutoproxyCreator.setInterceptorNames("calculateNameMatchMethodpointcutAdvisor");
		beanNameAutoproxyCreator.setInterceptorNames("calculateRegexpMethodpointcutAdvisor");
		return beanNameAutoproxyCreator;
	}

	/**
	 * BeanNameAutoproxyCreator 和 DefaultAdvisorAutoproxyCreator 二者选一个留下
	 * DefaultAdvisorAutoproxyCreator 让容器中的所有 advisor 都生效
	 */
//	@Bean
//	public DefaultAdvisorAutoproxyCreator calculateDefaultAdvisorAutoproxyCreator() {
//		return new DefaultAdvisorAutoproxyCreator();
//	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculate", 0);
	}

}

16:40:28.030 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add

16:40:28.030 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.subtract

16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply

16:40:28.031 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

基于 XML

百度

基于注解

@Aspect
public class CalculateAspect {

	private static final Logger log = LoggerFactory.getLogger(CalculateAspect.class);

	// Before:			方法执行前
	// After:			方法执行后(不管是否异常)
	// AfterReturning:	方法成功执行后
	// AfterThrowing:	方法抛出异常后
	// Around:			自己封装整个代理逻辑

	// 可以不写切点,直接把切点表达式写在 @Before 等括号中
	@pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.*(..))")
	public void all() {}
	@pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.add(..))")
	public void add() {}
	@pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.subtract(..))")
	public void subtract() {}
	@pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.multiply(..))")
	public void multiply() {}
	@pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.divide(..))")
	public void divide() {}

	@Before("all()")
	public void allBefore(JoinPoint joinPoint) {
		log.info("AllBefore: {},{}", joinPoint.getSignature().getName(), Arrays.asList(joinPoint.getArgs()));
	}

	@After("all()")
	public void allAfter(JoinPoint joinPoint) {
		log.info("AllAfter");
	}

	@AfterReturning(value = "all()", returning = "result")
	public void allAfterReturning(JoinPoint joinPoint, Object result) {
		log.info("AllAfterReturning: {}", result);
	}

	@AfterThrowing(value = "all()", throwing = "cause")
	public void allAfterThrowing(JoinPoint joinPoint, Throwable cause) {
		log.info("AllAfterThrowing: {}", cause.getMessage());
	}

	//	@Before("add()")
	// ajc: circular advice precedence: can't determine precedence between two or more pieces of advice that apply to the same join point: method-execution(int com.mrathena.aop.usage.CalculateImpl.add(int,int))
	// 每一个方法只能被一个@Before横切
	public void addBefore(JoinPoint joinPoint) {
		log.info("AddBefore: {}, Arrays.asList(joinPoint.getArgs()));
	}

}

@EnableAspectJAutoproxy
@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateAspect calculateAspect() {
		return new CalculateAspect();
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculate", 0);
	}

}

16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllBefore: multiply, [1, 2]
16:50:49.263 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfter
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfterReturning: 2

16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllBefore: divide, 0]
16:50:49.263 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfter
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfterThrowing: / by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

深入剖析HashMap：理解Hash、底层实现与扩容机制
HashMap是Java中最常用的集合类框架，也是Java语言中非常典型的数据结构， 而HashSet和HashMap者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap(适配器模式)。因此了解HashMap源码也就了解HashSet了 介绍 K
为什么在EffectiveJava中建议用EnumSet替代位字段，以及使用EnumMap替换序数索引
在EffectiveJava中的第 36条中建议 用 EnumSet 替代位字段，在第37条中建议 用EnumMap替换序数索引，为什么？ EnumSet 在EffectiveJava中的第 36条中建议 用 EnumSet 替代位字段 36、用 EnumSet替代位字段 如果枚举类型的元素主要在
注解的优点？元注解？
介绍 注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解。主要作用如下： 编写文档——通过注解中标识的元数据可以生成doc文档，这是最常见的，也是java 最早提供的注解。常用的有@param @return 等 代码分析——通过注解
Linkedlist源码详解
介绍 LinkedList同时实现了List接口和Deque接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列(Queue)，同时又可以看作一个栈(Stack)。这样看来，LinkedList简直就是个全能冠军。当你需要使用栈或者队列时，可以考虑使用LinkedList，一方面是因为Java
TreeMap源码详解—彻底搞懂红黑树的平衡操作
介绍 TreeSet和TreeMap在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说TreeSet里面有一个TreeMap(适配器模式)。 Java TreeMap实现了SortedMap接口，也就是说会按照key的大小顺序对Map中的元素进行排序，key大小的评判可以通过其本身的
深入理解ConcurrentHashMap
HashMap为什么线程不安全 put的不安全 由于多线程对HashMap进行put操作，调用了HashMap的putVal()，具体原因： 假设两个线程A、B都在进行put操作，并且hash函数计算出的插入下标是相同的； 当线程A执行完第六行由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处
枚举实现原理
枚举的定义 在JDK1.5之前，我们要是想定义一些有关常量的内容，例如定义几个常量，表示从周一到周末，一般都是在一个类，或者一个接口中，写类似于如下代码： public class WeekDayConstant { public static final int MONDAY = 0; publi
为什么Java已经不推荐使用Stack了？
为什么不推荐使用Stack Java已不推荐使用Stack，而是推荐使用更高效的ArrayDeque 为什么不推荐使用 性能低：是因为 Stack 继承自 Vector， 而 Vector 在每个方法中都加了锁。由于需要兼容老的项目，很难在原有的基础上进行优化，因此 Vector 就被淘汰掉了，使用
注解是如何实现的？
注解是否支持继承 不支持继承 不能使用关键字extends来继承某个@interface，但注解在编译后，编译器会自动继承java.lang.annotation.Annotation接口. 虽然反编译后发现注解继承了Annotation接口，但即使Java的接口可以实现多继承，但定义注解时依然无法
一篇文章讲清楚Java中的反射
介绍 每个类都有一个 Class 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。 类加载相当于 Class 对象的加载。类在第一次使用时才动态加载到 JVM 中，可以使用 Class.forName("com.mys
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native