死磕spring源码：4.spring的AOP是如何实现的

最新推荐文章于 2024-09-08 15:03:29 发布
最新推荐文章于 2024-09-08 15:03:29 发布
阅读量675 收藏 4
点赞数 1
分类专栏： spring Java 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24689783/article/details/103340012
版权
Java 同时被 2 个专栏收录
12 篇文章 0 订阅
订阅专栏
spring
5 篇文章 0 订阅
订阅专栏

死磕源码：4.spring的AOP是如何实现的

一. 前言

AOP是spring的一个核心功能之一，当我们需要将一些行为中的公共的逻辑抽离出来，然而这些行为不具备继承的关系的时候，那么这个时候AOP的作用就显现出来了，比如说日志系统，异常处理系统等等，如果说将这些逻辑糅合在业务代码中，那么这个就会导致代码及其难以维护。

二.什么叫做AOP？

说来话长，大家可参考这篇文章的解释：https://blog.csdn.net/q982151756/article/details/80513340，一句话***AOP（面向切面编程）是一种编程规范***。AOP采用了预编译和动态代理等手段，实现了代码的低耦合，提高了代码的可重用性。
在这里插入图片描述
这张图也是引自上边那篇文章，在AOP里边有几个非常重要的概念需要理解。上图是一个简单金融公司得业务图，有一个业务需求，就是在用户贷款申请，贷款管理，入出金管理的时候增加一个操作日志监控，对照着上图，我们来对下边几个概念逐一做一个解释，概念比较绕，大家要多揣摩几遍

  1. Joinpoint：连接点，就是对应上图贷款申请，贷款管理，入出金管理业务，这些业务在程序中的表现就是一个方法的调用，在代码中所谓的Joinpoint指的就是我们的方法，是允许申明切入点和通知的地方。
  2. Pointcut：切入点，就是针对Joinpoint进行一定的逻辑关联，申明Advice发生的地方。比如说上图Pointcut申明了贷款申请，贷款管理，入出金管理业务会做日志增强处理，加入再来一个还贷管理，那么没有申明，则不会进行增强处理
  3. Advice：通知，即针对满足Pointcut的地方做增强处理。
  4. Aspect：切面，就是关注节点的模块化，是Pointcut和Advice的集合
  5. Target：目标，是***真正逻辑实现的地方，被织入的类***。
  6. Proxy：代理，将切面应用于目标对象生成的代理对象
  7. Weaving：织入，这是一个很重要的概念，它指的是***将切面应用于目标对象生成代理对象的过程***。

三.spring的AOP的应用

具体的应用这篇文章不做过多的赘述，大家可以参照这一片博文：https://blog.csdn.net/qq_41615095/article/details/81240372。

四.spring的AOP的实现机制

1.解析aop:aspectj-autoproxy标签

可以看到想让AOP生效，必须要在spring的配置文件中添加aop:aspectj-autoproxy</aop:aspectj-autoproxy>申明，这样aop才会生效。这个标签明显是属于一个自定义的标签，之前我们在学习spring是如何解析xml标签的时候就说过，默认的标签有import，beans，bean和alias四个。那么这自定义的标签是如何解析的呢？

(1)自定义命名空间【aop】处理器-AopNamespaceHandler

类结构图
要解析aspectj-autoproxy这个自定义节点，那么必须要注册解析这个节点的解析器，通过全局搜索“aspectj-autoproxy”关键字，我们可以在spring的源码中找到它是在这个类中注册了这个节点的解析器

public class AopNamespaceHandler extends NamespaceHandlerSupport {
    public AopNamespaceHandler() {
    }
    public void init() {
        this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        this.registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}

OKOK，找到这个地方就太好了，终于找到下手的地方了，解析aspectj-autoproxy节点的解析器叫做AspectJAutoProxyBeanDefinitionParser，接下来就很好找下一步的逻辑了。spring在AOP的命名空间处理类AopNamespaceHandler中注册了aspectj-autoproxy这个标签的解析器。那么spring是如何初始化这个命名空间处理器，以及注册这个解析的呢？下边这段代码大家应该还有印象吧

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	if (delegate.isDefaultNamespace(root)) {
		NodeList nl = root.getChildNodes();
		for(int i = 0; i < nl.getLength(); ++i) {
			Node node = nl.item(i);
			if (node instanceof Element) {
				Element ele = (Element)node;
				if (delegate.isDefaultNamespace(ele)) {
					this.parseDefaultElement(ele, delegate);
				} else {
					delegate.parseCustomElement(ele);
				}
			}
		}
	} else {
		delegate.parseCustomElement(root);
	}
}

