//实例计数器
   private static final AtomicInteger INSTANCE_COUNTER = new AtomicInteger();
   //实例过多警告值
   private static final AtomicBoolean WARNED_TOO_MANY_INSTANCES = new AtomicBoolean();
   //实际数量限制
   private static final int INSTANCE_COUNT_LIMIT = 64;
   private static final long MILLISECOND_NANOS = TimeUnit.MILLISECONDS.toNanos(1);
   //资源泄漏检测器
   private static final ResourceLeakDetector<HashedWheelTimer> leakDetector = ResourceLeakDetectorFactory.instance()
           .newResourceLeakDetector(HashedWheelTimer.class, 1);
   //工作线程状态更新
   private static final AtomicIntegerFieldUpdater<HashedWheelTimer> WORKER_STATE_UPDATER =
           AtomicIntegerFieldUpdater.newUpdater(HashedWheelTimer.class, "workerState");
   //泄漏值
   private final ResourceLeakTracker<HashedWheelTimer> leak;
   //工作对象
   private final Worker worker = new Worker();
   //工作线程
   private final Thread workerThread;

   public static final int WORKER_STATE_INIT = 0;
   public static final int WORKER_STATE_STARTED = 1;
   public static final int WORKER_STATE_SHUTDOWN = 2;
   @SuppressWarnings({ "unused", "FieldMayBeFinal" })
   private volatile int workerState; // 0 - init, 1 - started, 2 - shut down
   //tick的时长，也就是指针多久转一格
   private final long tickDuration;
   //时间轮数组
   private final HashedWheelBucket[] wheel;
   // 这是一个标示符，用来快速计算任务应该呆的格子。
   private final int mask;
   //开始时间已初始化
   private final CountDownLatch startTimeInitialized = new CountDownLatch(1);
   //任务队列
   private final Queue<HashedWheelTimeout> timeouts = PlatformDependent.newMpscQueue();
   //关闭的任务队列
   private final Queue<HashedWheelTimeout> cancelledTimeouts = PlatformDependent.newMpscQueue();
   //挂起超时次数
   private final AtomicLong pendingTimeouts = new AtomicLong(0);
   //最大挂起超时次数
   private final long maxPendingTimeouts;
   //开始时间
   private volatile long startTime;

public HashedWheelTimer(
           ThreadFactory threadFactory, // 用来创建worker线程
           long tickDuration,// tick的时长，也就是指针多久转一格
           TimeUnit unit, // tickDuration的时间单位
           int ticksPerWheel, // 一圈有几格
           boolean leakDetection, // 是否开启内存泄露检测
           long maxPendingTimeouts  //最大挂起超时次数
   ) {

       if (threadFactory == null) {
           throw new NullPointerException("threadFactory");
       }
       if (unit == null) {
           throw new NullPointerException("unit");
       }
       if (tickDuration <= 0) {
           throw new IllegalArgumentException("tickDuration must be greater than 0: " + tickDuration);
       }
       if (ticksPerWheel <= 0) {
           throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
       }

       // 将ticksPerWheel标准化为2的幂并初始化轮子.
       wheel = createWheel(ticksPerWheel);
       // 这是一个标示符，用来快速计算任务应该呆的格子。
       // 我们知道，给定一个deadline的定时任务，其应该呆的格子=deadline%wheel.length.但是%操作是个相对耗时的操作，所以使用一种变通的位运算代替：
       // 因为一圈的长度为2的n次方，mask = 2^n-1后低位将全部是1，然后deadline&mast == deadline%wheel.length
       // java中的HashMap也是使用这种处理方法
       mask = wheel.length - 1;

       // 转换成纳秒处理
       long duration = unit.toNanos(tickDuration);

       // 校验是否存在溢出。即指针转动的时间间隔不能太长而导致tickDuration*wheel.length>Long.MAX_VALUE
       if (duration >= Long.MAX_VALUE / wheel.length) {
           throw new IllegalArgumentException(String.format(
                   "tickDuration: %d (expected: 0 < tickDuration in nanos < %d",
                   tickDuration, Long.MAX_VALUE / wheel.length));
       }

       if (duration < MILLISECOND_NANOS) {
           if (logger.isWarnEnabled()) {
               logger.warn("Configured tickDuration %d smaller then %d, using 1ms.",
                           tickDuration, MILLISECOND_NANOS);
           }
           this.tickDuration = MILLISECOND_NANOS;
       } else {
           this.tickDuration = duration;
       }

       // 创建worker线程
       workerThread = threadFactory.newThread(worker);

       // 这里默认是启动内存泄露检测：当HashedWheelTimer实例超过当前cpu可用核数*4的时候，将发出警告
       leak = leakDetection || !workerThread.isDaemon() ? leakDetector.track(this) : null;

       this.maxPendingTimeouts = maxPendingTimeouts;

       if (INSTANCE_COUNTER.incrementAndGet() > INSTANCE_COUNT_LIMIT &&
           WARNED_TOO_MANY_INSTANCES.compareAndSet(false, true)) {
           //发起警告
           reportTooManyInstances();
       }
   }

