Spring源码解析：（七）AOP的实现

最新推荐文章于 2022-11-06 12:16:04 发布
最新推荐文章于 2022-11-06 12:16:04 发布
阅读量116 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z591045/article/details/112175139
版权

AOP的实现

前言

上文中介绍了aop的思想和aop的使用及相关信息，本文将深入spring 中aop的源码实现。

正文

代理对象的生成时机

读者如果研读过ioc的源码后，应该了解到在aop的代理对象生成并不是在具体使用bean的时候调用getbean去生成，而是在ioc的bean初始化时候就已经完成。所以我们需要去定位到ioc中去寻求aop在什么时候进行代理的。

首先先访问AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object,
org.springframework.beans.factory.support.RootBeanDefinition)这个方法

/**
*
* 初始化Bean
包括Bean后置处理器初始化
Bean的⼀些初始化⽅法的执⾏init-method
Bean的实现的声明周期相关接⼝的属性注⼊
*/
protected Object initializeBean(final String beanName, final Object bean,
@Nullable RootBeanDefinition mbd) {
// 执⾏所有的AwareMethods
if (System.getSecurityManager() != null) {
	AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
		invokeAwareMethods(beanName, bean);
		return null;
		}, getAccessControlContext());
	}
else {
	invokeAwareMethods(beanName, bean);
	}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 执⾏所有的BeanPostProcessor#postProcessBeforeInitialization 初始化之前的处理器方法
	wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);
	}
try {
	// 这⾥就开始执⾏afterPropertiesSet（实现了InitializingBean接口）方法和initMethod
	invokeInitMethods(beanName, wrappedBean, mbd);
	}
catch (Throwable ex) {
	throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null),
		beanName, "Invocation of init method failed", ex);
	}
if (mbd == null || !mbd.isSynthetic()) {
	// 整个Bean初始化完成，执⾏后置处理器⽅法
	wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName);
	}
	return wrappedBean;
}

其次再追踪到AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization方法

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {
Object result = existingBean;
// 循环执行后置处理器
for (BeanPostProcessor processor : getBeanPostProcessors()) {
	Object current = processor.postProcessAfterInitialization(result,beanName);
	if (current == null) {
		return result;
		}
	result = current;
	}
return result;
}

