@Override
   public Result invoke(final Invocation invocation) throws RpcException {
       // 检查当前Invoker是否已销毁
       checkWhetherDestroyed();

       // binding attachments into invocation.
       // 将RpcContext中的attachment添加到Invocation中
       Map<String, Object> contextAttachments = RpcContext.getContext().getObjectAttachments();
       if (contextAttachments != null && contextAttachments.size() != 0) {
           ((RpcInvocation) invocation).addObjectAttachments(contextAttachments);
       }

       // 通过Directory获取Invoker对象列表 RegistryDirectory内部会调用Router完成服务路由的功能
       List<Invoker<T>> invokers = list(invocation); // 先去服务目录选择
       // 再通过SPI加载对应的负载均衡实现
       LoadBalance loadbalance = initLoadBalance(invokers, invocation);// 再负载均衡
       RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);

       // 委托给具体的集群容错子类 实现调用
       return doInvoke(invocation, invokers, loadbalance);
   }

protected Invoker<T> select(LoadBalance loadbalance, Invocation invocation,
                                List<Invoker<T>> invokers, List<Invoker<T>> selected) throws RpcException {

        if (CollectionUtils.isEmpty(invokers)) {
            return null;
        }
        // 方法名称
        String methodName = invocation == null ? StringUtils.EMPTY_STRING : invocation.getMethodName();

        // 获取sticky配置，sticky表示粘滞连接，所谓粘滞连接是指Consumer会尽可能地调用同一个Provider节点，除非这个Provider无法提供服务
        boolean sticky = invokers.get(0).getUrl()
                .getMethodParameter(methodName, CLUSTER_STICKY_KEY, DEFAULT_CLUSTER_STICKY);

        //ignore overloaded method
        if (stickyInvoker != null && !invokers.contains(stickyInvoker)) {
            stickyInvoker = null;
        }
        //ignore concurrency problem
        if (sticky && stickyInvoker != null && (selected == null || !selected.contains(stickyInvoker))) {
            if (availablecheck && stickyInvoker.isAvailable()) {
                return stickyInvoker;
            }
        }

        // doSelect选择新的Invoker
        Invoker<T> invoker = doSelect(loadbalance, invocation, invokers, selected);

        if (sticky) {
            stickyInvoker = invoker;
        }
        return invoker;
    }

@Override
  public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
      // 2. 外层对ClusterInvoker进行切面包装 返回InterceptorInvokerNode （继承自AbstractClusterInvoker接口）
      return buildClusterInterceptors(
              // 1. 先doJoin获取最终要调用的Invoker对象 比如直接返回一个FailOverClusterInvoker
              doJoin(directory),
              directory.getUrl().getParameter(REFERENCE_INTERCEPTOR_KEY)
      );
  }
  
  // buildClusterInterceptors方法
  private <T> Invoker<T> buildClusterInterceptors(AbstractClusterInvoker<T> clusterInvoker, String key) {
      AbstractClusterInvoker<T> last = clusterInvoker;
      // ClusterInterceptor是SPI加载自动激活的扩展实现
      List<ClusterInterceptor> interceptors = ExtensionLoader.getExtensionLoader(ClusterInterceptor.class).getActivateExtension(clusterInvoker.getUrl(), key);

      if (!interceptors.isEmpty()) {
          for (int i = interceptors.size() - 1; i >= 0; i--) {
              // 将InterceptorInvokerNode收尾连接到一起，形成调用链
              final ClusterInterceptor interceptor = interceptors.get(i);
              final AbstractClusterInvoker<T> next = last;
              last = new InterceptorInvokerNode<>(clusterInvoker, interceptor, next);
          }
      }
      return last;
  }

@Override
 public <T> AbstractClusterInvoker<T> doJoin(Directory<T> directory) throws RpcException {
     // 直接委托给FailoverClusterInvoker
     return new FailoverClusterInvoker<>(directory);
 }