这段代码就是spring遍历解析xml节点的代码，那么由于aspectj-autoproxy不属于默认的四个节点之一，那么一定会走下边这一段delegate.parseCustomElement(ele)，然后回跳转到parseCustomElement这个方法中

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	String namespaceUri = this.getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	} else {
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		} else {
			return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
		}
	}
}

可以看到这里通过namespaceUri获取到了AopNamespaceHandler，至于子么自定义和使用NamespaceHandler，大家可以自行百度一下，这里不做过多赘述，最后在中调用了AopNamespaceHandler的init方法

...
NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
namespaceHandler.init();
handlerMappings.put(namespaceUri, namespaceHandler);
...

这样一来大家是不是很清晰这个自定义标签的解析器是如何注册上来的了？就是在这个spring回根据namespaceUri找到AopNamespaceHandler，然后调用它的init方法，初始化了这个解析器，并注册到spring容器中。

(2)自定义标签【aspectj-autoproxy】解析器-AspectJAutoProxyBeanDefinitionParser

初始化AspectJAutoProxyBeanDefinitionParser这个解析器之后，可以看到调用了handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))这样一个方法。这个方法就是解析这个标签的核心所在，一起去看看这段代码完成了什么东西。这个方法实在抽象类NamespaceHandlerSupport中实现的，这个类是NamespaceHandler的实现类，AopNamespaceHandler也是继承了这个类

public BeanDefinition parse(Element element, ParserContext parserContext) {
	BeanDefinitionParser parser = this.findParserForElement(element, parserContext);
	return parser != null ? parser.parse(element, parserContext) : null;
}

可以看到，这段代码的逻辑很简单。this.findParserForElement(element, parserContext)这一步完成的操作就是根据节点获取对应的解析器，之前已经注册过aspectj-autoproxy的解析器，那么这里获取到的就是AspectJAutoProxyBeanDefinitionParser，然后一起去看看它的parse方法

public BeanDefinition parse(Element element, ParserContext parserContext) {
	AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
	this.extendBeanDefinition(element, parserContext);
	return null;
}

这里要注意这一行代码比较重要，AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element)，这段代码里创建注册一个很关键的bean到spring容器中

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
		BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		return null;
	} else {
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", -2147483648);
		beanDefinition.setRole(2);
		registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
		return beanDefinition;
	}
}

看看如果没有找到org.springframework.aop.config.internalAutoProxyCreator这个BeanDefinition，那么spring就会去创建一个BeanDefinition，其class类型就是AnnotationAwareAspectJAutoProxyCreator这个类，然后将这个类放入到spring对的容器中。其中还夹杂些关于aspectj-autoproxy相关的一些属性的解析，大家有兴趣自行研究，这里不做过多讨论。至此，spring解析aspectj-autoproxy这个标签的流程基本上就走完了。
在这里插入图片描述
spring解析aspectj-autoproxy节点的流程图如上，总结一句话，aspectj-autoproxy节点最终在spring中的表现，或者说转换的对象就是一个BeanDefinition对象，这个和bean节点是一样的，然后这个BeanDefinition的class是AnnotationAwareAspectJAutoProxyCreator，说明最终的bean一定是AnnotationAwareAspectJAutoProxyCreator的实例对象，那么这个对象有什么用，下边做详细的分析。

2.创建AOP代理对象

前边我们也解释过，AOP的最终的实现就是依赖代理对象的创建。依赖代理对象，我们可以对原对象进行增强处理。aspectj-autoproxy节点是启用AOP的关键所在，而这个节点在spring中最终的表现就是AnnotationAwareAspectJAutoProxyCreator对象，那么势必要深究这个对象的构造是怎么样的，完成了哪些功能。