private static HashedWheelBucket[] createWheel(int ticksPerWheel) {
       if (ticksPerWheel <= 0) {
           throw new IllegalArgumentException(
                   "ticksPerWheel must be greater than 0: " + ticksPerWheel);
       }
       if (ticksPerWheel > 1073741824) {
           throw new IllegalArgumentException(
                   "ticksPerWheel may not be greater than 2^30: " + ticksPerWheel);
       }
       // 初始化ticksPerWheel的值为不小于ticksPerWheel的最小2的n次方
       ticksPerWheel = normalizeTicksPerWheel(ticksPerWheel);
       // 初始化wheel数组
       HashedWheelBucket[] wheel = new HashedWheelBucket[ticksPerWheel];
       for (int i = 0; i < wheel.length; i ++) {
           wheel[i] = new HashedWheelBucket();
       }
       return wheel;
   }

// 初始化ticksPerWheel的值为不小于ticksPerWheel的最小2的n次方
   private static int normalizeTicksPerWheel(int ticksPerWheel) {
       int normalizedTicksPerWheel = 1;
       while (normalizedTicksPerWheel < ticksPerWheel) {
           normalizedTicksPerWheel <<= 1;
       }
       return normalizedTicksPerWheel;
   }

// 启动时间轮。这个方法其实不需要显示的主动调用，因为在添加定时任务（newTimeout()方法）的时候会自动调用此方法。
   // 这个是合理的设计，因为如果时间轮里根本没有定时任务，启动时间轮也是空耗资源
   public void start() {
       // 判断当前时间轮的状态，如果是初始化，则启动worker线程，启动整个时间轮；如果已经启动则略过；如果是已经停止，则报错
       // 这里是一个Lock Free的设计。因为可能有多个线程调用启动方法，这里使用AtomicIntegerFieldUpdater原子的更新时间轮的状态
       switch (WORKER_STATE_UPDATER.get(this)) {
       	 //如果时间轮还没有启动,则更改状态并启动
           case WORKER_STATE_INIT:
               if (WORKER_STATE_UPDATER.compareAndSet(this, WORKER_STATE_INIT, WORKER_STATE_STARTED)) {
                   workerThread.start();
               }
               break;
           //如果当前时间轮已经启动,则跳出该逻辑
           case WORKER_STATE_STARTED:
               break;
           //如果是关闭状态,抛出无法启动异常
           case WORKER_STATE_SHUTDOWN:
               throw new IllegalStateException("cannot be started once stopped");
           //如果工作状态未指定,则表示该程序异常,直接error
           default:
               throw new Error("Invalid WorkerState");
       }

       // 等待worker线程初始化时间轮的启动时间
       while (startTime == 0) {
           try {
               startTimeInitialized.await();
           } catch (InterruptedException ignore) {
               // Ignore - it will be ready very soon.
           }
       }
   }

