浅析AOP源码（四）

最新推荐文章于 2023-03-31 09:07:11 发布
转载 最新推荐文章于 2023-03-31 09:07:11 发布 · 270 阅读 · 0

转载自：https://blog.youkuaiyun.com/luanlouis/article/details/51155821

  

1、Spring内部创建代理对象的过程

  在Spring的底层，如果配置了AOP，Spring会为每一个Bean创建一个对应的ProxyFactoryBean的FactoryBean来创建某个对象的代理对象。
  假定有一个接口TicketService及其实现类RailwayStation，打算创建一个代理类，在执行TicketService的方法时的各个阶段，插入对应的业务代码。

public interface TicketService {
    //售票
    public void sellTicket();

    //问询
    public void inquire();

    //退票
    public void withdraw();
}

public class RailwayStation  implements TicketService {
    public void sellTicket(){
        System.out.println("售票............");
    }

    public void inquire() {
        System.out.println("问询.............");
    }

    public void withdraw() {
        System.out.println("退票.............");
    }
}

public class TicketServiceBeforeAdvice implements MethodBeforeAdvice {

    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("BEFORE_ADVICE: 欢迎光临代售点....");
    }
}

public class TicketServiceAfterReturningAdvice  implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("AFTER_RETURNING：本次服务已结束....");
    }
}

public class TicketServiceAroundAdvice  implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("AROUND_ADVICE:BEGIN....");
        Object returnValue = invocation.proceed();
        System.out.println("AROUND_ADVICE:END.....");
        return returnValue;
    }
}

public class TicketServiceThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(Exception ex) {
        System.out.println("AFTER_THROWING....");
    }

    public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {
        System.out.println("调用过程出错啦！！！！！");
    }

}

  然后来手动使用ProxyFactoryBean来创建Proxy对象，并将相应的几种不同的Advice加入这个proxy对应的各个执行阶段中：

    public static void main(String[] args) {
        Advice beforeAdvice = new TicketServiceBeforeAdvice();
        Advice afterReturningAdvice = new TicketServiceAfterReturningAdvice();
        Advice aroundAdvice = new TicketServiceAroundAdvice();
        Advice throwsAdvice = new TicketServiceThrowsAdvice();

        RailwayStation railwayStation = new RailwayStation();

        // 创建ProxyFactoryBean,用以创建指定对象的Proxy对象
        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        // 设置Proxy的接口
        proxyFactoryBean.setInterfaces(TicketService.class);
        // 设置RealSubject
        proxyFactoryBean.setTarget(railwayStation);
        // 使用JDK基于接口实现机制的动态代理生成Proxy代理对象，如果想使用CGLIB，需要将这个flag设置成true
        proxyFactoryBean.setProxyTargetClass(false);

        // 添加不同的Advice
        proxyFactoryBean.addAdvice(afterReturningAdvice);
        proxyFactoryBean.addAdvice(aroundAdvice);
        proxyFactoryBean.addAdvice(throwsAdvice);
        proxyFactoryBean.addAdvice(beforeAdvice);

        // 通过ProxyFactoryBean生成Proxy对象
        TicketService ticketService = (TicketService) proxyFactoryBean.getObject();
        ticketService.sellTicket();
    }

  运行结果：

AROUND_ADVICE:BEGIN....
BEFORE_ADVICE: 欢迎光临代售点....
售票............
AROUND_ADVICE:END.....
AFTER_RETURNING：本次服务已结束....

  我们成功地创建了一个通过一个ProxyFactoryBean和真实的实例对象创建出了对应的代理对象，并将各个Advice加入到proxy代理对象中。

  