(1)深究AnnotationAwareAspectJAutoProxyCreator对象

首先来我们来观察一下这个类的构造和继承关系图
在这里插入图片描述
有没有发现，一看这个图，我们就大概知道AnnotationAwareAspectJAutoProxyCreator是怎么工作的了，知道它是怎么创建代理对象的了。为什么呢？大家看看它是不是BeanPostProcessor的实现类，这个类在spring中太重要了啊。在我们分析getBean背后的机制的时候，这个类频繁的出现，它的作用就是可以在创建bean的时候，通过一些BeanPostProcessor来对bean进行修饰和处理，以实现个性化定制的bean，这就是spring的灵活之处。AnnotationAwareAspectJAutoProxyCreator是InstantiationAwareBeanPostProcessor的实现类，那么我们就要重点关注这个对象的postProcessBeforeInitialization和postProcessAfterInitialization这两个方法，这两个方法是在它的父类AbstractAutoProxyCreator中实现的，postProcessBeforeInitialization没有做任何处理，主要的逻辑都在postProcessAfterInitialization中

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	if (bean != null) {
		//构建一个key
		Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
		//如果需要被代理，那么就进行代理处理
		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
			//创建代理类的核心逻辑所在
			return this.wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}
...
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
	//已经创建代理的bean不需要再创建
	if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
		return bean;
	//不需要创建代理的bean直接跳过
	} else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
		return bean;
	//如果不是基础设施类或者需要跳过的类，那么就需要创建代理类
	} else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
		//关键代码，获取被增强的方法，如果有就创建代理
		Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
		if (specificInterceptors != DO_NOT_PROXY) {
			//添加如缓存
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			//创建代理类
			Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			//将代理放入缓存
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		} else {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}
	} else {
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}
}

代码真是又臭又长啊，看着脑阔疼，嗯，整理一张流程图，可能会更加清晰一些
在这里插入图片描述
从这张流程图，我们可以得出AnnotationAwareAspectJAutoProxyCreator实在创建bean的时候生效的，完成的工作就是看看这个bean是否需要创建代理，是否符合创建代理的要求。

(2)AOP生成代理类

上边已经分析过spring创建AOP代理类的整体过程，知道了AnnotationAwareAspectJAutoProxyCreator是继承BeanPostProcessor，解析来进行整体的细节分析

(2.1)获取增强方法和增强器

所谓增强器，就是我们用@Before和@After标记的处理方法。这一句的关键实现在哪里呢？getAdvicesAndAdvisorsForBean，就是这个方法，在这个方法中实现了获取增强器，具体的步骤可以研究一下，这个方法是再AbstractAdvisorAutoProxyCreator类中实现的

List<Advisor> advisors = this.findEligibleAdvisors(beanClass, beanName);

从这个方法名可以看出来，获取有资格的Advisor，什么是有资格的呢，切一起来看看

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	//获取增强器
	List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
	//过滤一遍
	List<Advisor> eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
	this.extendAdvisors(eligibleAdvisors);
	if (!eligibleAdvisors.isEmpty()) {
		eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
	}
	return eligibleAdvisors;
}

这里有一个关键方法findCandidateAdvisors，这个方法就是获取我们用注解标记的增强方法

protected List<Advisor> findCandidateAdvisors() {
	//虽然新版本提倡使用注解，但是还是要兼容老版本XML配置的方式，所以要调用父类的方法获取XML中配置的信息
	List<Advisor> advisors = super.findCandidateAdvisors();
	if (this.aspectJAdvisorsBuilder != null) {
		//获取注解中配置的
		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
	}
	return advisors;
}