public Set<Timeout> stop() {
        // worker线程不能停止时间轮，也就是加入的定时任务，不能调用这个方法。
        // 不然会有恶意的定时任务调用这个方法而造成大量定时任务失效
        if (Thread.currentThread() == workerThread) {
            throw new IllegalStateException(
                    HashedWheelTimer.class.getSimpleName() +
                            ".stop() cannot be called from " +
                            TimerTask.class.getSimpleName());
        }
        // 尝试CAS替换当前状态为“停止：2”。如果失败，则当前时间轮的状态只能是“初始化：0”或者“停止：2”。直接将当前状态设置为“停止：2“
        if (!WORKER_STATE_UPDATER.compareAndSet(this, WORKER_STATE_STARTED, WORKER_STATE_SHUTDOWN)) {
            // workerState can be 0 or 2 at this moment - let it always be 2.
            if (WORKER_STATE_UPDATER.getAndSet(this, WORKER_STATE_SHUTDOWN) != WORKER_STATE_SHUTDOWN) {
                INSTANCE_COUNTER.decrementAndGet();
                if (leak != null) {
                    boolean closed = leak.close(this);
                    assert closed;
                }
            }

            return Collections.emptySet();
        }

        try {
            boolean interrupted = false;
            //如果工作线程存活
            while (workerThread.isAlive()) {
                //中断工作线程
                //interrupt()不能中断在运行中的线程，它只能改变中断状态而已。
                workerThread.interrupt();
                try {
                    //工作线程加入本地线程
                    workerThread.join(100);
                } catch (InterruptedException ignored) {
                    interrupted = true;
                }
            }
            //如果发现线程已经被打上中断标识
            if (interrupted) {
                //改变当前线程状态
                Thread.currentThread().interrupt();
            }
        } finally {
            INSTANCE_COUNTER.decrementAndGet();
            if (leak != null) {
                boolean closed = leak.close(this);
                assert closed;
            }
        }
        return worker.unprocessedTimeouts();
    }

public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
        // 参数校验
        if (task == null) {
            throw new NullPointerException("task");
        }
        if (unit == null) {
            throw new NullPointerException("unit");
        }

        long pendingTimeoutsCount = pendingTimeouts.incrementAndGet();
        //待处理超时数 pendingTimeoutsCount 大于或等于允许的最大挂起
        if (maxPendingTimeouts > 0 && pendingTimeoutsCount > maxPendingTimeouts) {
            pendingTimeouts.decrementAndGet();
            throw new RejectedExecutionException("Number of pending timeouts ("
                + pendingTimeoutsCount + ") is greater than or equal to maximum allowed pending "
                + "timeouts (" + maxPendingTimeouts + ")");
        }
        // 如果时间轮没有启动，则启动
        start();

        //将超时添加到超时队列，该队列将在下一个时钟处理。
        //在处理过程中，所有排队的HashedWheelTimeouts都将添加到正确的HashedWheelBucket中。
        long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;

        // 防止溢出。
        if (delay > 0 && deadline < 0) {
            deadline = Long.MAX_VALUE;
        }
        // 这里定时任务不是直接加到对应的格子中，而是先加入到一个队列里，然后等到下一个tick的时候，会从队列里取出最多100000个任务加入到指定的格子中
        HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
        timeouts.add(timeout);
        return timeout;
    }

private final class Worker implements Runnable {
        private final Set<Timeout> unprocessedTimeouts = new HashSet<Timeout>();

        private long tick;
        //... 省略方法
 }

@Override
public void run() {
           // 初始化startTime.只有所有任务的的deadline都是想对于这个时间点
           startTime = System.nanoTime();
           if (startTime == 0) {
               // 由于System.nanoTime()可能返回0，甚至负数。并且0是一个标示符，用来判断startTime是否被初始化，所以当startTime=0的时候，重新赋值为1
               startTime = 1;
           }

           // 唤醒阻塞在start()的线程
           startTimeInitialized.countDown();
           // 只要时间轮的状态为WORKER_STATE_STARTED，就循环的“转动”tick，循环判断响应格子中的到期任务
           do {
               // waitForNextTick方法主要是计算下次tick的时间, 然后sleep到下次tick
               // 返回值就是System.nanoTime() - startTime, 也就是Timer启动后到这次tick, 所过去的时间
               final long deadline = waitForNextTick();
               if (deadline > 0) {   // 可能溢出或者被中断的时候会返回负数, 所以小于等于0不管
                   // 获取tick对应的格子索引
                   int idx = (int) (tick & mask);
                   // 移除被取消的任务
                   processCancelledTasks();
                   HashedWheelBucket bucket =
                           wheel[idx];
                   // 从任务队列中取出任务加入到对应的格子中
                   transferTimeoutsToBuckets();
                   System.out.println("bucket"+bucket+",idx"+idx);
                   // 过期执行格子中的任务
                   bucket.expireTimeouts(deadline);
                   tick++;
               }
           } while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_STARTED);

           // 这里应该是时间轮停止了，清除所有格子中的任务，并加入到未处理任务列表，以供stop()方法返回
           for (HashedWheelBucket bucket: wheel) {
               bucket.clearTimeouts(unprocessedTimeouts);
           }
           // 将还没有加入到格子中的待处理定时任务队列中的任务取出，如果是未取消的任务，则加入到未处理任务队列中，以供stop()方法返回
           for (;;) {
               HashedWheelTimeout timeout = timeouts.poll();
               if (timeout == null) {
                   break;
               }
               if (!timeout.isCancelled()) {
                   unprocessedTimeouts.add(timeout);
               }
           }
           // 处理取消的任务
           processCancelledTasks();
       }

