spring @EnableAspectJAutoProxy背后的那些事(spring AOP源码赏析)

在这个注解比较流行的年代里,当我们想要使用spring 的某些功能时只需要加上一行代码就可以了,比如:

@EnableAspectJAutoProxy开启AOP,

@EnableTransactionManagement开启spring事务管理,

@EnableCaching开启spring缓存

@EnableWebMvc 开启webMvc

.....

对于我们使用者而言十分简单便利,然而,其背后所做的事,却远远比一个注解复杂的多了,本篇只是简略的介绍一下@EnableAspectJAutoProxy背后所发生的那些事,了解其工作原理,才能更好的运用,并从中领略大师的智慧.

废话不多说,先来看一下源码:

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(AspectJAutoProxyRegistrar.class)

public @interface EnableAspectJAutoProxy {

    /**

     * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed

     * to standard Java interface-based proxies. The default is {@code false}.

     */

    boolean proxyTargetClass() default false;

    /**

     * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}

     * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.

     * Off by default, i.e. no guarantees that {@code AopContext} access will work.

     * @since 4.3.1

     */

    boolean exposeProxy() default false;

}

英文注解已经很详细了,这里简单介绍一下两个参数,一个是控制aop的具体实现方式,为true 的话使用cglib,为false的话使用java的Proxy,默认为false,第二个参数控制代理的暴露方式,解决内部调用不能使用代理的场景，默认为false.

这里核心是@Import(AspectJAutoProxyRegistrar.class);在AspectJAutoProxyRegistrar里,核心的地方是

        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

一个AOP的工具类,这个工具类的主要作用是把AnnotationAwareAspectJAutoProxyCreator这个类定义为BeanDefinition放到spring容器中,这是通过实现ImportBeanDefinitionRegistrar接口来装载的,具体装载过程不是本篇的重点,这里就不赘述,我们重点看AnnotationAwareAspectJAutoProxyCreator这个类.

首先看看这个类图:

从类图是可以大致了解AnnotationAwareAspectJAutoProxyCreator这个类的功能.它实现了一系列Aware的接口,在Bean装载的时候获取BeanFactory(Bean容器),Bean的ClassLoader,还实现了order接口,继承了PorxyConfig,ProxyConfig中主要封装了代理的通用处理逻辑,比如设置目标类,设置使用cglib还是java proxy等一些基础配置.

而能够让这个类参与到bean初始化功能,并为bean添加代理功能的还是因为它实现了BeanPostProcessor这个接口.这个接口的postProcessAfterInitialization方法会在bean初始化结束后(赋值完成)被调用,有关spring中bean初始化的过程可以参考我的另一篇博客:spring bean的装载过程简略赏析

这里先看一下最顶部的抽象类:AbstractAutoProxyCreator,这个抽象类主要抽象了实现代理的逻辑:

    @Override

    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

        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);

        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;

    }

当我们开启了EbableAspectJAutoProxy后,每次Bean的装配时,都会执行这段逻辑.前面主要是校验是否需要对bean进行代理(特殊的类,和已经被代理),核心逻辑在后面几行.getAdvicesAndAdvisorsForBean方法来获取所有符合条件的切面,具体的实现在子类,这里是抽象方法,获取切面后就是创建代理:

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());

    }

TargetSource中存放被代理的对象,这段代码主要是为了构建ProxyFactory,将配置信息(是否使用java proxy,是否threadlocal等),目标类,切面,传入ProxyFactory中,而在ProxyFactory中,会通过createAopProxy()方法创建代理工厂DefaultAopProxyFactory,由代理厂生成具体的代理对目标类进行代理:

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() || Proxy.isProxyClass(targetClass)) {

                return new JdkDynamicAopProxy(config);

            }

            return new ObjenesisCglibAopProxy(config);

        }

        else {

            return new JdkDynamicAopProxy(config);

        }

    }

可以看到,在这里有我们在注解中设置的参数的判断逻辑,是创建java代理,还是cglib代理，有关cglib的讲解请看cglib的使用.

我们主要看一下JdkDynamicAopProxy的实现，cglib其实差不多。

@Override

    public Object getProxy() {

        return getProxy(ClassUtils.getDefaultClassLoader());

    }

    @Override

    public Object getProxy(@Nullable ClassLoader classLoader) {

        if (logger.isDebugEnabled()) {

            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());

        }

        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);

        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

    }

findDefinedEqualsAndHashCodeMethods方法是为了查询被代理的接口是否包括equals和hashcode方法，这回影响到下面的调用。