为了兼容老版本，所以还会调用一遍父类的findCandidateAdvisors方法，来获取XML中配置的增强器。然后呢？显而易见，注解方式配置的增强其的获取就是通过buildAspectJAdvisors来获取的，这个方法比较关键，不过这个方法太长了，这里我就补贴出来了没大家可以仔细研究一下。这个方法主要干了些什么呢？

  1. 扫描所有的bean，找出使用@Aspect注解标记的bean
  2. 解析被@Aspect标记的bean中增强方法的表达式
  3. 将解析的数据放到缓存中
    主要就是这么四个步骤，第一步和第三步那都很简单，那种重点就在这第二步，这第二步是buildAspectJAdvisors方法中调用的this.advisorFactory.getAdvisors(factory)方法，这个方法又是一长串，首先在getAdvisorMethods方法中排除了@Pointcut标记的方法，然后返回进行处理
private List<Method> getAdvisorMethods(Class<?> aspectClass) {
	List<Method> methods = new ArrayList();
	ReflectionUtils.doWithMethods(aspectClass, (method) -> {
		if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
			methods.add(method);
		}
	});
	methods.sort(METHOD_COMPARATOR);
	return methods;
}

调用getAdvisorMethods获取到了需要处理的方法之后，spring开始遍历这些方法，可以预想到到，这个遍历肯定就是把所有的方法掏出来，找出@Before，@After等注解的相关信息，然后再做处理，接下来一起看看吧

while(var6.hasNext()) {
	Method method = (Method)var6.next();
	//获取增强方法
	Advisor advisor = this.getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
	if (advisor != null) {
		advisors.add(advisor);
	}
}
...
private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
	//查找增强方法
	AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
	if (aspectJAnnotation == null) {
		return null;
	} else {
		//将解析的信息封装为一个实例对象
		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);
		ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
		if (this.beanFactory != null) {
			ajexp.setBeanFactory(this.beanFactory);
		}
		return ajexp;
	}
}

这帖出来的代码我省略了很多，源码实在是太长了，大家一定要自己打开源码看一遍，才能理解。这里我们发现了查找增强方法的核心就在AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod方法中

protected static AbstractAspectJAdvisorFactory.AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
	Class[] var1 = ASPECTJ_ANNOTATION_CLASSES;
	int var2 = var1.length;
	for(int var3 = 0; var3 < var2; ++var3) {
		Class<?> clazz = var1[var3];
		AbstractAspectJAdvisorFactory.AspectJAnnotation<?> foundAnnotation = findAnnotation(method, clazz);
		if (foundAnnotation != null) {
			return foundAnnotation;
		}
	}
	return null;
}
...
private static <A extends Annotation> AbstractAspectJAdvisorFactory.AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
	A result = AnnotationUtils.findAnnotation(method, toLookFor);
	return result != null ? new AbstractAspectJAdvisorFactory.AspectJAnnotation(result) : null;
}

大家可以看一下ASPECTJ_ANNOTATION_CLASSES这个数组的内容***new Class[]{Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class}***，那么这一段代码的逻辑很显而易见了，就是找到method上的关于这些注解的信息，这个获取这个注解的方法也有点深，这里也不做细节展开讨论，主要是理解其思想。然后获取到注解之后，将注解里的信息封装成了一个AbstractAspectJAdvisorFactory.AspectJAnnotation对象，然后最后会封装一个InstantiationModelAwarePointcutAdvisorImpl对象返回，大家可以看看这个对象的构造方法中有一句代码this.instantiateAdvice(this.declaredPointcut)，这一句代码就是初始化Advisor的，会将注解转换成对应的对象

...
switch(aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
	if (this.logger.isDebugEnabled()) {
		this.logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
	}
	return null;
case AtAround:
	springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
	break;
case AtBefore:
	springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
	break;
case AtAfter:
	springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
	break;
case AtAfterReturning:
	springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
	AfterReturning afterReturningAnnotation = (AfterReturning)aspectJAnnotation.getAnnotation();
	if (StringUtils.hasText(afterReturningAnnotation.returning())) {
		((AbstractAspectJAdvice)springAdvice).setReturningName(afterReturningAnnotation.returning());
	}
	break;
case AtAfterThrowing:
	springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
	AfterThrowing afterThrowingAnnotation = (AfterThrowing)aspectJAnnotation.getAnnotation();
	if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
		((AbstractAspectJAdvice)springAdvice).setThrowingName(afterThrowingAnnotation.throwing());
	}
	break;