// 将newTimeout()方法中加入到待处理定时任务队列中的任务加入到指定的格子中
      private void transferTimeoutsToBuckets() {
          // 每次tick只处理10w个任务，以免阻塞worker线程
          // adds new timeouts in a loop.
          for (int i = 0; i < 100000; i++) {
              HashedWheelTimeout timeout = timeouts.poll();
              //System.out.println("当前times.size"+timeouts.size());
              // 如果没有任务了，直接跳出循环
              if (timeout == null) {
                  // all processed
                  break;
              }
              // 还没有放入到格子中就取消了，直接略过
              if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
                  // Was cancelled in the meantime.
                  continue;
              }
              // 计算任务需要经过多少个tick
              long calculated = timeout.deadline / tickDuration;
              // 计算任务的轮数
              timeout.remainingRounds = (calculated - tick) / wheel.length;

              //如果任务在timeouts队列里面放久了, 以至于已经过了执行时间, 这个时候就使用当前tick, 也就是放到当前bucket, 此方法调用完后就会被执行.
              final long ticks = Math.max(calculated, tick); // Ensure we don't schedule for past.
              System.out.println("tick:"+ticks);
              int stopIndex = (int) (ticks & mask);
              // 将任务加入到响应的格子中
              HashedWheelBucket bucket = wheel[stopIndex];
              bucket.addTimeout(timeout);
          }
      }b

public class ReferenceBean<T> extends ReferenceConfig<T> implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {

	//省略一部分代码

	//获取服务接口
    @Override
    public Object getObject() {
        return get();
    }

    @Override
    @SuppressWarnings({"unchecked"})
    public void afterPropertiesSet() throws Exception {
    	//此处省略 配置校验代码
        Boolean b = isInit();
        if (b == null && getConsumer() != null) {
            b = getConsumer().isInit();
        }
        if (b != null && b) {
        	//发现服务
            getObject();
        }
    }
}

public synchronized T get() {
	//配置校验
       checkAndUpdateSubConfigs();
	//如果该服务已被销毁,则抛出异常
       if (destroyed) {
           throw new IllegalStateException("The invoker of ReferenceConfig(" + url + ") has already destroyed!");
       }
       //如果服务为空,则进行初始化,否则直接返回
       if (ref == null) {
           init();
       }
       return ref;
   }