在这里插入图片描述
创建代理对象的后置处理器AbstractAutoProxyCreator#postProcessAfterInitialization

 @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String
            beanName) {
        if (bean != null) {
// 检查下该类是否已经暴露过了（可能已经创建了，比如A依赖B时，创建A时候，就会先去创建B。
// 当真正需要创建B时，就没必要再代理一次已经代理过的对象）,避免重复创建
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

AbstractAutoProxyCreator#wrapIfNecessary

/**
* Wrap the given bean if necessary, i.e. if it is eligible for being
proxied.
* @param bean the raw bean instance
* @param beanName the name of the bean
* @param cacheKey the cache key for metadata access
* @return a proxy wrapping the bean, or the raw bean instance as-is
*/
 protected Object wrapIfNecessary(Object bean, String beanName, Object
            cacheKey) {
	// targetSourcedBeans包含，说明前⾯创建过
        if (StringUtils.hasLength(beanName) &&
                this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(),
                beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
	// Create proxy if we have advice.
	// 得到所有候选Advisor，对Advisors和bean的⽅法双层遍历匹配，最终得到⼀个
        List<Advisor>，即specificInterceptors
        Object[] specificInterceptors =
                getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
		// 重点，创建代理对象
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new
                            SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

终于找到了调用生成代理对象的时机，接下来继续看下关键的创建代理对象方法AbstractAutoProxyCreator#createProxy

/**
* Create an AOP proxy for the given bean.
* 为指定 bean 创建代理对象
*/
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 proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);
		// 根据一些情况判断是否要设置proxyTargetClass=true
        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
		// 把指定和通过拦截对象合并, 并都适配成Advisor
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
		// 设置参数
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);
        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
		// 上次准备做完就开始创建代理
        return proxyFactory.getProxy(getProxyClassLoader());
    }

接着跟进到ProxyFactory中

public class ProxyFactory extends ProxyCreatorSupport {
        public Object getProxy(ClassLoader classLoader) {
        //ProxyFactory创建AopProxy, 然后用AopProxy创建Proxy, 所以这里重要的是看获取的AopProxy
        // 对象是什么,然后进去看怎么创建动态代理, 提供了两种：jdk proxy, cglib
            return createAopProxy().getProxy(classLoader);
        }
    }
     public class ProxyCreatorSupport extends AdvisedSupport {
        private AopProxyFactory aopProxyFactory;
        public ProxyCreatorSupport() {
            this.aopProxyFactory = new DefaultAopProxyFactory();
        }
        protected final synchronized AopProxy createAopProxy() {
            if (!this.active) {
                activate();
            }
        //先获取创建AopProxy的工厂, 再由此创建AopProxy
            return getAopProxyFactory().createAopProxy(this);
        }
        public AopProxyFactory getAopProxyFactory() {
            return this.aopProxyFactory;
        }
    }

流程就是用AopProxyFactory创建AopProxy, 再用AopProxy创建代理对象，这里的AopProxyFactory默
认是DefaultAopProxyFactory，看他的createAopProxy方法

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
        @Override
        public AopProxy createAopProxy(AdvisedSupport config) throws
                AopConfigException {
            if (config.isOptimize() || config.isProxyTargetClass() ||
                    hasNoUserSuppliedProxyInterfaces(config)) {
                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.");
                }
                if (targetClass.isInterface()) {
                    return new JdkDynamicAopProxy(config);
                }
                return new ObjenesisCglibAopProxy(config);
            } else {
                return new JdkDynamicAopProxy(config);
            }
        }
        /**
* Determine whether the supplied {@link AdvisedSupport} has only the
* {@link org.springframework.aop.SpringProxy} interface specified (or no
`* proxy interfaces specified at all).
*/
 private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class<?>[] interfaces = config.getProxiedInterfaces();
        return (interfaces.length == 0 || (interfaces.length == 1 &&
                SpringProxy.class.equals(interfaces[0])));
    }
}``
这⾥决定创建代理对象是用JDK Proxy，还是用 Cglib 了，最简单的从使用方面使用来说：设置
proxyTargetClass=true强制使用Cglib 代理，什么参数都不设并且对象类实现了接口则默认用JDK 代
理，如果没有实现接口则也必须用Cglib
ProxyFactory#getProxy(java.lang.ClassLoader)
------ CglibAopProxy#getProxy(java.lang.ClassLoader)