default:
	throw new UnsupportedOperationException("Unsupported advice type on method: " + candidateAdviceMethod);
}
...

多余的代码就不贴出来了，至此Advisor创建完毕了，即增强方法从注解到实例对象的转换过程完毕，接下来就是spring根据Advisor来创建代理对象以及对代理对象的方法进行增强了。

(2.2)创建代理类

获取到符合要求的增强方法之后，就要开始创建代理对象了。创建代理对象才是AOP的核心，创建AOP代理又是非常大的一堆代码

protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {
	if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
		AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)this.beanFactory, beanName, beanClass);
	}
	ProxyFactory proxyFactory = new ProxyFactory();
	proxyFactory.copyFrom(this);
	//判断是创建代理类而不是接口代理，检查proxyTargetClass属性的设置
	if (!proxyFactory.isProxyTargetClass()) {
		if (this.shouldProxyTargetClass(beanClass, beanName)) {
			proxyFactory.setProxyTargetClass(true);
		} else {
			this.evaluateProxyInterfaces(beanClass, proxyFactory);
		}
	}
	//获取所有的增强器
	Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
	//添加增强器
	proxyFactory.addAdvisors(advisors);
	//设置需要代理的类
	proxyFactory.setTargetSource(targetSource);
	this.customizeProxyFactory(proxyFactory);
	//冻结配置好的代理工厂，设置是否还允许修改代理工厂
	proxyFactory.setFrozen(this.freezeProxy);
	if (this.advisorsPreFiltered()) {
		proxyFactory.setPreFiltered(true);
	}
	//创建代理类
	return proxyFactory.getProxy(this.getProxyClassLoader());
}

代码挺长的，其实逻辑并不复杂，获取完增强器，spring会创建一个AOP的代理工厂，将增强器Advisor，代理的对象等相关信息都放到工厂的配置中，然后昨晚所有的准备工作，最后一行代码才是点睛之笔。proxyFactory.getProxy(this.getProxyClassLoader())是创建代理对象的所在

this.createAopProxy().getProxy(classLoader)；

这段代码有两个步骤，第一步先创建AopProxy对象，即代理的方式。我们都知道spring的代理有两种，一种是JDK动态代理，一种是CGLIB动态代理。spring是如何选用AOP代理方式的呢

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
		return new JdkDynamicAopProxy(config);
	} else {
		Class<?> targetClass = config.getTargetClass();
		if (targetClass == null) {
			throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
		} else {
			return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
		}
	}
}

代码先贴在这里，总结我们放后边一点点。创建完AopProxy之后，就要创建代理对象了，调用的是getProxy方法，接口代理和CGLIB代理创建代理对象是不同的

2) 接口代理

接口代理的AopProxy的实现类为JdkDynamicAopProxy。回想一下接口代理的使用方式（https://www.jianshu.com/p/07596979960d），首先是要实现InvocationHandler接口，传入被代理对象，然后利用Proxy类来创建代理对象，我们看一下JdkDynamicAopProxy的类结构
在这里插入图片描述
看看看，这样一来是不是spring的AOP也就不神秘了，它就是用了最基本的JDK的动态代理来创建代理对象的，不过JdkDynamicAopProxy对JDK动态代理进行了增强

public Object getProxy(@Nullable ClassLoader classLoader) {
	if (logger.isTraceEnabled()) {
		logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
	}
	Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
	this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
	return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

最后仍旧是借助于Proxy的newProxyInstance来创建的代理对象，Over。

2) CGLIB动态代理

CGLIB是一种开源的动态代理的方式，利用字节码操作工具为代理对象创建子对象，覆盖原来的方法进行增强。不过在最新的spring（本人看的是spring5）中，spring已经自己实现了CGLIB代理的方式，不过其个开源的使用方式差不多