private void init() {
       if (initialized) {
           return;
       }
       initialized = true;
       checkStubAndLocal(interfaceClass);
       //校验mock
       checkMock(interfaceClass);
       Map<String, String> map = new HashMap<String, String>();
       
	//省略对参数解析设置 ...
	
	//创建代理对象
       ref = createProxy(map);

       ApplicationModel.initConsumerModel(getUniqueServiceName(), buildConsumerModel(attributes));
   }

 private T createProxy(Map<String, String> map) {
     URL tmpUrl = new URL("temp", "localhost", 0, map);
     final boolean isJvmRefer;
     if (isInjvm() == null) {
         if (url != null && url.length() > 0) { // 如果指定了url，则不要进行本地引用
             isJvmRefer = false;
         } else {
             // 默认情况下，引用本地服务（如果有）
             isJvmRefer = InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl);
         }
     } else {
         isJvmRefer = isInjvm();
     }

     if (isJvmRefer) {
         URL url = new URL(Constants.LOCAL_PROTOCOL, Constants.LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
         invoker = refprotocol.refer(interfaceClass, url);
         if (logger.isInfoEnabled()) {
             logger.info("Using injvm service " + interfaceClass.getName());
         }
     } else {
         if (url != null && url.length() > 0) { // 用户指定的URL，可以是对等地址，也可以是注册中心的地址.
             String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
             if (us != null && us.length > 0) {
                 for (String u : us) {
                     URL url = URL.valueOf(u);
                     if (StringUtils.isEmpty(url.getPath())) {
                         url = url.setPath(interfaceName);
                     }
                     if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                         urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                     } else {
                         urls.add(ClusterUtils.mergeUrl(url, map));
                     }
                 }
             }
         } else { // x来自注册中心配置的URL
             checkRegistry();
             List<URL> us = loadRegistries(false);
             if (CollectionUtils.isNotEmpty(us)) {
                 for (URL u : us) {
                     URL monitorUrl = loadMonitor(u);
                     if (monitorUrl != null) {
                         map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
                     }
                     urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                 }
             }
             if (urls.isEmpty()) {
                 throw new IllegalStateException("No such any registry to reference " + interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config <dubbo:registry address=\"...\" /> to your spring config.");
             }
         }
//这里的refprotocol.refer即通过registryProtocol来进行发现
         if (urls.size() == 1) {
             invoker = refprotocol.refer(interfaceClass, urls.get(0));
         } else {
             List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
             URL registryURL = null;
             for (URL url : urls) {
                 invokers.add(refprotocol.refer(interfaceClass, url));
                 if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                     registryURL = url; // 使用最后一个注册表网址
                 }
             }
             if (registryURL != null) { // 注册表网址可用
                 // 仅在寄存器的群集可用时才使用RegistryAwareCluster
                 URL u = registryURL.addParameter(Constants.CLUSTER_KEY, RegistryAwareCluster.NAME);
                 //调用者包装关系将是：RegistryAwareClusterInvoker（StaticDirectory） - > FailoverClusterInvoker（RegistryDirectory，将执行路由） - > Invoker                    invoker = cluster.join(new StaticDirectory(u, invokers));
             } else { // 不是注册表网址，必须直接调用。
             	//这里要注意 cluster 最终都会被包装成 MockClusterWrapper(SPI的依赖注入) 
                 invoker = cluster.join(new StaticDirectory(invokers));
             }
         }
     }

     Boolean c = check;
     if (c == null && consumer != null) {
         c = consumer.isCheck();
     }
     if (c == null) {
         c = true; // default true
     }
     if (c && !invoker.isAvailable()) {
         // 如果提供者暂时不可用，则允许消费者稍后重试
         initialized = false;
         throw new IllegalStateException("Failed to check the status of the service " + interfaceName + ". No provider available for the service " + (group == null ? "" : group + "/") + interfaceName + (version == null ? "" : ":" + version) + " from the url " + invoker.getUrl() + " to the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
     }
     if (logger.isInfoEnabled()) {
         logger.info("Refer dubbo service " + interfaceClass.getName() + " from url " + invoker.getUrl());
     }
     /**
      * @since 2.7.0
      * ServiceData Store
      */
     MetadataReportService metadataReportService = null;
     if ((metadataReportService = getMetadataReportService()) != null) {
         URL consumerURL = new URL(Constants.CONSUMER_PROTOCOL, map.remove(Constants.REGISTER_IP_KEY), 0, map.get(Constants.INTERFACE_KEY), map);
         metadataReportService.publishConsumer(consumerURL);
     }
     // create service proxy
     return (T) proxyFactory.getProxy(invoker);
 }

@Override
   @SuppressWarnings("unchecked")
   public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
       url = url.setProtocol(url.getParameter(REGISTRY_KEY, DEFAULT_REGISTRY)).removeParameter(REGISTRY_KEY);
       //获取注册中心
       Registry registry = registryFactory.getRegistry(url);
       //如果是注册中心的服务,直接返回注册中心类型的invoker
       if (RegistryService.class.equals(type)) {
           return proxyFactory.getInvoker((T) registry, type, url);
       }

       // group="a,b" or group="*"
       Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(REFER_KEY));
       String group = qs.get(Constants.GROUP_KEY);
       if (group != null && group.length() > 0) {
           if ((COMMA_SPLIT_PATTERN.split(group)).length > 1 || "*".equals(group)) {
               return doRefer(getMergeableCluster(), registry, type, url);
           }
       }
       //发现服务
       return doRefer(cluster, registry, type, url);
   }
   
   private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
   	//创建并设置注册目录对象
       RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
       directory.setRegistry(registry);
       directory.setProtocol(protocol);
       // all attributes of REFER_KEY
       Map<String, String> parameters = new HashMap<String, String>(directory.getUrl().getParameters());
       URL subscribeUrl = new URL(CONSUMER_PROTOCOL, parameters.remove(REGISTER_IP_KEY), 0, type.getName(), parameters);
       if (!ANY_VALUE.equals(url.getServiceInterface()) && url.getParameter(REGISTER_KEY, true)) {
           directory.setRegisteredConsumerUrl(getRegisteredConsumerUrl(subscribeUrl, url));
           //注册服务
           registry.register(directory.getRegisteredConsumerUrl());
       }
       directory.buildRouterChain(subscribeUrl);
       //订阅服务
       directory.subscribe(subscribeUrl.addParameter(CATEGORY_KEY,
               PROVIDERS_CATEGORY + "," + CONFIGURATORS_CATEGORY + "," + ROUTERS_CATEGORY));
	//装饰Invoker
       Invoker invoker = cluster.join(directory);
       ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
       return invoker;
   }

