SpringAop执行流程

最新推荐文章于 2024-07-04 15:07:58 发布
最新推荐文章于 2024-07-04 15:07:58 发布
阅读量206 收藏
点赞数
分类专栏： spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42685950/article/details/120781748
版权

Cglib

Callback[] mainCallbacks = new Callback[] {
aopInterceptor, //DynamicAdvisedInterceptor
targetInterceptor, //DynamicUnadvisedExposedInterceptor
new SerializableNoOp(),
targetDispatcher, this.advisedDispatcher,
new EqualsInterceptor(this.advised),
new HashCodeInterceptor(this.advised)
};
DynamicAdvisedInterceptor

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			Object oldProxy = null;
			boolean setProxyContext = false;
			Object target = null;
			TargetSource targetSource = this.advised.getTargetSource();
			try {
				//是否暴露代理
				if (this.advised.exposeProxy) {
					// 使调用在必要时可用。
					oldProxy = AopContext.setCurrentProxy(proxy);
					setProxyContext = true;
				}
				// 尽可能晚一点，以尽量减少我们 "拥有 "目标的时间，以防它来自于一个池......
				target = targetSource.getTarget();
				Class<?> targetClass = (target != null ? target.getClass() : null);
				//获取到所有匹配的Interceptor
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
				// 拦截器链不为空并且方法修饰符是public的
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
					// 我们可以跳过创建一个MethodInvocation：直接调用目标。
					// 注意，最终的调用者必须是一个InvokerInterceptor，所以我们知道它只对目标进行反射性操作，而没有热交换或花哨的代理。
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					retVal = methodProxy.invoke(target, argsToUse);
				}
				else {
					// 我们需要创建一个方法调用...
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				//对特殊返回值做处理（this）
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}
			finally {
				if (target != null && !targetSource.isStatic()) {
					targetSource.releaseTarget(target);
				}
				if (setProxyContext) {
					// 恢复原来的代理。
					AopContext.setCurrentProxy(oldProxy);
				}
			}
		}

public CglibMethodInvocation(Object proxy, @Nullable Object target, Method method,
				Object[] arguments, @Nullable Class<?> targetClass,
				List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {

			super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);

			// 只对非源自java.lang.Object的公共方法使用方法代理
			this.methodProxy = (Modifier.isPublic(method.getModifiers()) &&
					method.getDeclaringClass() != Object.class && !AopUtils.isEqualsMethod(method) &&
					!AopUtils.isHashCodeMethod(method) && !AopUtils.isToStringMethod(method) ?
					methodProxy : null);
		}

protected ReflectiveMethodInvocation(
			Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
			@Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {

		this.proxy = proxy;
		this.target = target;
		this.targetClass = targetClass;
		//处理桥接方法
		this.method = BridgeMethodResolver.findBridgedMethod(method);
		//处理可变参数
		this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
		this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
	}

public Object proceed() throws Throwable {
			try {
				//总是执行ReflectiveMethodInvocation.proceed()
				return super.proceed();
			}
			catch (RuntimeException ex) {
				throw ex;
			}
			catch (Exception ex) {
				if (ReflectionUtils.declaresException(getMethod(), ex.getClass()) ||
						KotlinDetector.isKotlinType(getMethod().getDeclaringClass())) {
					// 如果在目标方法上声明了原始异常，则传播原始异常（调用者期待它）。
					// 对于Kotlin代码来说，总是传播它，因为检查过的异常不需要在那里明确声明。
					throw ex;
				}
				else {
					// 检查在拦截器中抛出但未在目标方法签名中声明的异常-->应用UndeclaredThrowableException。
					// 与标准的JDK动态代理行为保持一致。
					throw new UndeclaredThrowableException(ex);
				}
			}
		}

ExposeInvocationInterceptor

public Object invoke(MethodInvocation mi) throws Throwable {
		MethodInvocation oldInvocation = invocation.get();
		//在当前线程保存MethodInvocation
		invocation.set(mi);
		try {
			return mi.proceed();
		}
		finally {
			invocation.set(oldInvocation);
		}
	}

public boolean matches(Method method, Class<?> targetClass, Object... args) {
		//获取切点表达式
		obtainPointcutExpression();
		//通过表达式匹配方法获取对应的ShadowMatch
		ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);

		// 将Spring AOP代理与AspectJ "this "绑定，将Spring AOP目标与AspectJ目标绑定。
		// 与MethodInvocationProceedingJoinPoint的返回一致
		ProxyMethodInvocation pmi = null;
		Object targetObject = null;
		Object thisObject = null;
		try {
			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
			targetObject = mi.getThis();
			if (!(mi instanceof ProxyMethodInvocation)) {
				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
			}
			pmi = (ProxyMethodInvocation) mi;
			thisObject = pmi.getProxy();
		}
		catch (IllegalStateException ex) {
			// No current invocation...
			if (logger.isDebugEnabled()) {
				logger.debug("Could not access current invocation - matching with limited context: " + ex);
			}
		}

		try {
			JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);

			/*
			 * 做最后的检查，看是否有this(TYPE)类的残留物匹配。为此，我们使用原始方法（代理方法）的阴影来确保'this'被正确检查。
			 * 如果没有这个检查，我们会在this(TYPE)上得到不正确的匹配，其中TYPE与目类型而不是'this'（如JDK动态代理的情况）。
			 * 请参见SPR-2979了解原始错误。
			 */
			if (pmi != null && thisObject != null) {  // 有一个当前的调用
				RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(getShadowMatch(method, method));
				if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
					return false;
				}
				if (joinPointMatch.matches()) {
					bindParameters(pmi, joinPointMatch);
				}
			}

			return joinPointMatch.matches();
		}
		catch (Throwable ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to evaluate join point for arguments " + Arrays.asList(args) +
						" - falling back to non-match", ex);
			}
			return false;
		}
	}

