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

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

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

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

在 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 的性能瓶颈点的时候根本都是盘绕告诉。

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

前言

一、Bean 的生命周期

二、AOP

（一）@EnableAspectJAutoProxy

（二）创立 Proxy 代理对象