/**
    * 将网址转换为调用者，如果网址已被引用，则不会重新引用。
    *
    * @param urls
    * @return invokers
    */
   private Map<String, Invoker<T>> toInvokers(List<URL> urls) {
       Map<String, Invoker<T>> newUrlInvokerMap = new HashMap<>();
       if (urls == null || urls.isEmpty()) {
           return newUrlInvokerMap;
       }
       Set<String> keys = new HashSet<>();
       String queryProtocols = this.queryMap.get(Constants.PROTOCOL_KEY);
       for (URL providerUrl : urls) {
           // 如果在参考侧配置协议，则仅选择匹配协议
           if (queryProtocols != null && queryProtocols.length() > 0) {
               boolean accept = false;
               String[] acceptProtocols = queryProtocols.split(",");
               for (String acceptProtocol : acceptProtocols) {
                   if (providerUrl.getProtocol().equals(acceptProtocol)) {
                       accept = true;
                       break;
                   }
               }
               if (!accept) {
                   continue;
               }
           }
           if (Constants.EMPTY_PROTOCOL.equals(providerUrl.getProtocol())) {
               continue;
           }
           if (!ExtensionLoader.getExtensionLoader(Protocol.class).hasExtension(providerUrl.getProtocol())) {
               logger.error(new IllegalStateException("Unsupported protocol " + providerUrl.getProtocol() +
                       " in notified url: " + providerUrl + " from registry " + getUrl().getAddress() +
                       " to consumer " + NetUtils.getLocalHost() + ", supported protocol: " +
                       ExtensionLoader.getExtensionLoader(Protocol.class).getSupportedExtensions()));
               continue;
           }
           URL url = mergeUrl(providerUrl);

           String key = url.toFullString(); // 参数URL已排序
           if (keys.contains(key)) { //重复的网址
               continue;
           }
           keys.add(key);
           // 缓存键是不与消费者方参数合并的URL，无论消费者如何组合参数，如果服务器URL更改，则再次引用
           Map<String, Invoker<T>> localUrlInvokerMap = this.urlInvokerMap; // 本地发现
           Invoker<T> invoker = localUrlInvokerMap == null ? null : localUrlInvokerMap.get(key);
           if (invoker == null) { // 不在缓存中，请再次发现
               try {
                   boolean enabled = true;
                   if (url.hasParameter(Constants.DISABLED_KEY)) {
                       enabled = !url.getParameter(Constants.DISABLED_KEY, false);
                   } else {
                       enabled = url.getParameter(Constants.ENABLED_KEY, true);
                   }
                   if (enabled) {
                       invoker = new InvokerDelegate<>(protocol.refer(serviceType, url), url, providerUrl);
                   }
               } catch (Throwable t) {
                   logger.error("Failed to refer invoker for interface:" + serviceType + ",url:(" + url + ")" + t.getMessage(), t);
               }
               if (invoker != null) { // Put new invoker in cache
                   newUrlInvokerMap.put(key, invoker);
               }
           } else {
               newUrlInvokerMap.put(key, invoker);
           }
       }
       keys.clear();
       return newUrlInvokerMap;
   }