2、Spring AOP的核心ProxyFactoryBean

  上面通过了使用ProxyFactoryBean实现了AOP的功能，在使用时通过addAdvice(Advice advice)把各类Advice添加到ProxyFactoryBean（实际是父类AdvisedSupport）中：

	public void addAdvice(Advice advice) throws AopConfigException {
		int pos = this.advisors.size();
		addAdvice(pos, advice);
	}

  AdvisedSupport中维护了private List<Advisor> advisors = new LinkedList<Advisor>();列表，addAdvice中会把advice包装为DefaultPointcutAdvisor加入到这个列表里。
  也就是说ProxyFactoryBean知道Advice信息，可以根据特定的类名和方法名返回对应的AdviceChain，用以表示需要执行的Advice串。当使用proxy时，对proxy对象调用的方法，都最终被转到这个类的invoke()方法中。以JdkDynamicAopProxy为例：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  //...略
	/** Proxy的配置信息，这里主要提供Advisor列表，并用于返回AdviceChain */
	private final AdvisedSupport advised;
 
	//...略
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		MethodInvocation invocation;
		Object oldProxy = null;
		boolean setProxyContext = false;
 
		TargetSource targetSource = this.advised.targetSource;
		Class<?> targetClass = null;
		Object target = null;
 
		try {
			//...略
			Object retVal;

      //...略
			// 获取当前调用方法的拦截链
			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 
      // 如果没有拦截链，则直接调用Joinpoint连接点的方法。
			if (chain.isEmpty()) {
				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
        // 根据给定的拦截链和方法调用信息，创建新的MethodInvocation对象，
        // 整个拦截链的工作逻辑都在这个ReflectiveMethodInvocation里 
				invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				retVal = invocation.proceed();
			}
 
			//...略
			return retVal;
		}
		finally {
			//...略
		}
	}
}

  来看关键的getInterceptorsAndDynamicInterceptionAdvice函数：

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
		MethodCacheKey cacheKey = new MethodCacheKey(method);
		List<Object> cached = this.methodCache.get(cacheKey);
		if (cached == null) {
			cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
					this, method, targetClass);
			this.methodCache.put(cacheKey, cached);
		}
		return cached;
	}

  最终是调用到了DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice：

	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, Class<?> targetClass) {

		// This is somewhat tricky... We have to process introductions first,
		// but we need to preserve order in the ultimate list.
		List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

		for (Advisor advisor : config.getAdvisors()) {
			if (advisor instanceof PointcutAdvisor) {
				// Add it conditionally.
				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
					MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
						if (mm.isRuntime()) {
							// Creating a new object instance in the getInterceptors() method
							// isn't a problem as we normally cache created chains.
							for (MethodInterceptor interceptor : interceptors) {
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
							interceptorList.addAll(Arrays.asList(interceptors));
						}
					}
				}
			}
			else if (advisor instanceof IntroductionAdvisor) {
				//...略
			}
			else {
				//...略
			}
		}

		return interceptorList;
	}

  代码比较长，主要看for循环的第一个if分支。config.getAdvisors()返回的就是之前通过addAdvisor添加的Advisor列表（new DefaultPointcutAdvisor(advice)）。registry.getInterceptors(advisor)是把advisor转换成MethodInterceptor[]：

	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
		Advice advice = advisor.getAdvice();
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
	}

  AdvisorAdapter的实例有AfterReturningAdviceAdapter、MethodBeforeAdviceAdapter、ThrowsAdviceAdapter分别用于转换AfterReturningAdvice、MethodBeforeAdvice、ThrowsAdvice为AfterReturningAdviceInterceptor、MethodBeforeAdviceInterceptor、ThrowsAdviceInterceptor。注意，示例代码里的TicketServiceAroundAdvice类是MethodInterceptor的子类，不需要AdvisorAdapter转换。

  这里创建MethodInterceptor链，然后构造ReflectiveMethodInvocation实例，调用proceed()：

	@Override
	public Object proceed() throws Throwable {
		//	We start with an index of -1 and increment early.
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint();
		}
    
    // 取得第拦截器链上第N个拦截器 
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			// Evaluate dynamic method matcher here: static part will already have
			// been evaluated and found to match.
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
				return dm.interceptor.invoke(this);
			}
			else {
				// Dynamic matching failed.
				// Skip this interceptor and invoke the next in the chain.
				return proceed();
			}
		}
		else {
			// It's an interceptor, so we just invoke it: The pointcut will have
			// been evaluated statically before this object was constructed.
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}

  初始时，this.currentInterceptorIndex=-1，this.interceptorsAndDynamicMethodMatchers即先前创建的MethodInterceptor[]。
  第一步，取MethodInterceptor[]中的第0个，即AfterReturningAdviceInterceptor：

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {

	private final AfterReturningAdvice advice;

	public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		Object retVal = mi.proceed();
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}
}

  先执行mi.proceed()，即ReflectiveMethodInvocation实例的proceed()方法，进入proceed()后，取MethodInterceptor[]中的第1个，即TicketServiceAroundAdvice：

