Spring AOP源码分析

柔光的暖阳◎ 2022-01-28 12:04 294阅读 0赞

# [Spring AOP源码分析][Spring AOP] #

看下Spring核心的代理类

![1179709-20190420003840686-2072516926.png][]

**AbstractAutoProxyCreator**  这是Spring核心的一个代理类，他的子类：

![1179709-20190420003659694-1637776423.png][]

接口: BeanFactoryAware 的作用

![1179709-20190420004127901-590039876.png][]

初始化之前执行一个方法：

@Override
        public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
            Object cacheKey = getCacheKey(beanClass, beanName);
    
            if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
                if (this.advisedBeans.containsKey(cacheKey)) {
                    return null;
                }
                if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                    this.advisedBeans.put(cacheKey, Boolean.FALSE);
                    return null;
                }
            }
    
            // Create proxy here if we have a custom TargetSource.
            // Suppresses unnecessary default instantiation of the target bean:
            // The TargetSource will handle target instances in a custom fashion.
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName); //通过BeanClass和BeanName找到目标来源
            if (targetSource != null) {
                if (StringUtils.hasLength(beanName)) { 
                    this.targetSourcedBeans.add(beanName);
                }
                Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
                Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);  //创建一个代理对象
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            }
    
            return null;
        }

createProxy(beanClass, beanName, specificInterceptors, targetSource); 点击进入
    这是做代理的：

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);
    
            if (!proxyFactory.isProxyTargetClass()) {
                if (shouldProxyTargetClass(beanClass, beanName)) {
                    proxyFactory.setProxyTargetClass(true);
                }
                else {
                    evaluateProxyInterfaces(beanClass, proxyFactory);
                }
            }
    
            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());
        }

进入方法：  return proxyFactory.getProxy(getProxyClassLoader());

public Object getProxy(@Nullable ClassLoader classLoader) {
            return createAopProxy().getProxy(classLoader);
        }

查看：两个代理方式

![1179709-20190420004855695-223638849.png][]

看下jdk的动态代理：

@Override
        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); //通过反射生成代理类
            findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
            return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
        }

cglib：这个是不需要反射的哦 通过字节码

@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);
    
                // Configure CGLIB Enhancer...
                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);
    
                // Generate the proxy class and create a proxy instance.
                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);
            }
        }

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
            enhancer.setInterceptDuringConstruction(false);
            enhancer.setCallbacks(callbacks);
            return (this.constructorArgs != null && this.constructorArgTypes != null ?
                    enhancer.create(this.constructorArgTypes, this.constructorArgs) :   //查看此方法
                    enhancer.create());  
        }

点进去查看：

public Object create(Class[] argumentTypes, Object[] arguments) {
            classOnly = false;
            if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
                throw new IllegalArgumentException("Arguments must be non-null and of equal length");
            }
            this.argumentTypes = argumentTypes;
            this.arguments = arguments;
            return createHelper();  //创建Helper  点进去就是代理
        }

查看：

private Object createHelper() {
            preValidate();
            Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                    ReflectUtils.getNames(interfaces),
                    filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
                    callbackTypes,
                    useFactory,
                    interceptDuringConstruction,
                    serialVersionUID);
            this.currentKey = key;
            Object result = super.create(key);
            return result;
        }

看下CglibAopProxy：

![1179709-20190420011853619-1197041225.png][]

适配器，有好多中。我们可以通过debug去获取查看。

也可以参考这个博客：https://www.cnblogs.com/lulu638/p/4474698.html

![1179709-20190420125652245-478116710.png][]

posted @ 2019-04-20 01:45 [toov5][] 阅读(...) 评论(...) [编辑][Link 1] 收藏

[Spring AOP]: https://www.cnblogs.com/toov5/p/10739715.html
[1179709-20190420003840686-2072516926.png]: /images/20220128/94e3c21e749744beb85f06ae6ff60e1b.png
[1179709-20190420003659694-1637776423.png]: /images/20220128/dea4e2b2cb664768a143f29064b8d32d.png
[1179709-20190420004127901-590039876.png]: /images/20220128/5e09807aec2c403fb5b83152d6e5d3c4.png
[1179709-20190420004855695-223638849.png]: /images/20220128/e28b5826b9c7444a8b0ccc4109abf11d.png
[1179709-20190420011853619-1197041225.png]: /images/20220128/464faa5482ce4b0ca6b15304b0aa16df.png
[1179709-20190420125652245-478116710.png]: /images/20220128/8fa71f730e6040abb274962e837fd9e6.png
[toov5]: https://www.cnblogs.com/toov5/
[Link 1]: https://i.cnblogs.com/EditPosts.aspx?postid=10739715