@Override
   public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
       optimizeSerialization(url);

       // create rpc invoker.
       DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
       invokers.add(invoker);

       return invoker;
   }

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware {
 private static final long serialVersionUID = 213195494150089726L;
	/**
	 *此处省略其他代码
	 **/

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (!isExported() && !isUnexported()) {
            if (logger.isInfoEnabled()) {
                logger.info("The service ready on spring started. service: " + getInterface());
            }
            //服务暴露
            export();
        }
    }

    @Override
    @SuppressWarnings({"unchecked", "deprecation"})
    public void afterPropertiesSet() throws Exception {
    	 //此处省略....
        if (!supportedApplicationListener) {
            //服务暴露
            export();
        }
    }
 }

public synchronized void export() {
       if (provider != null) {
           if (export == null) {
               export = provider.getExport();
           }
           if (delay == null) {
               delay = provider.getDelay();
           }
       }
       if (export != null && !export) {
           return;
       }

       if (delay != null && delay > 0) {
           delayExportExecutor.schedule(new Runnable() {
               @Override
               public void run() {
                   doExport();
               }
           }, delay, TimeUnit.MILLISECONDS);
       } else {
           doExport();
       }
   }

protected synchronized void doExport() {
	//省略判断代码
	doExportUrls();
}

  	private void doExportUrls() {
       //加载注册中心的配置
       List<URL> registryURLs = loadRegistries(true);
       //把使用的协议注册到注册中心 
       for (ProtocolConfig protocolConfig : protocols) {
           doExportUrlsFor1Protocol(protocolConfig, registryURLs);
       }
   }

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
	 //省略判断代码
    // 导出服务
    String contextPath = protocolConfig.getContextpath();
    if ((contextPath == null || contextPath.length() == 0) && provider != null) {
        contextPath = provider.getContextpath();
    }

    String host = this.findConfigedHosts(protocolConfig, registryURLs, map);
    Integer port = this.findConfigedPorts(protocolConfig, name, map);
    URL url = new URL(name, host, port, (contextPath == null || contextPath.length() == 0 ? "" : contextPath + "/") + path, map);

    if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
            .hasExtension(url.getProtocol())) {
        url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
    }

    String scope = url.getParameter(Constants.SCOPE_KEY);
    // 没有配置时不导出
    if (!Constants.SCOPE_NONE.equalsIgnoreCase(scope)) {
        // 导出本地服务
        if (!Constants.SCOPE_REMOTE.equalsIgnoreCase(scope)) {
            exportLocal(url);
        }
        // 导出远程服务
        if (!Constants.SCOPE_LOCAL.equalsIgnoreCase(scope)) {
            if (logger.isInfoEnabled()) {
                logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
            }
            if (registryURLs != null && !registryURLs.isEmpty()) {
                //将服务都注册到当前已有的注册中心上去
                for (URL registryURL : registryURLs) {
                    url = url.addParameterIfAbsent(Constants.DYNAMIC_KEY, registryURL.getParameter(Constants.DYNAMIC_KEY));
                    //判断是否有监控中心
                    URL monitorUrl = loadMonitor(registryURL);
                    if (monitorUrl != null) {
                        url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
                    }
                    if (logger.isInfoEnabled()) {
                        logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                    }
			//对于providers，这用于启用自定义代理以生成invoker
                    String proxy = url.getParameter(Constants.PROXY_KEY);
                    if (StringUtils.isNotEmpty(proxy)) {
                        registryURL = registryURL.addParameter(Constants.PROXY_KEY, proxy);
                    }

                    Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
                    //包装调用者和所有元数据的Invoker包装器
                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

                    Exporter<?> exporter = protocol.export(wrapperInvoker);
                    exporters.add(exporter);
                }
            } else {
            	//没有注册中心直接暴露
                Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
                //包装调用者和所有元数据的Invoker包装器
                DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                Exporter<?> exporter = protocol.export(wrapperInvoker);
                exporters.add(exporter);
            }
        }
    }
    this.urls.add(url);
}

//暴露本地服务
private void exportLocal(URL url) {
    if (!Constants.LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
        //手动暴露一个本地服务
        URL local = URL.valueOf(url.toFullString())
                .setProtocol(Constants.LOCAL_PROTOCOL)
                .setHost(LOCALHOST)
                .setPort(0);
        Exporter<?> exporter = protocol.export(
                proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
        exporters.add(exporter);
        logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry");
    }
}

public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;
    //装饰者模式
    public ProtocolFilterWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }
}

@Override
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    //如果是注册中心协议直接导出
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    //如果不是则执行整个filter的责任链
    return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}