public Object invoke(MethodInvocation mi) throws Throwable {
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		return mi.proceed();
	}

@Override
	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
		invokeAdviceMethod(getJoinPointMatch(), null, null);
	}

protected JoinPointMatch getJoinPointMatch() {
		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
		if (!(mi instanceof ProxyMethodInvocation)) {
			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
		}
		return getJoinPointMatch((ProxyMethodInvocation) mi);
	}

@Nullable
	protected JoinPointMatch getJoinPointMatch(ProxyMethodInvocation pmi) {
		String expression = this.pointcut.getExpression();
		return (expression != null ? (JoinPointMatch) pmi.getUserAttribute(expression) : null);
	}

调用对应Advice的方法

protected Object invokeAdviceMethod(
			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
			throws Throwable {

		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
	}

protected JoinPoint getJoinPoint() {
		return currentJoinPoint();
	}

public static JoinPoint currentJoinPoint() {
		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
		if (!(mi instanceof ProxyMethodInvocation)) {
			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
		}
		ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
		//从JoinPoint获取属性org.aspectj.lang.JoinPoint
		JoinPoint jp = (JoinPoint) pmi.getUserAttribute(JOIN_POINT_KEY);
		if (jp == null) {
			//没有就创建一个
			jp = new MethodInvocationProceedingJoinPoint(pmi);
			pmi.setUserAttribute(JOIN_POINT_KEY, jp);
		}
		return jp;
	}

protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
			@Nullable Object returnValue, @Nullable Throwable ex) {

  		calculateArgumentBindings();

		// AMC启动
		Object[] adviceInvocationArgs = new Object[this.parameterTypes.length];
		int numBound = 0;
		//joinPoint参数的下标不能为-1
		if (this.joinPointArgumentIndex != -1) {
			//将参数JoinPoint赋值给对应的下标
			adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
			numBound++;
		}
		else if (this.joinPointStaticPartArgumentIndex != -1) {
			adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
			numBound++;
		}

		if (!CollectionUtils.isEmpty(this.argumentBindings)) {
			// 与pointcut匹配的结合
			if (jpMatch != null) {
				PointcutParameter[] parameterBindings = jpMatch.getParameterBindings();
				for (PointcutParameter parameter : parameterBindings) {
					String name = parameter.getName();
					Integer index = this.argumentBindings.get(name);
					//通过下标赋值参数
					adviceInvocationArgs[index] = parameter.getBinding();
					numBound++;
				}
			}
			// 从返回条款中绑定
			if (this.returningName != null) {
				Integer index = this.argumentBindings.get(this.returningName);
				adviceInvocationArgs[index] = returnValue;
				numBound++;
			}
			// 与被抛出的异常结合
			if (this.throwingName != null) {
				Integer index = this.argumentBindings.get(this.throwingName);
				adviceInvocationArgs[index] = ex;
				numBound++;
			}
		}

		if (numBound != this.parameterTypes.length) {
			throw new IllegalStateException("Required to bind " + this.parameterTypes.length +
					" arguments, but only bound " + numBound + " (JoinPointMatch " +
					(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
		}

		return adviceInvocationArgs;
	}

public final synchronized void calculateArgumentBindings() {
		// 简单的例子…没有绑定。
		if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
			return;
		}

		int numUnboundArgs = this.parameterTypes.length;
		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
		//确认JoinPoint参数的顺序下标
		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0]) ||
				maybeBindJoinPointStaticPart(parameterTypes[0])) {
			numUnboundArgs--;
		}

		if (numUnboundArgs > 0) {
			// 需要按从pointcut匹配返回的名称绑定参数
			bindArgumentsByName(numUnboundArgs);
		}

		this.argumentsIntrospected = true;
	}

protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
		Object[] actualArgs = args;
		//如果参数为0就赋值null
		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
			actualArgs = null;
		}
		try {
			//设置该方法的访问权限
			ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
			return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
		}
		catch (IllegalArgumentException ex) {
			throw new AopInvocationException("Mismatch on arguments to advice method [" +
					this.aspectJAdviceMethod + "]; pointcut expression [" +
					this.pointcut.getPointcutExpression() + "]", ex);
		}
		catch (InvocationTargetException ex) {
			throw ex.getTargetException();
		}
	}

AspectJAfterAdvice

public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}
		finally {
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

protected Object invokeJoinpoint() throws Throwable {
			if (this.methodProxy != null) {
				return this.methodProxy.invoke(this.target, this.arguments);
			}
			else {
				return super.invokeJoinpoint();
			}
		}

private static Object processReturnType(
			Object proxy, @Nullable Object target, Method method, @Nullable Object returnValue) {

		// 如有必要，可对返回值进行代理
		if (returnValue != null && returnValue == target &&
				!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
			// 特殊情况：它返回了 "this"。注意，如果目标在另一个返回的对象中设置了对自己的引用，我们也无能为力。
			returnValue = proxy;
		}
		Class<?> returnType = method.getReturnType();
		if (returnValue == null && returnType != Void.TYPE && returnType.isPrimitive()) {
			throw new AopInvocationException(
					"Null return value from advice does not match primitive return type for: " + method);
		}
		return returnValue;
	}
chinh.bling
关注
专栏目录
【Spring全家桶系列】SpringAOP的实现步骤与工作流程
未见花闻的博客
05-13 1444
如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象，如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。 要验证也很简单，在验证程序获取对象后，调用getClass()方法就能获取到它的类型了。
Spring-AOP工作流程
qq_53098203的博客
03-10 623
Spring-AOP工作流程
Spring AOP 执行流程及源码分析
weixin_42225963的博客
07-24 332
Spring AOP 执行流程及源码分析
【Spring】AOP工作流程
2201_75743716的博客
05-30 1803
AOP(Aspect Oriented Programming)面向切面编程：一种编程范式，指导开发者如何组织程序结构。AOP作用：在不惊动原始设计的基础上为其进行功能增强。
Spring Aop 执行流程
@Bean
07-26 2210
闲聊 在Spring Bean的生命周期中，处理aop的流程只有第一步处理通知和最后一步创建代理对象。 可以说只要去掉第一步和最后一步，也不会影响SpringBean的生命周期。可见在生命周期中处理aop 和aop的理念是完全符合解耦的思想。 切面的组成 一个简单的切面AspectJ 通常可以由多个切入点Pointcut 和多个通知Advice 组成。 切入点：切入点和切入点表达式相辅相成的存在，通常由切入点表达式决定切入点需要切入的位置 通知：在切面里面，通知通常分为五种。分别是前置通知，环绕
Spring系列之AOP工作过程详解一
a_ittle_pan的博客
03-26 1027
引言 spring的IOC系列已经正式完结了，这一个星期一直在想着接下来更新什么系列，想了想，面试里面不就是IOC和AOP考的最多吗？那么就索性接下来开始更新AOP系列的文章，就非常的河狸 aop:config aop部分的解析器由AopNamespaceHandler注册，其init方法: @Override public void init() { registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
springaop执行流程
06-02
Spring AOP 的执行流程如下： 1. 获取目标对象：首先，Spring AOP 会获取被代理的目标对象。 2. 创建代理对象：基于目标对象和配置的切面，Spring AOP 会创建一个代理对象。代理对象包含了目标对象的所有方法，...
Spring Aop 源码流程.doc
08-07
当我们谈论Spring AOP的源码流程，这通常涉及到Spring初始化过程中的自动代理创建，以及如何通过AOP实现切面的动态代理。下面我们将深入探讨这个过程。 首先，Spring容器的初始化始于`...
SpringAOP(图文详解)
热门推荐
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring项目AOP工作流程
时代各有不同，青春一脉相承。
10-26 903
Spring项目AOP工作流程。由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起。流程1:Spring容器启动；流程2:读取所有切面配置中的切入点；流程3:初始化bean；流程4:获取bean执行方法。目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现。
SpringAop过程
小蜜蜂
11-29 629
SpringAop全过程 1开启AOP,2解析advisor,3创建Aop,4调用Aop
Spring中AOP的执行流程
Smilelfq的专栏
08-21 424
Spring的AOP: AOP就是一种更高级的动态代理的使用; Aspect Oritention Programming(面向切面编程) 切入点:要加入业务逻辑的点(在哪些类的哪些方法上面) 通知:通知包含两个方面,1,代表方法的执行时间,2,在这个时间上面要做什么事情; 切面:一个切入点+一个通知=一个切面(在什么地方,在什么时候,做什么事情); 织入:把一个切面应用到真实对象上面的过程,就叫做织入; SpringAOP的执行流程: 1，解析xml； 2，实例化所有的bea...
spring中的Aop大致流程
m0_49708063的博客
11-16 669
首先我们先来一个基础类 就是需要被Aop代理的类 再来一个切面 加上配置类 启动类 打上断点 debug执行 f7进入方法中查看 我们看一看chain中有什么属性 ExposeInvocationInterceptor的用处我们等下讲解 继续往下看 进入方法 来执行链式调用 就是我们所说的责任链模式 new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed
SpringAOP执行流程——从源码画流程图
qq_44027353的博客
06-26 911
在该方法中就会从MethodInterceptor集合中取出来，并调用各自的invoke()方法，在调用过程中会把this自己传递过去，而在MethodInterceptor的invoke()方法中又会调用proceed()方法，就这样完成了循环遍历。设置接口，如果UserService类实现了UserInterface接口，但是没有调用该方法进行设置，那么下方源码中的if判断还是为没有实现接口，ProxyFactory不会自动判断类有没有实现接口，Spring它是自己做了相应的处理逻辑。
SpringAOP大致流程
wuqjwuqj2013的博客
09-20 523
3. 代理类中还会有一个target属性，该属性的值为被代理对象（也就是通过UserService类推断构造方法实例化出来的对象，进行了依赖注入、初始化等步骤的对象）AOP就是进行动态代理，在创建一个Bean的过程中，Spring在最后一步会去判断当前正在创建的这个Bean是不是需要进行AOP，如果需要则会进行动态代理。UserService代理对象.test()--->执行切面逻辑--->target.test()，注意target对象不是代理对象，而是被代理对象。1. 找出所有的切面Bean。
Spring AOP 源码执行流程
最新发布
2301_78976656的博客
07-04 590
这里我们总结一下注解方式和配置文件方式注解是基于@AspectJ；有两种方式，一种是纯注解方式；一种是 切面用注解，在配置文件中配置启动AOP自动代理。配置文件方式：就是纯解析xml标签节点方式。但是最终我们发现，都会走到方法来注册 AnnotationAwareAspectJAutoProxyCreator.class。
spring AOP配置方法 与 IoC容器的执行流程
CTO成长之路——Rosanu
05-09 1460
主要适用于写日志等操作，可以在dao层 业务层添加，但是必须是借口才能使用 配置方法 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframew
Spring——AOP工作流程
测试
03-11 341
AOP工作流程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值