@Override
   @SuppressWarnings({"unchecked", "rawtypes"})
   public Result doInvoke(Invocation invocation, final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
       List<Invoker<T>> copyInvokers = invokers;
       checkInvokers(copyInvokers, invocation);
       String methodName = RpcUtils.getMethodName(invocation);
       // 获取重试次数
       int len = getUrl().getMethodParameter(methodName, RETRIES_KEY, DEFAULT_RETRIES) + 1;
       if (len <= 0) {
           // 默认重试次数是1
           len = 1;
       }
       // retry loop. 循环来实现重试

       // 最近的一次异常
       RpcException le = null; // last exception.
       // 记录已经尝试调用过的Invoker
       List<Invoker<T>> invoked = new ArrayList<Invoker<T>>(copyInvokers.size()); // invoked invokers.

       // 记录执行过的provider地址
       Set<String> providers = new HashSet<String>(len);
       for (int i = 0; i < len; i++) {
           //Reselect before retry to avoid a change of candidate `invokers`.
           //NOTE: if `invokers` changed, then `invoked` also lose accuracy.
           if (i > 0) {
               // 第二次进来就是重试的逻辑 需要再次走一遍 服务目录list（内部会走route服务路由）拉取最新的Invoker列表并检查
               checkWhetherDestroyed();
               // list重新从服务目录中获取集合
               copyInvokers = list(invocation);
               // check again
               checkInvokers(copyInvokers, invocation);
           }
           // AbstractClusterInvoker.select() 有自己的粘连逻辑（优先调用一个provider） 也会根据负载均衡算法来选出provider
           Invoker<T> invoker = select(loadbalance, invocation, copyInvokers, invoked);
           invoked.add(invoker);
           RpcContext.getContext().setInvokers((List) invoked);
           try {
               // 进行调用
               Result result = invoker.invoke(invocation);
               if (le != null && logger.isWarnEnabled()) {
                   logger.warn("Although retry the method " + methodName
                           + " in the service " + getInterface().getName()
                           + " was successful by the provider " + invoker.getUrl().getAddress()
                           + ", but there have been failed providers " + providers
                           + " (" + providers.size() + "/" + copyInvokers.size()
                           + ") from the registry " + directory.getUrl().getAddress()
                           + " on the consumer " + NetUtils.getLocalHost()
                           + " using the dubbo version " + Version.getVersion() + ". Last error is: "
                           + le.getMessage(), le);
               }
               return result;
           } catch (RpcException e) {
               if (e.isBiz()) { // biz exception. dubbo内部的biz异常
                   throw e;
               }
               // 记录异常
               le = e;
           } catch (Throwable e) {
               // 封装为rpc异常 然后记录下次重试
               le = new RpcException(e.getMessage(), e);
           } finally {
               // 记录已经尝试过的provider地址
               providers.add(invoker.getUrl().getAddress());
           }
       }
       // 超过重试次数 抛出异常
       throw new RpcException(le.getCode(), "Failed to invoke the method "
               + methodName + " in the service " + getInterface().getName()
               + ". Tried " + len + " times of the providers " + providers
               + " (" + providers.size() + "/" + copyInvokers.size()
               + ") from the registry " + directory.getUrl().getAddress()
               + " on the consumer " + NetUtils.getLocalHost() + " using the dubbo version "
               + Version.getVersion() + ". Last error is: "
               + le.getMessage(), le.getCause() != null ? le.getCause() : le);
   }

public class Application {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
        context.start();
        System.in.read();
    }

    @Configuration
    @EnableDubbo(scanBasePackages = "org.apache.dubbo.demo.provider")
    @PropertySource("classpath:/spring/dubbo-provider.properties")
    static class ProviderConfiguration {
        @Bean
        public RegistryConfig registryConfig() {
            RegistryConfig registryConfig = new RegistryConfig();
            registryConfig.setAddress("zookeeper://127.0.0.1:2181");
            return registryConfig;
        }
    }
}

@EnableDubboConfig
@DubboComponentScan
// @EnableDubbo注解来标注在spring boot应用上 来开启dubbo接口暴露、引用（dubbo的@Service、@Reference注解的扫描）。还有dubbo config配置初始化为bean的过程
// 主要功能在@EnableDubboConfig、@EnableComponentScan
public @interface EnableDubbo {
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
// 解析Dubbo 配置 （properties文件）的支持 导入了DubboConfigConfigurationRegistrar
public @interface EnableDubboConfig {

    /**
     * It indicates whether binding to multiple Spring Beans.
     *
     * @return the default value is <code>false</code>
     * @revised 2.5.9
     */
    boolean multiple() default true;

}

public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        // 获取EnableDubboConfig注解信息
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));

        // multiple的配置值 multiple就是 dubbo.applications（复数）这种多个配置
        boolean multiple = attributes.getBoolean("multiple");

        // Single Config Bindings
        // 注册Single配置Bean定义 内部主要是@EnableConfigurationBeanBindings注解再次import了具体配置bean定义的注册（ConfigurationBeanBindingsRegister）—
        // ，并且注册了对应的后置处理器去解析具体配置值
        registerBeans(registry, DubboConfigConfiguration.Single.class);

        if (multiple) { // Since 2.6.6 https://github.com/apache/dubbo/issues/3193
            registerBeans(registry, DubboConfigConfiguration.Multiple.class);
        }

        // Since 2.7.6
        registerCommonBeans(registry);
    }
}

public class ConfigurationBeanBindingsRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private ConfigurableEnvironment environment;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableConfigurationBeanBindings.class.getName()));

        AnnotationAttributes[] annotationAttributes = attributes.getAnnotationArray("value");

        ConfigurationBeanBindingRegistrar registrar = new ConfigurationBeanBindingRegistrar();

        registrar.setEnvironment(environment);

        for (AnnotationAttributes element : annotationAttributes) {
        // 对定义好的每个binding（其实就是properties文件中的属性）去注册对应的Bean定义 且注册一个bean后置处理器（ConfigurationBeanBindingPostProcessor）去绑定配置中的值（值来源于properties文件解析之后放入的environment中）
            registrar.registerConfigurationBeanDefinitions(element, registry);
        }
    }

// DubboComponentScanRegistrar dubbo扫描@Service和@Reference注解 解析
public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        // 获取要扫描的包路径
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);

        // 注册路径下处理@Service注解的Bean后置处理器
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);

        // @since 2.7.6 Register the common beans
        registerCommonBeans(registry);
    }

//此方法中处理 dubbo @Service注解
   @Override
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

       // @since 2.7.5
       // 注册DubboBootstrapApplicationListener 监听事件之后启动Dubbo
       registerBeans(registry, DubboBootstrapApplicationListener.class);

       // 注解上解析出需要扫描的路径
       Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);

       if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
           // 去注册ServiceBean
           registerServiceBeans(resolvedPackagesToScan, registry);
       } else {
           if (logger.isWarnEnabled()) {
               logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
           }
       }

   }

@Override
   public PropertyValues postProcessPropertyValues(
           PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

       InjectionMetadata metadata = findInjectionMetadata(beanName, bean.getClass(), pvs);
       try {
           // 也是借助metadata.inject来实现的注入字段
           metadata.inject(bean, beanName, pvs);
       } catch (BeanCreationException ex) {
           throw ex;
       } catch (Throwable ex) {
           throw new BeanCreationException(beanName, "Injection of @" + getAnnotationType().getSimpleName()
                   + " dependencies is failed", ex);
       }
       return pvs;
   }

@Override
     protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {

         Class<?> injectedType = pd.getPropertyType();

         Object injectedObject = getInjectedObject(attributes, bean, beanName, injectedType, this);

         ReflectionUtils.makeAccessible(method);

         method.invoke(bean, injectedObject);

     }
     
     // getInjectedObject方法
     protected Object getInjectedObject(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
                                    InjectionMetadata.InjectedElement injectedElement) throws Exception {

     String cacheKey = buildInjectedObjectCacheKey(attributes, bean, beanName, injectedType, injectedElement);

     Object injectedObject = injectedObjectsCache.get(cacheKey);

     if (injectedObject == null) {
     // doGetInjectedBean 方法 dubbo实现了ReferenceBean注入的关键
         injectedObject = doGetInjectedBean(attributes, bean, beanName, injectedType, injectedElement);
         // Customized inject-object if necessary
         injectedObjectsCache.putIfAbsent(cacheKey, injectedObject);
     }

     return injectedObject;

 }

/**
    * 实现的doGetInjectedBean方法来解析@DubboReference字段 来注入dubbo服务（最终是ReferenceBean的代理对象）
    * @param attributes
    * @param bean
    * @param beanName
    * @param injectedType
    * @param injectedElement
    * @return
    * @throws Exception
    */
   @Override
   protected Object doGetInjectedBean(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
                                      InjectionMetadata.InjectedElement injectedElement) throws Exception {
       /**
        * The name of bean that annotated Dubbo's {@link Service @Service} in local Spring {@link ApplicationContext}
        * 先在本地的Spring上下文中查找ServiceBean是否存在
        * ServiceBean: com.xxx.DemoService:group:version
        */
       String referencedBeanName = buildReferencedBeanName(attributes, injectedType);

       /**
        * The name of bean that is declared by {@link Reference @Reference} annotation injection
        * 根据@Reference注解的属性和注入的类属性 来生成referenceBean的名称
        */
       String referenceBeanName = getReferenceBeanName(attributes, injectedType);

       // 从缓存中取ReferenceBean 如果不存在 会去创建（内部的配置也会注入）
       ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referenceBeanName, attributes, injectedType);

       // 是否是本地的bean 上面的ServiceBeanName来在容器中寻找
       boolean localServiceBean = isLocalServiceBean(referencedBeanName, referenceBean, attributes);

       // 容器中注册referenceBean 
       registerReferenceBean(referencedBeanName, referenceBean, attributes, localServiceBean, injectedType);

       cacheInjectedReferenceBean(referenceBean, injectedElement);

       // 最终返回注入给@Reference变量是 ReferenceBean的代理对象 是个FactoryBean 代理逻辑在其get()方法中（远程bean）
       return getOrCreateProxy(referencedBeanName, referenceBean, localServiceBean, injectedType);
   }