public class TicketServiceAroundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("AROUND_ADVICE:BEGIN....");
        Object returnValue = invocation.proceed();
        System.out.println("AROUND_ADVICE:END.....");
        return returnValue;
    }
}

  同理再次进入proceed()后，取MethodInterceptor[]中的第2个，即ThrowsAdviceInterceptor：

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}
		catch (Throwable ex) {
			Method handlerMethod = getExceptionHandler(ex);
			if (handlerMethod != null) {
				invokeHandlerMethod(mi, ex, handlerMethod);
			}
			throw ex;
		}
	}

  之后进入proceed()后，取MethodInterceptor[]中的第3个，MethodBeforeAdviceInterceptor：

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {

	private MethodBeforeAdvice advice;

	public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}

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

}

  之后进入proceed()，this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1满足条件，进入invokeJoinpoint:

	protected Object invokeJoinpoint() throws Throwable {
		return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
	}

  这里执行被代理对象的方法调用。然后根据方法栈的调用依次执行完MethodBeforeAdviceInterceptor->ThrowsAdviceInterceptor->TicketServiceAroundAdvice->AfterReturningAdviceInterceptor。所以最终的运行情况是：

AROUND_ADVICE:BEGIN....
BEFORE_ADVICE: 欢迎光临代售点....
售票............
AROUND_ADVICE:END.....
AFTER_RETURNING：本次服务已结束....
Spring AI 实战：第六章、Spring AI源码浅析之一山可容二虎
liaokailin的专栏
05-04 1653
通过Debug看代码效率更高依赖ChatModel，而ChatModel由各个大模型的提供；通过手动定义多个 ChatClient 解决 NoUniqueBeanDefinitionException；Advisor 机制类似 AOP，可以在调用前后插入逻辑，可以自定义 Advisor 实现日志、缓存、限流等功能；chatModel.call()最终把请求转发到各个大模型的API调用规范实现上。看完代码以后期望你能自行读懂流式请求的操作（核心是Flux的操作，在第一章给出了示例）
Spring AOP源码 浅析
yangsnow_rain_wind的专栏
05-03 614
NND ,源码实在复杂,先整理个思路吧 AOP配置文件demo &lt;bean id="daoImpl" class="com.xx.xx.pcwebv2.Dao.CDaoImp" /&gt; &lt;bean id="timeHandler" class="com.xx.xx.pcwebv2.Dao.TimeHandler" /&gt; &lt;aop:config prox
浅析Spring Aop源码
javashareauthor的博客
06-28 168
Aop作为Spring的一个重要组成部分，有着举足轻重的位置，因此有必要去深入了解实现原理。 在现在的面试或者同事之间聊天的时候，我们都习惯去这样回答Aop：Aop就是面向切面编程，实现原理就是动态代理（jdk代理或者cglib代理），应用于Spring的事务和日志打印等场景。 不知道你发现问题没有，上述的回答很虚（评论性见解，并非工程学见解），...
浅析AOP源码（一）
ZERO
05-19 1331
转载自： https://blog.youkuaiyun.com/moreevan/article/details/11977115/ https://blog.youkuaiyun.com/qq_38182963/article/details/78747404 　　AOP（Aspect-Oriented Programming）面向切面的编程，在平时的开发过程中，AOP其实用到的地方一般有: ①用来做日...
浅析AOP源码（三）
ZERO
05-19 345
转载自： https://blog.youkuaiyun.com/moreevan/article/details/11977115/ https://blog.youkuaiyun.com/qq_38182963/article/details/78747404 　　Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSu...
aop源码浅析
chunbing_dkw的博客
03-31 205
说明：主要分成四部分，
浅析AOP源码（二）
ZERO
05-19 291
转载自：https://blog.youkuaiyun.com/qq_38182963/article/details/78759574 　　上一篇介绍了AOP代理对象的生成方式中的ProxyFactoryBean，这篇接着分析一下基于注解实现的AOP怎么生成代理对象。 　　首先看下关键类AnnotationAwareAspectJAutoProxyCreator，该类实现了InstantiationAw...
java源码浅析之AOP
DaHuangXiao的博客
05-22 243
前言 继之前写了一篇Proxy源码浅析后打算去看AOP，由于本人刚学java不久，Spring看得很粗，以至于看源码比较慢，不过在学习过程中逐渐提高了探索源码的能力，觉得整个过程也挺有趣，故做此记录。 主要记录一下作为一名java初学者是怎么探索Spring框架的 预备知识 所谓磨刀不误砍柴功，在探索源码之前，我通过B站以下两个系列视频稍微了解了一下Spring的大体框架，但听的时候似懂非懂 雷神的注解驱动开发（IOC和AOP部分） 周瑜老师的手写Spring 看完视频后能够大概掌握 注解开发以及AO
spring-AOP源码浅析
nzgry_csdn的博客
05-09 408
spring-AOP源码浅析 目录spring-AOP源码浅析入口自动代理创建器类图功能实现切面获取流程ProxyFactory通知切面执行过程 入口 spring aop功能可以使用@EnableAspectJAutoProxy注解开启，这个注解中，通过@Import(AspectJAutoProxyRegistrar.class)导入了AspectJAutoProxyRegistrar这个注册类，该类实现了ImportBeanDefinitionRegistrar接口，这个接口会在Configurati
Spring中AOP源码浅析③
Harrison
12-31 172
结合Spring中AOP源码浅析①Spring中AOP源码浅析②这两篇文章我们知道AOP的实现其实是通过引入AnnotationAwareAspectJAutoProxyCreator这个类（注解感知AspectJ自动代理创建器 BeanName：org.springframework.aop.config.internalAutoProxyCreator）去实现的。实际他的底层也是一个InstantiationAwareBeanPostProcessor后置处理器。结合两篇文章，简单画一下它的实现过...
sping AOP 权限管理方案浅析
07-17
本文将深入浅析Spring AOP在权限管理中的应用，结合标签"源码"和"工具"，我们将探讨如何利用Spring AOP实现精细的权限控制，并通过具体的代码示例来理解这一过程。 Spring AOP（Aspect Oriented Programming）是...
Spring源码浅析之AOP、Aspect、Advice
DaHuangXiao的博客
06-15 1371
前言 理一理AOP与切面（Aspect）、通知（Advisor）的关系 概念 通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。 切点（PointCut）: 可以插入增强处理的连接点。 切面（Aspect）: 切面是通知和切点的结合。 做了张图 PointCut：指的是具体
Spring框架浅析 -- AOP
吾日三省吾身
07-30 720
什么是AOP AOP-Aspect Oriented Programming，通常翻译为面向切面编程。它的提出实际上是为了补充OOP-Object Oriented Programming的一些不足。 那么OOP有哪些不足呢？这里我谈谈自己的一些想法，我们知道OOP的思路通常是，将一个大型的功能划分成若干子功能，然后进一步抽象成为若干小模块或者叫小组件，每一个小组件封装了数据（属性）与操作（方...
【嵌入式AIoT】系统架构与轻量化模型部署：面向智能家居与工业监测的边缘智能终端实战设计
12-21
内容概要：本文系统介绍了嵌入式AIoT应用场景的实战方法与实践路径，涵盖从场景选择、系统架构设计到AI模型部署、通信与数据管理的全流程。重点阐述了嵌入式系统与人工智能、物联网技术的融合，强调在资源受限环境下实现感知、分析与决策一体化的智能终端系统。文章详细解析了感知层、边缘计算层和云端服务层的协同机制，突出边缘侧数据处理与轻量化AI模型优化的重要性，并倡导以实际需求为导向，避免“为AI而AI”的设计误区。同时，强调系统稳定性、远程维护和长期运行能力的建设。; 适合人群：具备嵌入式系统基础、物联网或AI相关背景，有一定开发经验的工程师或工作1-3年的技术研发人员；适用于希望深入理解AIoT系统集成与实战落地的学习者。; 使用场景及目标：①智能家居、工业监测、智慧农业等分布式智能系统开发；②在算力、功耗受限的嵌入式设备上实现AI推理与边缘智能；③构建高效、可靠、可维护的端云协同AIoT系统。; 阅读建议：建议结合实际硬件平台进行项目化学习，边学边练，重点关注系统架构设计、模型优化与通信协议选型，注重整体系统思维的培养，而非仅关注单一技术点。
基于Python 的UART 文件传输工具
最新发布
12-21
基于Python 的UART 文件传输工具，基于Pyside6的GUI界面
C# 基于 Onnx 与 P2PNet 的人群检测与计数系统源码实现
12-21
基于C#编程语言与Onnx运行时环境，本文档详细阐述了一种利用P2PNet架构实现人群密度估计与个体计数的技术方案。该方案通过解析预训练模型，实现了对图像或视频流中人群分布的精准检测，并提供了可靠的计数功能。核心内容包括模型加载与推理流程的完整实现、数据处理管道的构建以及性能优化策略的探讨。本文旨在为相关领域的开发人员提供一个清晰、可复现的参考实现，着重于工程实践的严谨性与代码模块的可用性。所有实现代码均经过结构化组织与详细注释，以确保其易于理解与集成。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
Theoretical Machine Learning Notes (Princeton COS511)
12-21
根据原作 https://pan.quark.cn/s/459657bcfd45 的源码改编 Classic-ML-Methods-Algo 引言 建立这个项目,是为了梳理和总结传统机器学习(Machine Learning)方法(methods)或者算法(algo),和各位同仁相互学习交流. 现在的深度学习本质上来自于传统的神经网络模型,很大程度上是传统机器学习的延续,同时也在不少时候需要结合传统方法来实现. 任何机器学习方法基本的流程结构都是通用的;使用的评价方法也基本通用;使用的一些数学知识也是通用的. 本文在梳理传统机器学习方法算法的同时也会顺便补充这些流程,数学上的知识以供参考. 机器学习 机器学习是人工智能(Artificial Intelligence)的一个分支,也是实现人工智能最重要的手段.区别于传统的基于规则(rule-based)的算法,机器学习可以从数据中获取知识,从而实现规定的任务[Ian Goodfellow and Yoshua Bengio and Aaron Courville的Deep Learning].这些知识可以分为四种: 总结（summarization） 预测(prediction) 估计(estimation) 假想验证(hypothesis testing) 机器学习主要关心的是预测[Varian在Big Data : New Tricks for Econometrics],预测的可以是连续性的输出变量,分类,聚类或者物品之间的有趣关联. 机器学习分类 根据数据配置(setting,是否有标签，可以是连续的也可以是离散的)和任务目标,我们可以将机器学习方法分为四种: 无监督(unsupervised) 训练数据没有给定...
食堂线上预约点餐系统_一个基于现代Web技术构建的面向学校企业及园区食堂的综合性数字化餐饮服务平台_该系统旨在通过线上化流程彻底革新传统食堂就餐模式_核心功能模块包括用户端小程序.zip
12-21
食堂线上预约点餐系统_一个基于现代Web技术构建的面向学校企业及园区食堂的综合性数字化餐饮服务平台_该系统旨在通过线上化流程彻底革新传统食堂就餐模式_核心功能模块包括用户端小程序.zip
深入理解Spring AOP源码与测试实践
资源摘要信息:"老王读spring-aop源码分析&测试代码.zip" 本文档为老王对于Spring框架中AOP（面向切面编程）模块的深入分析及测试代码的集合。Spring AOP作为Spring框架的一个核心模块，允许开发者以声明式的方式将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值