//责任链模式,对filter进行逐个执行
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
    Invoker<T> last = invoker;
    List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
    if (!filters.isEmpty()) {
        for (int i = filters.size() - 1; i >= 0; i--) {
            final Filter filter = filters.get(i);
            final Invoker<T> next = last;
            last = new Invoker<T>() {

                @Override
                public Class<T> getInterface() {
                    return invoker.getInterface();
                }

                @Override
                public URL getUrl() {
                    return invoker.getUrl();
                }

                @Override
                public boolean isAvailable() {
                    return invoker.isAvailable();
                }

                @Override
                public Result invoke(Invocation invocation) throws RpcException {
                    Result result = filter.invoke(next, invocation);
                    if (result instanceof AsyncRpcResult) {
                        AsyncRpcResult asyncResult = (AsyncRpcResult) result;
                        asyncResult.thenApplyWithContext(r -> filter.onResponse(r, invoker, invocation));
                        return asyncResult;
                    } else {
                        return filter.onResponse(result, invoker, invocation);
                    }
                }

                @Override
                public void destroy() {
                    invoker.destroy();
                }

                @Override
                public String toString() {
                    return invoker.toString();
                }
            };
        }
    }
    return last;
}

@Override
   public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
       return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
   }

@Override
   public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
       URL url = invoker.getUrl();
       // 导出服务.
       String key = serviceKey(url);
       DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
       exporterMap.put(key, exporter);
       //导出根服务以进行调度事件
       Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY, Constants.DEFAULT_STUB_EVENT);
       Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
       if (isStubSupportEvent && !isCallbackservice) {
           String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
           if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
               if (logger.isWarnEnabled()) {
                   logger.warn(new IllegalStateException("consumer [" + url.getParameter(Constants.INTERFACE_KEY) +
                           "], has set stubproxy support event ,but no stub methods founded."));
               }
           } else {
               stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
           }
       }
       //打开服务
       openServer(url);
       optimizeSerialization(url);
       return exporter;
   }	
   
   //打开服务
   private void openServer(URL url) {
       // find server.
       String key = url.getAddress();
       //客户端可以导出仅供服务器调用的服务
       boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);
       if (isServer) {
           ExchangeServer server = serverMap.get(key);
           if (server == null) {
               synchronized (this) {
                   server = serverMap.get(key);
                   if (server == null) {
                       //如果服务不存在,创建服务
                       serverMap.put(key, createServer(url));
                   }
               }
           } else {
               // 服务器支持重置，与override一起使用
               server.reset(url);
           }
       }
   }

@Override
   public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
       URL registryUrl = getRegistryUrl(originInvoker);
       // url在本地导出
       URL providerUrl = getProviderUrl(originInvoker);
       // 订阅覆盖数据
       // 同样的服务由于订阅是带有服务名称的缓存密钥，因此会导致订阅信息覆盖。
       final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
       final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
       overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);

       providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
       //导出invoker
       final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
       //将url注册到注册中心
       final Registry registry = getRegistry(originInvoker);
       final URL registeredProviderUrl = getRegisteredProviderUrl(providerUrl, registryUrl);
       ProviderInvokerWrapper<T> providerInvokerWrapper = ProviderConsumerRegTable.registerProvider(originInvoker,
               registryUrl, registeredProviderUrl);
       //判断我们是否需要推迟发布
       boolean register = registeredProviderUrl.getParameter("register", true);
       if (register) {
           register(registryUrl, registeredProviderUrl);
           providerInvokerWrapper.setReg(true);
       }
       // Deprecated! Subscribe to override rules in 2.6.x or before.
       registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
       exporter.setRegisterUrl(registeredProviderUrl);
       exporter.setSubscribeUrl(overrideSubscribeUrl);
       //确保每次导出时都返回一个新的导出器实例
       return new DestroyableExporter<>(exporter);
   }
   
   //真正导出服务的地方
	private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
       String key = getCacheKey(originInvoker);
       ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
       if (exporter == null) {
           synchronized (bounds) {
               exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
               if (exporter == null) {

                   final Invoker<?> invokerDelegete = new InvokerDelegate<T>(originInvoker, providerUrl);
                   //以dubbo协议为例,这里才是真正调用DubboProtocol.exprot的地方
                   exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker);
                   bounds.put(key, exporter);
               }
           }
       }
       return exporter;
   }

public String concat(String s1,String s2,String s3){
   return s1 + s2 + s3 ;
}