private Object getOrCreateProxy(String referencedBeanName, ReferenceBean referenceBean, boolean localServiceBean,
                                    Class<?> serviceInterfaceType) {
        if (localServiceBean) { // If the local @Service Bean exists, build a proxy of Service
            // 本地的dubbo服务 创建jdk动态代理 内部直接调用ServiceBean的ref的方法
            return newProxyInstance(getClassLoader(), new Class[]{serviceInterfaceType},
                    newReferencedBeanInvocationHandler(referencedBeanName));
        } else {
            // 如果需要export 帮助依赖的ServiceBean 去 export
            exportServiceBeanIfNecessary(referencedBeanName); // If the referenced ServiceBean exits, export it immediately
            // get方法创建代理对象
            return referenceBean.get();
        }
    }

getObject()方法：

  @Override
    public Object getObject() {
        // 调用get生成代理对象
        return get();
    }

// 定义了一个WeakHashMap
	private static volatile WeakHashMap<java.lang.reflect.Type, Integer> knownTypes = new WeakHashMap<java.lang.reflect.Type, Integer>();

* <p> Like most collection classes, this class is not synchronized.
* A synchronized <tt>WeakHashMap</tt> may be constructed using the
* {@link Collections#synchronizedMap Collections.synchronizedMap}
* method.

# 1.CMS初始标记 标记GCRoots直接关联的对象 会STW 第一个内存是老年代 第二个内存数据是堆内存
0.245: [GC (CMS Initial Mark) [1 CMS-initial-mark: 32776K(53248K)] 41701K(99328K), 0.0061676 secs] [Times: user=0.01 sys=0.00, real=0.01 secs]


# 2. CMS并发标记，进行GCRoots分析，标记存活对象，不会STW，用户线程和GC线程并发，且多个GC线程并行去标记
0.251: [CMS-concurrent-mark-start]
0.270: [CMS-concurrent-mark: 0.004/0.020 secs] [Times: user=0.08 sys=0.01, real=0.02 secs]


# 3. CMS在重新标记之前会预清理 
#   preClean：清理 card marking 标记的 dirty card，更新引用记录。方便后边并发扫描的时候去扫描跨代引用。
#   abortable-preclean：调节final-remark阶段的时机，这个阶段不一定存在
0.270: [CMS-concurrent-preclean-start]
0.272: [CMS-concurrent-preclean: 0.001/0.001 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.272: [CMS-concurrent-abortable-preclean-start]
0.291: [CMS-concurrent-abortable-preclean: 0.004/0.019 secs] [Times: user=0.09 sys=0.00, real=0.02 secs]

# 4. CMS的最终重新标记 会STW 可以多线程并行去标记 会STW，修正之前并发执行用户线程带来的浮动对象或者引用的错误。
0.291: [GC (CMS Final Remark) [YG occupancy: 17928 K (46080 K)]0.291: [Rescan (parallel) , 0.0082702 secs]0.299: [weak refs processing, 0.0000475 secs]0.299: [class unloading, 0.0002451 secs]0.299: [scrub symbol table, 0.0003183 secs]0.300: [scrub string table, 0.0001611 secs][1 CMS-remark: 49164K(53248K)] 67093K(99328K), 0.0091462 secs] [Times: user=0.04 sys=0.00, real=0.01 secs]

# 5. CMS的并发清理 进行GC回收垃圾 多线程执行
0.300: [CMS-concurrent-sweep-start]
0.300: [CMS-concurrent-sweep: 0.000/0.000 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

# 6.CMS的并发重置 清除对象的标记（比如对象的三色标记），为下次GC做准备
0.300: [CMS-concurrent-reset-start]
0.300: [CMS-concurrent-reset: 0.000/0.000 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]