```java
  @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
        }
        try {
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for
                    creating a CGLIB proxy");
                    Class<?> proxySuperClass = rootClass;
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }
            // Validate the class, writing log messages as necessary.
            validateClassIfNecessary(proxySuperClass, classLoader);
            // 配置 Cglib 增强
            Enhancer enhancer = 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
                    ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
            Callback[] callbacks = getCallbacks(rootClass);
            Class<?>[] types = new Class<?>[callbacks.length];
            for (int x = 0; x < types.length; x++) {
                types[x] = callbacks[x].getClass();
            }
            // fixedInterceptorMap only populated at this point, after getCallbacks
            call above
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap,
                    this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);
        // 生成代理类，并且创建一个代理类的实例
            return createProxyClassAndInstance(enhancer, callbacks);
        }
        catch (CodeGenerationException | IllegalArgumentException ex) {
            throw new AopConfigException("Could not generate CGLIB subclass of " +
                    this.advised.getTargetClass() +
                    ": Common causes of this problem include using a final class or a
                    non-visible class",
            ex);
        }
        catch (Throwable ex) {
        // TargetSource.getTarget() failed
            throw new AopConfigException("Unexpected AOP exception", ex);
        }
    }

所以aop实现的整体调用流程如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#i
nitializeBean
调用
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#a
pplyBeanPostProcessorsAfterInitialization
调用
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProce
ssAfterInitialization（后置处理器AbstractAutoProxyCreator完成bean代理对象创建）
调用
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNec
essary
调用
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createPro
xy （在这一步把委托对象的aop增强和通过拦截进行合并，最终给代理对象）
调用
org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy
调用
org.springframework.aop.framework.CglibAopProxy#getProxy(java.lang.ClassLoader
)

后话

本文详细的通过代码梳理了spring的aop的实现过程，希望能帮助读者深入理解的aop的实现和其思想。

一白丁
关注
专栏目录
Spring AOP实现流程、源码分析
程序员劝退师的博客
03-07 819
前言 AOP字面意思解释就是面向切面编程，面向切面编程是一种编程模型，我们知道JAVA是面向对象的也就是OOP，OOP这种面向对象的编程适用于定义纵向的关系，但是并不适用定义横向的关系。那么应对这种OOP的存在的这些不利，AOP面向切面的编程模型作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。 AO
深入解析Spring AOP源码：从原理到实现，全方位掌握Java AOP编程精髓
最新发布
12-13
在源码解析中，我们通常会关注以下几个关键点： 1. 切面类的解析：如何识别和处理切面类，提取切点和通知信息。 2. 创建代理：根据目标对象的类型选择JDK动态代理或CGLIB代理，并生成相应的代理类。 3. 代理类的调用...
Spring原理篇(14)--Spring AOP源码的实现＜一＞
wenaicoo的博客
11-03 1954
@TOC# Spring系列 记录在程序走的每一步___auth:huf
Spring源码系列： AOP实现
Zong_0915的博客
03-29 1775
Spring源码系列： AOP实现前言一. AOP的使用二. AOP的实现2.1 创建AnnotationAwareAspectJAutoProxyCreator2.1.1 注册或升级AnnotationAwareAspectJAutoProxyCreator2.1.2 处理 proxy-target-class 以及 expose-proxy 属性2.2 AnnotationAwareAspectJAutoProxyCreator的作用2.3 获取增强器2.3.1 获取增强器findCandidateAd
动态代理
weixin_45608102的博客
12-15 148
UsbShell.java package dontaidiali.service; /** * 目标接口 */ public interface UsbShell { float sell(int amount); } UsbKingFactory.java package dontaidiali.factory; import dontaidiali.service.UsbShell; /** * 目标类 */ public class UsbKingFactory implem
spring aop源码实现分析
weixin_33906657的博客
06-06 104
AOP就是面向切面编程，我们可以从几个层面来实现AOP。 在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。 spring AOP是Spring框架面向切面的编程思想，AOP采用一种称为“横切”的技术，将涉及多业务流程的通用功能抽取并单独封装，形成独立的切面，在合适的时机将这些切面横向切入到业务流程指定的位置中。 AOP到底能做什...
Spring AOP源码深度解析：掌握Java高级编程核心技术
12-13
了解了这些核心概念后，我们可以通过以下步骤来实现Spring AOP： 1. **定义切面类（Aspect）**：创建包含通知方法的类，并使用@Aspect注解标记。 2. **定义切点（Pointcut）**：使用@Pointcut注解声明切点表达式，...
SpringAOP源码解析：AOP拦截器链的构建与执行流程
本文将深入探讨Spring AOP源码中AOP拦截器链的构建与执行流程。首先，我们将介绍文章的背景和目的，以及Spring AOP的概念和作用。接下来，我们将概述本文的内容和结构。 ## 1.1 背景和目的 随着软件开发的复杂性...
spring源代码分析：aop的实现
05-03
本文将深入Spring源码，探索AOP的实现原理。 首先，我们需要理解AOP的基本概念。AOP允许开发者定义“切面”（Aspect），一个切面封装了跨越多个对象的横切关注点。切点（Pointcut）定义了这些关注点在何时何地被...
五、Spring源码分析——Spring Aop
08-11
了解了Spring AOP的基本概念后，我们可以进一步深入源码，探究如何创建代理、如何执行通知以及如何实现切点匹配。这对于理解Spring的工作原理，以及优化和扩展Spring AOP功能具有重要意义。 在实际开发中，Spring ...
Spring AOP 常用的四种实现方式的代码
04-05
NULL 博文链接：https://kavinhub.iteye.com/blog/1511252
Spring源代码解析（七）：Spring AOP中对拦截器调用的实现
jiwenke的专栏
08-01 253
前面我们分析了Spring AOP实现中得到Proxy对象的过程，下面我们看看在Spring AOP中拦截器链是怎样被调用的，也就是Proxy模式是怎样起作用的，或者说Spring是怎样为我们提供AOP功能的； 在JdkDynamicAopProxy中生成Proxy对象的时候： [code] return Proxy.newProxyInstance(classLoader,...
Spring AOP源码解析——AOP动态代理原理和实现方式
weixin_33730836的博客
10-31 181
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring原理篇(15)--Spring AOP源码的实现＜AOP终＞
wenaicoo的博客
11-04 1238
@TOC# Spring系列 记录在程序走的每一步___auth:huf 昨天细心的同学已经发现一个问题; 就是在Spring5.X 版本 或者是SpringBoot 2.x版本 不管类是否实现了接口 都是使用的CGLIB 接口;. 在Spring5.X 版本 Spring默认就是使用CGLIB接口 在Spring 4开头的版本 使用的是JDK代理 但是到了5.X以后 我们可以在 AOP自动装载过程中发现一个 AopAutoConfiguration 以下是源码 原因如下: 翻译过来就是 :我们应该使
Spring源码探究——Spring的AOP是如何实现的
weixin_48680790的博客
05-02 501
前言&准备工作 在之前的源码分析文章中，我们介绍了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怎么实现_源码分析：Spring是如何实现AOP的？
weixin_42492000的博客
01-25 187
什么是AOPAOP(Aspect Oriented Programming)，即面向切面编程，是Spring框架中的一个核心内容，主要目的是对业务逻辑进行隔离，让业务代码更加关注于实现功能，降低耦合度举个例子，AOP的典型使用场景就是日志和安全，比如我们要记录一段代码的执行时间，很容易想到的方法就是在执行的开始处打印一个时间，在执行的结尾处再打印一个时间，两个时间相减就是代码真正的执行时间。但这样...
SpringAop实现原理及源码解析
Java动物园的专栏
12-31 624
本文基于 SpringBoot5.1.8.RELEASE 版本源码解析 Spring IOC源码解析(1) Spring IOC源码解析(2) Spring拓展点及调用顺序总结 我们直接通过SpringBoot项目来调试，建议阅读此文前先熟悉 Spring IOC源码，对SpringBoot自动装配有了解。 目录1. AnnotationAwareAspectJAutoProxyCreator2. AnnotationAwareAspectJAutoProxyCreator的注册3. AOP源码解析4..
Spring AOP 超详细源码解析
热门推荐
qq_41956014的博客
11-06 1万+
spring aop 源码超详细解析
AOP及源码分析
Laiyer_的博客
03-07 607
1.AOP是什么？为啥需要AOP，有哪些应用场景 AOP就是面向切面编程。 有时候我们需要对JAR包中类的方法织入一些代码，但是jar包中的代码我们是无法修改的，这时候怎么办呢？ （1）继承，继承重写方法； （2）聚合，并在在方法中调用此类对象方法； （3）静态代理，其实和聚合是差不多的了，只不过需要将方法改为引用类同名的方法。一般来说是和委托类共同实现同样的接口，并聚合委托类对象，重写接口方法时候调用此对象的同名方法；缺点：如果方法太多，工程量巨大。 而动态代理就是在程序运行期间动态的生成此静态代理对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值