...
Enhancer enhancer = this.createEnhancer();
if (classLoader != null) {
	enhancer.setClassLoader(classLoader);
	if (classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {
		enhancer.setUseCache(false);
	}
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new CglibAopProxy.ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
Callback[] callbacks = this.getCallbacks(rootClass);
Class<?>[] types = new Class[callbacks.length];
for(x = 0; x < types.length; ++x) {
	types[x] = callbacks[x].getClass();
}
enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
return this.createProxyClassAndInstance(enhancer, callbacks);
...

一目了然，如果有童鞋不了解CGLIB，以及CGLIB的使用，可以参考这篇文章https://www.jianshu.com/p/d0427b4423ff，使用很简单，不再做多余的赘述。

五.反思与总结

1.JDK动态代理和CGLIB动态代理有什么区别

  1. JDK动态代理只能创建接口代理，不能为类创建代理
  2. CGLIB代理的方法不能用final修饰，因为其动态为代理对象创建子类，会覆盖父类的方法，final方法不能被重写

2.什么情况下会使用JDK动态代理和CGLIB代理

  1. 当类实现了接口的时候，默认使用的是JDK的动态代理
  2. 当类实现了接口，可以强制使用CGLIB动态代理 ，参照https://blog.csdn.net/baidu_20608025/article/details/85704791
  3. 当类没有实现接口，则强制使用CGLIB动态代理
一直在梦想路上
关注
专栏目录
死磕Spring源码-常见底层核心注解
java小马哥的博客
07-23 2306
一:Spring框架功能整体介绍 二：根据Spring架构图可知，包含以上的模块儿。下面逐个模块儿进行解释。 1：IOC 和 DI（Inversion of Control I DependencyInjection ( IoC/DI ） 最最最最核心的功能是 ：通过多级缓存解决循环依赖问题。 2：Spring Core Container： 模块作用：Core ...
源码分析：Spring是如何实现AOP的？
热门推荐
果子爸聊技术
11-29 1万+
Spring AOP硬核文章，建议收藏！！！
Spring源码探究——Spring的AOP是如何实现的
weixin_48680790的博客
05-02 497
前言&准备工作 在之前的源码分析文章中，我们介绍了IoC的执行流程，在本篇文章中，我们来解析一些Spring的另一大功能——AOP。 准备工作 1.准备被切入的方法方法 @Component public class HelloService { public void sayHello(){ System.out.println("HELLO WORLD"); } } 2.准备切面 @Aspect @Component public class LogAspect { @Bef
Spring AOP 实现机制
DHG2012的博客
07-30 1057
使用注解定义Spring AOP允许使用注解来定义pointcuts。常见的注解有@Before@After@Around等，它们内部隐含了一个pointcut。
spring aop怎么实现_源码分析：Spring是如何实现AOP的？
weixin_42492000的博客
01-25 182
什么是AOPAOP(Aspect Oriented Programming)，即面向切面编程，是Spring框架中的一个核心内容，主要目的是对业务逻辑进行隔离，让业务代码更加关注于实现功能，降低耦合度举个例子，AOP的典型使用场景就是日志和安全，比如我们要记录一段代码的执行时间，很容易想到的方法就是在执行的开始处打印一个时间，在执行的结尾处再打印一个时间，两个时间相减就是代码真正的执行时间。但这样...
源码分析-Spring AOP是如何实现的？（一）
佛系程序员
01-19 379
本文目的 此篇博客主要目的是要理清Spring中实现AOP这一编程思想的的具体思路。由于Spring AOP的源码非常多且繁琐，所以这里着重介绍Spring对AOP的核心源码实现，一些辅助功能的源码实现细节不会过多讲述，同时，我们知道，Spring 对目标类的代理有两种方式----JDK Proxy和Cglib,本篇主要以JDK这种代理方式来分析。既然说Spring AOP的源码，需要读者至少要知道AOP如何使用，同时也要对Spring IOC的实现流程或者说bean的生命周期有部分了解，这部分知识本文不会
spring aop 是如何实现的?
u013328649的博客
09-30 172
spring aop 是如何实现的? 要分析这个议题,我们以spring cache为例 spring cache是如何与spring整合的 在spring项目 spring-context下的META-INF\spring.handlers定义了 org.springframework.cache.config.CacheNamespaceHandler, 使用xml方式,次handler就...
死磕spring源码系列-深度解析spring aop
08-30
死磕spring源码系列-深度解析spring_aop
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
在 Spring AOP 中，`org.springframework.aop.framework.JdkDynamicAopProxy` 类实现了 `InvocationHandler` 接口，当代理对象的方法被调用时，实际会执行 `JdkDynamicAopProxy.invoke()` 方法。这个方法会检查并...
死磕spring源码系列-SpringAop十分钟快速入门
08-30
死磕spring源码系列-SpringAop十分钟快速入门
死磕Spring之AOP篇 - Spring AOP常见面试题
m0_57077948的博客
03-14 1076
代理模式是一种结构性设计模式，通过代理类为其他对象提供一种代理以控制对这个对象的访问。AOP 代理是 AOP 框架中 AOP 的实现，主要分为静态代理和动态代理，如下：静态代理：代理类需要实现被代理类所实现的接口，同时持有被代理类的引用，新增处理逻辑，进行拦截处理，不过方法还是由被代理类的引用所执行。静态代理通常需要由开发人员在编译阶段就定义好，不易于维护。常用 OOP 继承和组合相结合AspectJ，在编辑阶段会织入 Java 字节码，且在运行期间会进行增强。
Spring原理篇(14)--Spring AOP源码的实现＜一＞
wenaicoo的博客
11-03 1952
@TOC# Spring系列 记录在程序走的每一步___auth:huf
Spring实现AOP的四种方式
zxh66的专栏
10-22 361
先了解AOP的相关术语: 1.通知(Advice): 通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。 2.连接点(Joinpoint): 程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。 3.切入点(Pointcut) 通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例
1000行代码读懂Spring（二）- 在Spring中实现AOP
weixin_34184561的博客
01-20 64
2019独角兽企业重金招聘Python工程师标准>>> ...
spirng5源码-springAOP模块
automannn
11-20 257
1.spirngAOP模块的组成 2.AOP联盟对AOP的定义 AOP技术是与语言无关的一种源码解决方案。具有特定的AOP规范，同时具有特定的组织：AOP联盟; 3.springAOP对AOP联盟的支持 4.springAOP对AOP联盟标准的实现 5.springAOP对AOP流程的抽象设计 6.springAOP对自动代理的设计与支持 自动代理的实现原理： 通过bean工厂的 Bean后置处理器，达到移花接木的目的。 即将原来的实例..
代理模式
Lin_home
11-06 93
一、代理 代理有三种模式 在静态代理模式之下，我们显示地创建代理类，代理类持有被代理类的对象，实现与被代理类的相同接口，并且增添相应的业务逻辑，以达到代理的效果。 1、静态代理 代码步骤: 1.接口 2.真实角色 3.代理角色 4.客户端访问代理角色 假设：房东要出租，但是不想要麻烦自己，然后就是装让给中介，就现在，房东是出租房，中介也是出租房，但是中介是管理房东房 /** * @Author Lin_Home * @Date 2020/8/18 14:51 * @Version 1.0
Spring源码之AOP实现
qq_38706652的博客
08-20 1447
Spring源码之AOP
Spring AOP ① 实现原理
最新发布
weixin_37711738的博客
09-08 662
AOP的实现原理分3个阶段收集切面生成代理使用代理对象。
Spring之AOP源码解析
qq_36851469的博客
05-07 558
三、面向切面的 Spring 切面提供了取代继承和委托的另一种可选方案，而且在很多场景下更清晰简洁。在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称为切面（ aspect ）。这样做有两个好处：首先，现在每个关注点都集中于一个地方，而不是分散到多处代码中；其次，服务模块...
Caused by: java.lang.ClassNotFoundException: org.springframework.aop.framework.AopConfigException
02-02
Caused by: java.lang.ClassNotFoundException: org.springframework.aop.framework.AopConfigException 是一个Java异常，表示在运行时找不到指定的类。具体来说，这个异常是由于缺少名为org.springframework.aop....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值