可以看到InvocationHandler的实现就是this。我们看一下invoke方法的实现：

    @Override

    @Nullable

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        MethodInvocation invocation;

        Object oldProxy = null;

        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;

        Object target = null;

        try {

            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {

                // The target does not implement the equals(Object) method itself.

                return equals(args[0]);

            }

            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {

                // The target does not implement the hashCode() method itself.

                return hashCode();

            }

            else if (method.getDeclaringClass() == DecoratingProxy.class) {

                // There is only getDecoratedClass() declared -> dispatch to proxy config.

                return AopProxyUtils.ultimateTargetClass(this.advised);

            }

            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&

                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {

                // Service invocations on ProxyConfig with the proxy config...

                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);

            }

            Object retVal;

            if (this.advised.exposeProxy) {

                // Make invocation available if necessary.

                oldProxy = AopContext.setCurrentProxy(proxy);

                setProxyContext = true;

            }

            // Get as late as possible to minimize the time we "own" the target,

            // in case it comes from a pool.

            target = targetSource.getTarget();

            Class<?> targetClass = (target != null ? target.getClass() : null);

            // Get the interception chain for this method.

            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct

            // reflective invocation of the target, and avoid creating a MethodInvocation.

            if (chain.isEmpty()) {

                // We can skip creating a MethodInvocation: just invoke the target directly

                // Note that the final invoker must be an InvokerInterceptor so we know it does

                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.

                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);

            }

            else {

                // We need to create a method invocation...

                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

                // Proceed to the joinpoint through the interceptor chain.

                retVal = invocation.proceed();

            }

            // Massage return value if necessary.

            Class<?> returnType = method.getReturnType();

            if (retVal != null && retVal == target &&

                    returnType != Object.class && returnType.isInstance(proxy) &&

                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {

                // Special case: it returned "this" and the return type of the method

                // is type-compatible. Note that we can't help if the target sets

                // a reference to itself in another returned object.

                retVal = proxy;

            }

            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {

                throw new AopInvocationException(

                        "Null return value from advice does not match primitive return type for: " + method);

            }

            return retVal;

        }

        finally {

            if (target != null && !targetSource.isStatic()) {

                // Must have come from TargetSource.

                targetSource.releaseTarget(target);

            }

            if (setProxyContext) {

                // Restore old proxy.

                AopContext.setCurrentProxy(oldProxy);

            }

        }

    }

红色的代码是构建代理链，因为一个方法可能有多个切点匹配上，这个时候就需要构建一个链式的执行结构。

    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable 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;

    }

这里做了一个缓存，虽然new了一个对象最为key，但是对象的equals和hashcode方法都被重写了，所以没有问题，我们主要来看一下它是如何组装这个链式处理结构的：

    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(

            Advised config, Method method, @Nullable 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<>(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) {

                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;

                if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {

                    Interceptor[] interceptors = registry.getInterceptors(advisor);

                    interceptorList.addAll(Arrays.asList(interceptors));

                }

            }

            else {

                Interceptor[] interceptors = registry.getInterceptors(advisor);

                interceptorList.addAll(Arrays.asList(interceptors));

            }

        }

        return interceptorList;

    }

可以看到，它会遍历自己的所有建言，那这些advisor是从哪里来的呢：

还记得最开始,我们说过,AbstractAutoProxyCreator中通过getAdvicesAndAdvisorsForBean方法来装载切面,而这个是一个抽象方法,现在来看它的实现,在AbstractAdvisorAutoProxyCreator中:

@Override

    @Nullable

    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

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

        if (advisors.isEmpty()) {

            return DO_NOT_PROXY;

        }

        return advisors.toArray();

    }

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {

        List<Advisor> candidateAdvisors = findCandidateAdvisors();

        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);

        extendAdvisors(eligibleAdvisors);

        if (!eligibleAdvisors.isEmpty()) {

            eligibleAdvisors = sortAdvisors(eligibleAdvisors);

        }

        return eligibleAdvisors;

    }

findCandidateAdvisors又是一个抽象方法,主要功能就是找到候选的切面,为什么是候选的,因为它是加载了所有的切面,有些前面并不需要,在最底层AnnotationAwareAspectJAutoProxyCreator的实现类中也有:

protected List<Advisor> findCandidateAdvisors() {

        // Add all the Spring advisors found according to superclass rules.

        List<Advisor> advisors = super.findCandidateAdvisors();

        // Build Advisors for all AspectJ aspects in the bean factory.

        if (this.aspectJAdvisorsBuilder != null) {

            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());

        }

        return advisors;

    }

可以看到,通过aspectJAdvisorsBuilder来将该类关心的所有的切面装载进来,并添加到父类的集合里面.aspectJAdvisorsBuilder里缓存了advisor的信息,拿到切面后,通过findAdvisorsThatCanApply方法来筛选合适的切面,之后对切面进行排序(因为实现了Order接口),然后返回切面的链表.

好了,以上就是我们在写下@EnableAspectJAutoProxy后发生的事情,可以看到,spring在背后确实为我们做了许多事情,感谢开源的人们的努力!

总结:回过头看,spring抽象了最顶层的通用方法作为接口:,Bean生命周期处理,Order,排序,Aware接口,然后需要这些功能的类去实现这些接口,而实现了这些接口的类,会在特定的时候收到通知(观察者模式),在上面的例子中,还可以看到典型的模板模式,这也是spring中用的最多的模式之一了,对于代理类的创建采用工厂模式,将类的创建和拥有者解耦,具有高扩展性.从spring整个架构上来看,也正是由一个个接口组成的(面向接口),所以spring不仅是一个很好的工具,还是一本很好的教科书.

最后贴出spring源码地址:https://github.com/spring-projects/spring-framework.git

转载请注明出处!

BeanPostProcessor

巴特西

spring @EnableAspectJAutoProxy背后的那些事(spring AOP源码赏析)

最新文章

热门文章