关于spring:Spring-AOP源码学习AOP的入口

前言

  开启AOP性能后，AOP的逻辑是如何开始进行的。

一、Bean的生命周期

  要讲AOP就必须理解Spring Bean的生命周期，AOP的逻辑是在Bean初始化后这个阶段开始的。Spring Bean的生命周期简略上图：
 

二、AOP

（一）@EnableAspectJAutoProxy

  Spring中应用该注解开启AOP性能。该注解会注册一个AutoProxyCreator【AnnotationAwareAspectJAutoProxyCreator、AspectJAwareAdvisorAutoProxyCreator】相干的类到IOC容器中，AutoProxyCreator相干的类实现了InstantiationAwareBeanPostProcessor接口，即在Bean实例化前后会执行AOP的一些前置筹备操作。

• 其中AbstractAutoProxyCreator实现了BeanFactoryAware接口，是咱们事务和aop导入进来的后置处理器的顶级父类；

• 在AbstractAutoProxyCreator postProcessBeforeInstantiation实例化前办法中，会进行AOP切面Bean的缓存（是Advice、PointCut、Advisor根底Bean类型就间接跳过不解析）；
   

  /**  AbstractAutoProxyCreator
     * 在咱们的创立Bean的流程中还没调用结构器来实例化bean的时候进行调用(实例化前后)
     * 咱们的aop 解析切面 以及事务解析事务注解都是在这里实现的
     * @param beanClass 以后正在创立的bean的class对象
     * @param beanName beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        //构建咱们的缓存key
        Object cacheKey = getCacheKey(beanClass, beanName);
  
        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            //如果被解析过 间接返回
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            /**
             * 判断是不是根底的bean
             * 判断是不是应该跳过 (aop解析间接解析出咱们的切面信息(并且把咱们的切面信息进行保留)，而事务在这里是不会解析的)
             */
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }
  
        /**
         * 这个中央个别是不会生成代理对象的,除非咱们的容器中有TargetSourceCreator 并且咱们的bean须要实现
         * TargetSource接口
         */
        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;
    }

  （二）创立Proxy代理对象

• 在AbstractAutoProxyCreator postProcessAfterInitialization初始化后办法中【每个Bean在创立的时候都会调用】，会进行AOP代理对象的创立，次要办法：wrapIfNecessary；
   

  /**  AbstractAutoProxyCreator
     * 在该后置办法中，AOP的代理对象在这生成
     * @param bean bean实例
     * @param beanName bean的名称
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            //获取缓存key
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //找到适合的就会被代理
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

  wrapIfNecessary办法如下：
   

  /**  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) {
        //曾经被解决过
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //不须要加强的
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //是不是根底的bean 是不是须要跳过的
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
  
        //如果咱们有告诉的话,就创立代理对象
        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;
    }

• 创立代理的外围办法：createProxy（基于ProxyFactory）。其中真正的创立代理对象的办法是ProxyFactory.getProxy办法；
   

  /**  
     * Create a new proxy according to the settings in this factory.
     * <p>Can be called repeatedly. Effect will vary if we've added
     * or removed interfaces. Can add and remove interceptors.
     * <p>Uses the given class loader (if necessary for proxy creation).
     * @param classLoader the class loader to create the proxy with
     * (or {@code null} for the low-level proxy facility's default)
     * @return the proxy object
     */
    public Object getProxy(@Nullable ClassLoader classLoader) {
        //createAopProxy() 用来获取咱们的代理工厂
        return createAopProxy().getProxy(classLoader);
    }

  createAopProxy办法会判断应用JDK动静代理还是CGLIB
   

  • CGLIB代理形式在第一次执行AOP操作的时候可能耗时会比拟长，因为须要生成新的字节码文件；
  • 总的状况，CGLIB和JDK的形式性能都差不多；然而相比应用原生的AspectJ，性能还是要差上一些。AspectJ是基于字节码编制技术，不借助于Proxy对象实现。
     

  /**
     * 实现类DefaultAopProxyFactory createAopProxy
     * @param config 用来为咱们指定咱们advisor信息
     * 该办法用来创立咱们的代理对象
     * 所咱们的targetClass对象实现了接口，且  ProxyTargetClass 没有指定强制的走cglib代理,那么就是创立jdk代理
     * 咱们代理的类没有实现接口，那么会间接走cglib代理
     * 若咱们   ProxyTargetClass 指定为false 且代理类是接口才会走jdk代理 否在咱们还是cglib代理
     * @return
     * @throws AopConfigException
     */
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        //判断咱们是否前置指定应用cglib代理ProxyTargetClass =true  fasle
        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.");
            }
            //所targetClass是接口 应用的就是jdk代理
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            //cglib代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            //动静代理
            return new JdkDynamicAopProxy(config);
        }
    }

  // 实现类JdkDynamicAopProxy getProxy办法
  @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);
    }
  
    /**
     * Finds any {@link #equals} or {@link #hashCode} method that may be defined
     * on the supplied set of interfaces.
     * @param proxiedInterfaces the interfaces to introspect
     */
    private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
        for (Class<?> proxiedInterface : proxiedInterfaces) {
            Method[] methods = proxiedInterface.getDeclaredMethods();
            for (Method method : methods) {
                if (AopUtils.isEqualsMethod(method)) {
                    this.equalsDefined = true;
                }
                if (AopUtils.isHashCodeMethod(method)) {
                    this.hashCodeDefined = true;
                }
                if (this.equalsDefined && this.hashCodeDefined) {
                    return;
                }
            }
        }
    }

  创立完的代理对象就会保留到DefaultSingletonBeanRegistry的单例池singletonObjects中，之后getBean()获取到的就是这个单例池中的代理对象。

  后续思考针对AOP的一些优化措施，特地是盘绕告诉，在遇到所有AOP的性能瓶颈点的时候根本都是盘绕告诉。