abstract class OneTimeExecutionApplicationContextEventListener implements ApplicationListener, ApplicationContextAware {

    private ApplicationContext applicationContext;

    public final void onApplicationEvent(ApplicationEvent event) {
         //判断事件源是持有的ApplicationContext并且是应用上下文事件
        if (isOriginalEventSource(event) && event instanceof ApplicationContextEvent) {
          
          //执行方法
            onApplicationContextEvent((ApplicationContextEvent) event);
        }
    }

   //抽象方法交给子类执行
    protected abstract void onApplicationContextEvent(ApplicationContextEvent event);

   
    private boolean isOriginalEventSource(ApplicationEvent event) {
        return (applicationContext == null)  || Objects.equals(applicationContext, event.getSource());
    }

    @Override
    public final void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }
}

public class DubboBootstrapApplicationListener extends OneTimeExecutionApplicationContextEventListener
        implements Ordered {

    /**
     * The bean name of {@link DubboBootstrapApplicationListener}
     */
    public static final String BEAN_NAME = "dubboBootstrapApplicationListener";

    private final DubboBootstrap dubboBootstrap;

  
  //实例化该监听器的的时候会先实例化dubboBootstrap 对象。
    public DubboBootstrapApplicationListener() {
        this.dubboBootstrap = DubboBootstrap.getInstance();
    }
    
    @Override
    public void onApplicationContextEvent(ApplicationContextEvent event) {
      //是上下文刷新事件则调用DubboBootstrap的start方法
        if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
          
          //如果是上下文关闭事件则调用DubboBootstrap的stop方法
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }

   //dubbo开始 上下文刷新时间
    private void onContextRefreshedEvent(ContextRefreshedEvent event) {
        dubboBootstrap.start();
    }

    private void onContextClosedEvent(ContextClosedEvent event) {
        dubboBootstrap.stop();
    }

    @Override
    public int getOrder() {
        return LOWEST_PRECEDENCE;
    }
}

public class DubboBootstrap extends GenericEventListener {


    private static DubboBootstrap instance;

    private final ConfigManager configManager;

    private final Environment environment;

  
   //加锁构造单例
    public static synchronized DubboBootstrap getInstance() {
        if (instance == null) {
            instance = new DubboBootstrap();
        }
        return instance;
    }
  
  
    //私有化构造函数，保证只能被自己实例化
    private DubboBootstrap() {
      
    	//通过SPI方式获取环境配置和环境管理实例，继承关系如下图
        configManager = ApplicationModel.getConfigManager();
        environment = ApplicationModel.getEnvironment();
      
        //注册shutdown事件，回调DubboBootstrap的destroy方法，销毁所有导出及引用的服务等
        DubboShutdownHook.getDubboShutdownHook().register();
        ShutdownHookCallbacks.INSTANCE.addCallback(new ShutdownHookCallback() {
            @Override
            public void callback() throws Throwable {
                DubboBootstrap.this.destroy();
            }
        });
    }
  
  

public class ApplicationModel {


  private static final ExtensionLoader<FrameworkExt> LOADER = ExtensionLoader.getExtensionLoader(FrameworkExt.class);


  //通过SPI方式获取环境配置和环境管理实例
  public static Environment getEnvironment() {
    return (Environment) LOADER.getExtension(Environment.NAME);
  }

  public static ConfigManager getConfigManager() {
    return (ConfigManager) LOADER.getExtension(ConfigManager.NAME);
  }


}

    public DubboBootstrap start() {
      
         //原子操作，保证只启动一次
        if (started.compareAndSet(false, true)) {
            ready.set(false);
          
          //1、初始化操作，主要是一些配置
            initialize();
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " is starting...");
            }
          
          // 2、导出dubbo服务（最终调用ServiceConfig的export方法）
            exportServices();

            // 当不只是注册服务提供者或者已经导出元数据的情况下执行
            if (!isOnlyRegisterProvider() || hasExportedServices()) {
              
                // 导出元数据服务（最终调用ServiceConfig实例，然后调用export方法）
                exportMetadataService();
              
                // 如果有则需要注册本地服务实例，通过SPI方式获取服务发现注册中心，然后调用他们的注册方法（默认自适应拓展实现是zookeeper）
                registerServiceInstance();
            }

           // 3、服务导入
            referServices();
            if (asyncExportingFutures.size() > 0) {
                new Thread(() -> {
                    try {
                        this.awaitFinish();
                    } catch (Exception e) {
                        logger.warn(NAME + " exportAsync occurred an exception.");
                    }
                    ready.set(true);
                    if (logger.isInfoEnabled()) {
                        logger.info(NAME + " is ready.");
                    }
                }).start();
            } else {
                ready.set(true);
                if (logger.isInfoEnabled()) {
                    logger.info(NAME + " is ready.");
                }
            }
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " has started.");
            }
        }
        return this;
    }

 private void initialize() {
    	// 原子操作确保只初始化一次
        if (!initialized.compareAndSet(false, true)) {
            return;
        }
        //初始化Dubbo组件的生命周期，这里主要是对环境配置初始化
        ApplicationModel.iniFrameworkExts();
   
        //开始构建配置中心
        startConfigCenter();
   
        //如果是zookeeper作为注册中心且没有指定配置中心时，使用注册中心做配置中心
        useRegistryAsConfigCenterIfNecessary();
   
        //加载远程的配置
        loadRemoteConfigs();
   
        //全局配置校验（应用、元数据、提供者、消费者、监控等）
        checkGlobalConfigs();
   
        //初始化元数据服务
        initMetadataService();
   
        //初始化事件监听器（将当前实例添加到事件监听器中）
        initEventListener();

        if (logger.isInfoEnabled()) {
            logger.info(NAME + " has been initialized!");
        }
    }

    public static void initFrameworkExts() {
      //这里面通过上面其实就可以看出来就是 一些环境的类，进行初始化
        Set<FrameworkExt> exts = ExtensionLoader.getExtensionLoader(FrameworkExt.class).getSupportedExtensionInstances();
        for (FrameworkExt ext : exts) {
            ext.initialize();
        }
    }

    private void startConfigCenter() {
        Collection<ConfigCenterConfig> configCenters = configManager.getConfigCenters();

        // check Config Center
        if (CollectionUtils.isEmpty(configCenters)) {
            ConfigCenterConfig configCenterConfig = new ConfigCenterConfig();
            configCenterConfig.refresh();
            if (configCenterConfig.isValid()) {
                configManager.addConfigCenter(configCenterConfig);
                configCenters = configManager.getConfigCenters();
            }
        } else {
            for (ConfigCenterConfig configCenterConfig : configCenters) {
                configCenterConfig.refresh();
                ConfigValidationUtils.validateConfigCenterConfig(configCenterConfig);
            }
        }

        if (CollectionUtils.isNotEmpty(configCenters)) {
            CompositeDynamicConfiguration compositeDynamicConfiguration = new CompositeDynamicConfiguration();
            for (ConfigCenterConfig configCenter : configCenters) {
                compositeDynamicConfiguration.addConfiguration(prepareEnvironment(configCenter));
            }
            environment.setDynamicConfiguration(compositeDynamicConfiguration);
        }
        configManager.refreshAll();
    }

private void useRegistryAsConfigCenterIfNecessary() {
        // we use the loading status of DynamicConfiguration to decide whether ConfigCenter has been initiated.
        if (environment.getDynamicConfiguration().isPresent()) {
            return;
        }

        if (CollectionUtils.isNotEmpty(configManager.getConfigCenters())) {
            return;
        }

  			//从环境中获取注册中心，我们会发现我这里其实只有一个，如果有多个的话则要进行过滤，筛选出符合条件的
        configManager.getDefaultRegistries().stream()
                .filter(registryConfig -> registryConfig.getUseAsConfigCenter() == null || registryConfig.getUseAsConfigCenter())
                .forEach(registryConfig -> {
                    String protocol = registryConfig.getProtocol();
                    String id = "config-center-" + protocol + "-" + registryConfig.getPort();
                    ConfigCenterConfig cc = new ConfigCenterConfig();
                    cc.setId(id);
                    if (cc.getParameters() == null) {
                        cc.setParameters(new HashMap<>());
                    }
                    if (registryConfig.getParameters() != null) {
                        cc.getParameters().putAll(registryConfig.getParameters());
                    }
                    cc.getParameters().put(CLIENT_KEY, registryConfig.getClient());
                    cc.setProtocol(registryConfig.getProtocol());
                    cc.setPort(registryConfig.getPort());
                    cc.setAddress(registryConfig.getAddress());
                    cc.setNamespace(registryConfig.getGroup());
                    cc.setUsername(registryConfig.getUsername());
                    cc.setPassword(registryConfig.getPassword());
                    if (registryConfig.getTimeout() != null) {
                        cc.setTimeout(registryConfig.getTimeout().longValue());
                    }
                    cc.setHighestPriority(false);
                    configManager.addConfigCenter(cc);
                });
        startConfigCenter();
    }

    private void loadRemoteConfigs() {
        // registry ids to registry configs
        List<RegistryConfig> tmpRegistries = new ArrayList<>();
        Set<String> registryIds = configManager.getRegistryIds();
        registryIds.forEach(id -> {
            if (tmpRegistries.stream().noneMatch(reg -> reg.getId().equals(id))) {
                tmpRegistries.add(configManager.getRegistry(id).orElseGet(() -> {
                    RegistryConfig registryConfig = new RegistryConfig();
                    registryConfig.setId(id);
                    registryConfig.refresh();
                    return registryConfig;
                }));
            }
        });

        configManager.addRegistries(tmpRegistries);

        // protocol ids to protocol configs
        List<ProtocolConfig> tmpProtocols = new ArrayList<>();
        Set<String> protocolIds = configManager.getProtocolIds();
        protocolIds.forEach(id -> {
            if (tmpProtocols.stream().noneMatch(prot -> prot.getId().equals(id))) {
                tmpProtocols.add(configManager.getProtocol(id).orElseGet(() -> {
                    ProtocolConfig protocolConfig = new ProtocolConfig();
                    protocolConfig.setId(id);
                    protocolConfig.refresh();
                    return protocolConfig;
                }));
            }
        });

        configManager.addProtocols(tmpProtocols);
    }

 private void exportServices() {
 			
 			  //这个方法是获取我们所有的service服务类， 看下面的图片就明白了
        configManager.getServices().forEach(sc -> {
          
            //设置ServiceConfig的启动器为 当前 bootstrap
            ServiceConfig serviceConfig = (ServiceConfig) sc;
            serviceConfig.setBootstrap(this);
            
            if (exportAsync) {
              
            	//异步导出，将导出任务提交到线程池异步完成
                ExecutorService executor = executorRepository.getServiceExporterExecutor();
                Future<?> future = executor.submit(() -> {
                    sc.export();
                });
                asyncExportingFutures.add(future);
              
              //我这里是同步导出
            } else {
            	//同步导出 则直接调用ServiceConfig的导出方法
                sc.export();
                exportedServices.add(sc);
            }
        });
    }

 public synchronized void export() {
    	//判断当前服务是否需要导出
        if (!shouldExport()) {
            return;
        }
   
        //启动类为空则获取一个实例（按照上面的流程下来其实已经执行了）
        if (bootstrap == null) {
            bootstrap = DubboBootstrap.getInstance();
            bootstrap.init();
        }
     
     
        //校验并更细配置（默认配置、协议配置等）
        checkAndUpdateSubConfigs();

        //初始化元数据（设置版本、分组、类型及名称等属性，接口的一些属性）
        serviceMetadata.setVersion(version);
        serviceMetadata.setGroup(group);
        serviceMetadata.setDefaultGroup(group);
        serviceMetadata.setServiceType(getInterfaceClass());
        serviceMetadata.setServiceInterfaceName(getInterface());
        serviceMetadata.setTarget(getRef());
   
   
   
        //是否需要延迟导出
        if (shouldDelay()) {
        	//提交导出任务到延迟导出调度器（可调度线程池）
            DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
        } else {
        	//执行导出操作，我们执行这里
            doExport();
        }
    
        //执行已导出操作
        exported();
    }

	//判断是否要导出，如果已经导出了那么久不要导出了，如果没有导出的时候就返回true执行导出
    public boolean shouldExport() {
        Boolean export = getExport();
        // default value is true
        return export == null ? true : export;
    }

	//判断是否导出，如果已经有服务提供者了，就说明已经导出了
    //有时候我们只是想本地启动服务进行一些调试工作，我们并不希望把本地启动的服务暴露出去给别人调用。此时，我们可通过配置 export 禁止服务导出
    protected ProviderConfig provider;
    @Override
    public Boolean getExport() {
        return (export == null && provider != null) ? provider.getExport() : export;
    }
	
   @Deprecated
    public void init() {
        initialize();
    }


    public void exported() {
        // 发布一个服务导出事件（ ServiceConfigExportedEvent）
        dispatch(new ServiceConfigExportedEvent(this));
    }

protected synchronized void doExport() {
    	//是否执行了unexport方法（表示服务注销了），执行了则抛出异常
        if (unexported) {
            throw new IllegalStateException("The service " + interfaceClass.getName() + " has already unexported!");
        }
  
        //已经导出过则直接返回
        if (exported) {
            return;
        }
        //设置已导出标志
        exported = true;
        //路径及服务名为空
        if (StringUtils.isEmpty(path)) {
        	//服务名为接口名
            path = interfaceName;
        }
  
  
        //Dubbo 允许我们使用不同的协议导出服务，也允许我们向多个注册中心注册服务。Dubbo 在 doExportUrls 方法中对多协议，多注册中心进行了支持
       //执行多协议多注册导出
        doExportUrls();
    }

 private void doExportUrls() {
    	//获取服务缓存库
        ServiceRepository repository = ApplicationModel.getServiceRepository();
   
        //注册当前服务到本地缓存库
        ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
   
        //注册服务提供者到缓存库
        repository.registerProvider(
        		//根据接口名，服务组及版本号生成唯一名称 （163/com.healerjean.proj.service.MailClientService:0.0.1）
                getUniqueServiceName(),
                ref,
                serviceDescriptor,
                this,
                serviceMetadata
        );
   
   
   		
        //加载注册中心地址（支持多注册中心，因此是集合） 
   			//registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=hlj-server-provider&dubbo=2.0.2&file=/Users/healerjean/Desktop/logs/hljServerProvider2001&pid=3931&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&registry=zookeeper&release=2.7.7&timestamp=1604404226937 
        List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
        
        //支持多协议导出，遍历每个协议，执行这个协议所对应的注册中心的导出逻辑
        for (ProtocolConfig protocolConfig : protocols) {
        	//根据协议配置生成服务地址（注册中心的key） 163/com.healerjean.proj.service.MailClientService:0.0.1
            String pathKey = URL.buildKey(getContextPath(protocolConfig)
                    .map(p -> p + "/" + path)
                    .orElse(path), group, version);
          
            // 如果指定了服务路径，需要再次注册到缓存中，保证此映射路径能获取到服务
            repository.registerService(pathKey, interfaceClass);
          
            // 设置原数据服务key
            serviceMetadata.setServiceKey(pathKey);
          
            //执行多注册中心单协议的导出逻辑
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

	private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
		String name = protocolConfig.getName();
		// 协议名称为空，设置为dubbo,我这个配置了，进来就是dubbo
		if (StringUtils.isEmpty(name)) {
			name = DUBBO;
		}
    
    
		// 添加配置<side,provider>
		Map<String, String> map = new HashMap<String, String>();
		map.put(SIDE_KEY, PROVIDER_SIDE);
    
		// 添加dubbo、版本、时间戳等运行参数到map中
		ServiceConfig.appendRuntimeParameters(map);
    
		// 通过getter或者getParameters方法将ApplicationConfig、ModuleConfig、MetricsConfig、
		// ProviderConfig、ProtocolConfig及ServiceConfig属性放到map中
		AbstractConfig.appendParameters(map, getMetrics());
		AbstractConfig.appendParameters(map, getApplication());
		AbstractConfig.appendParameters(map, provider);
		AbstractConfig.appendParameters(map, protocolConfig);
		AbstractConfig.appendParameters(map, this);
    
		// 获取原数导出配置，如果合法则添加<metadata,remote>到map中
		MetadataReportConfig metadataReportConfig = getMetadataReportConfig();
		if (metadataReportConfig != null && metadataReportConfig.isValid()) {
			map.putIfAbsent(METADATA_KEY, REMOTE_METADATA_STORAGE_TYPE);
		}
		//是否存在 <dubbo:method> 标签的配置信息
		if (CollectionUtils.isNotEmpty(getMethods())) {
			for (MethodConfig method : getMethods()) {
				// 通过getter或者getParameters方法将MethodConfig属性添加到map中，前缀是当前MethodConfig名称即<方法名.属性名,属性值>。
				AbstractConfig.appendParameters(map, method, method.getName());
				String retryKey = method.getName() + ".retry";
				//是否存在methodname.retry键，及是否配置了retry属性
				if (map.containsKey(retryKey)) {
					//存在则移除
					String retryValue = map.remove(retryKey);
					//如果retry配置的false，设置retries配置为0
					if ("false".equals(retryValue)) {
						map.put(method.getName() + ".retries", "0");
					}
				}
				//获取方法参数配置ArgumentConfig，存放到map中
				List<ArgumentConfig> arguments = method.getArguments();
				if (CollectionUtils.isNotEmpty(arguments)) {
					for (ArgumentConfig argument : arguments) {
						// 判断参数类型是否为空
						if (argument.getType() != null && argument.getType().length() > 0) {
							//获取接口（导出服务）的所有方法，遍历
							Method[] methods = interfaceClass.getMethods();
							if (methods.length > 0) {
								for (int i = 0; i < methods.length; i++) {
									String methodName = methods[i].getName();
									// 接口方法名和方法配置名称相同
									if (methodName.equals(method.getName())) {
										//获取接口方法参数类型
										Class<?>[] argtypes = methods[i].getParameterTypes();
										// 参数索引不是-1，-1表示未设置
										if (argument.getIndex() != -1) {
											 // 检测 ArgumentConfig 中的 type 属性与方法参数列表中的参数名称是否一致
											if (argtypes[argument.getIndex()].getName().equals(argument.getType())) {
												//一致的则添加配置到map<方法名.参数索引,参数配置>
												AbstractConfig.appendParameters(map, argument,
														method.getName() + "." + argument.getIndex());
											} else {//不一致则抛出异常
												throw new IllegalArgumentException(
														"Argument config error : the index attribute and type attribute not match :index :"
																+ argument.getIndex() + ", type:" + argument.getType());
											}
										} else {//未设置参数索引
											// 遍历方法参数的所有类型
											for (int j = 0; j < argtypes.length; j++) {
												Class<?> argclazz = argtypes[j];
												//查找和当前参数配置类型匹配的参数
												if (argclazz.getName().equals(argument.getType())) {
													//匹配则将配置放入map中<方法名.参数索引,参数配置>
													AbstractConfig.appendParameters(map, argument,
															method.getName() + "." + j);
													//如果匹配到的参数类型设置了索引并且和当前索引不一致，抛出异常
													if (argument.getIndex() != -1 && argument.getIndex() != j) {
														throw new IllegalArgumentException(
																"Argument config error : the index attribute and type attribute not match :index :"
																		+ argument.getIndex() + ", type:"
																		+ argument.getType());
													}
												}
											}
										}
									}
								}
							}
						} else if (argument.getIndex() != -1) {
							//参数类型为空但是参数索引不是-1，添加配置到map中
							AbstractConfig.appendParameters(map, argument,
									method.getName() + "." + argument.getIndex());
						} else {
							//如果既没有配置参数索引又没哟配置参数类型则抛出异常
							throw new IllegalArgumentException(
									"Argument config must set index or type attribute.eg: <dubbo:argument index='0' .../> or <dubbo:argument type=xxx .../>");
						}

					}
				}
			} 
		}
		
		if (ProtocolUtils.isGeneric(generic)) {
			//是泛化服务则设置<generic,generic值>、<methods,*>表示任意方法
			map.put(GENERIC_KEY, generic);
			map.put(METHODS_KEY, ANY_VALUE);
		} else {
			//不是泛化服务，获取修订版本号，放入map
			String revision = Version.getVersion(interfaceClass, version);
			if (revision != null && revision.length() > 0) {
				map.put(REVISION_KEY, revision);
			}
			//创建并返回包装类方法名称
			String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
			if (methods.length == 0) {
				//没有包装方法名则设置<methods,*>
				logger.warn("No method found in service interface " + interfaceClass.getName());
				map.put(METHODS_KEY, ANY_VALUE);
			} else {
				//如果有，则方面通过逗号分隔拼接放入map中，key=methods
				map.put(METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
			}
		}

		//没有token且提供者不为空,获取提供者的token
		if (ConfigUtils.isEmpty(token) && provider != null) {
			token = provider.getToken();
		}
		//如果token不为空
		if (!ConfigUtils.isEmpty(token)) {
			//如果token是默认值（true或者default）,则创建UUID作为token
			if (ConfigUtils.isDefault(token)) {
				map.put(TOKEN_KEY, UUID.randomUUID().toString());
			} else {
				map.put(TOKEN_KEY, token);
			}
		}
		// init serviceMetadata attachments
		serviceMetadata.getAttachments().putAll(map);

    
    
    
    
    
    
    //开始服务导出，上面一堆东西，无非就是构建mao，然后将所有的参数放到map中，然后下面将map制作为dubbo协议的url
    
		// 127.0.0.1
        //找到配置的主机,优先级如下：environment variables -> java system properties -> host property in config file 
		// -> /etc/hosts -> default network address -> first available network address
		String host = findConfigedHosts(protocolConfig, registryURLs, map);
		// 20880
        // 找到配置的端口，优先级： environment variable -> java system properties ->
		// port property in protocol config file -> protocol default port
		Integer port = findConfigedPorts(protocolConfig, name, map);
		//拼接URL ：dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=3931&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604405352872&version=0.0.1
		URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);

    
		// 如果存对应的url扩展工厂，则再接着进行处理url，则获取自定义扩展配置，我这里没有进入
		if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class).hasExtension(url.getProtocol())) {
			url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class).getExtension(url.getProtocol())
					.getConfigurator(url).configure(url);
		}
        
        
		//获取导出范围，我这里获取到的是
		String scope = url.getParameter(SCOPE_KEY);
		// 如果导出单位不是字符串'none'，则准备导出，我这里获取到的是null
		if (!SCOPE_NONE.equalsIgnoreCase(scope)) {

			// 如果导出范围不是remote则执行本地导出逻辑
			if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
				exportLocal(url);
			}
      
      
      
      
			// 如果配置导出范围不是local则执行远程导出
			if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
				//注册中心地址不为空
				if (CollectionUtils.isNotEmpty(registryURLs)) {
					for (URL registryURL : registryURLs) {
						// 如果协议是injvm 则不执行导出注册逻辑
						if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
							continue;
						}
						//url配置dynamic参数
						url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
						//获取监控地址
						URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);
						if (monitorUrl != null) {
							//监控地址不为空则添加到URL参数中key=monitor
							url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
						}
						if (logger.isInfoEnabled()) {
							if (url.getParameter(REGISTER_KEY, true)) {
								logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url
										+ " to registry " + registryURL);
							} else {
								logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
							}
						}

						// 获取自定义代理配置
						String proxy = url.getParameter(PROXY_KEY);
						if (StringUtils.isNotEmpty(proxy)) {
							//如果存在，则为注册地址添加代理实现参数
							registryURL = registryURL.addParameter(PROXY_KEY, proxy);
						}
						//为服务引用生成Invoker对象
						Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass,
								registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
						//生成提供者和配置包装Invoker
						DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker,
								this);
						//通过SPI自适应拓展获取Protocol的拓展实现，调用导出方法
						Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
						//添加到导出器缓存
						exporters.add(exporter);
					}
				} else {
					//注册中心地址为空，导出服务到配置地址
					if (logger.isInfoEnabled()) {
						logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
					}
					Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
					DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

					Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
					exporters.add(exporter);
				}
				/**
				 * @since 2.7.0 ServiceData Store
				 * 获取可写元数据服务，默认实现为本地
				 */
				WritableMetadataService metadataService = WritableMetadataService
						.getExtension(url.getParameter(METADATA_KEY, DEFAULT_METADATA_STORAGE_TYPE));
				if (metadataService != null) {
					//发布服务定义
					metadataService.publishServiceDefinition(url);
				}
			}
		}
		//添加到服务引用url缓存中
		this.urls.add(url);
	}

private final List<Exporter<?>> exporters = new ArrayList<Exporter<?>>();


//使用SPI自适应拓展机制，获取ProxyFactory和Protocol的实现。
//默认实现是DubboProtocol,这里是本地协议，也就是InjvmProtocol（根据Invoker才确认是InjvmProtocol的哦）
private static final Protocol PROTOCOL = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
//代理工厂，这里的适配扩展是 JavassistProxyFactory
private static final ProxyFactory PROXY_FACTORY = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();


/**
* 导出服务到本地（及jvm导出）
*/
private void exportLocal(URL url) {
    //组装导出地址，协议为injvm，
    // injvm://127.0.0.1/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4172&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604407350304&version=0.0.1
    URL local = URLBuilder.from(url)
        .setProtocol(LOCAL_PROTOCOL)
        .setHost(LOCALHOST_VALUE)
        .setPort(0)
        .build();

    //使用ProxyFactory生成导出服务代理的实现，默认实现JavassistProxy
    //使用Protocol调用服务导出逻辑，默认实现是DubboProtocol,这里是本地协议，也就是InjvmProtocol
    Exporter<?> exporter = PROTOCOL.export(PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, local));

    //添加导出服务到缓存中
    exporters.add(exporter);
    logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry url : " + local);
}

public interface Invoker<T> extends Node {

    /**
     * get service interface.
     *
     * @return service interface.
     */
    Class<T> getInterface();

    /**
     * invoke.
     *
     * @param invocation
     * @return result
     * @throws RpcException
     */
    Result invoke(Invocation invocation) throws RpcException;

}

public class JavassistProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
    	//为目标类创建包装类，无法解决类名包含$的情况,不能是代理类，所以 是type
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
      
      
        //创建了一个继承自 AbstractProxyInvoker 类的匿名类对象
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
              
            	// 调用 Wrapper 的 invokeMethod 方法(此方法实际上是上面 Wrapper.getWrapper生成的)，invokeMethod 最终会调用目标方法
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

}

public abstract class Wrapper {

    private static final Map<Class<?>, Wrapper> WRAPPER_MAP = new ConcurrentHashMap<Class<?>, Wrapper>(); //class wrapper map

    //^^^^^^

    public static Wrapper getWrapper(Class<?> c) {
        //因为无法代理动态类，因此是动态类时会循环找到不是动态类的父类
        while (ClassGenerator.isDynamicClass(c)) 
        {	//获取父类
            c = c.getSuperclass();
        }

        //如果代理Object类，则直接返回固定实现OBJECT_WRAPPER
        if (c == Object.class) {
            return OBJECT_WRAPPER;
        }

        //代理其他类则调用makeWrapper创建一个实例，并存入缓存中（如果不存在,则创建并返回）
        return WRAPPER_MAP.computeIfAbsent(c, key -> makeWrapper(key))



    }

private static Wrapper makeWrapper(Class<?> c) {
    // 判断是否是基本类型的包装类，如果是则抛出异常
    if (c.isPrimitive()) {
        throw new IllegalArgumentException("Can not create wrapper for primitive type: " + c);
    }

    // 获取类的全限定名称(包名+类名)
    String name = c.getName();
    // 获取类加载器，优先级如下：线程上下文加载器 -> c的类加载器 -> 系统类加载器
    ClassLoader cl = ClassUtils.getClassLoader(c);
    // 存放setPropertyValue方法代码
    StringBuilder c1 = new StringBuilder("public void setPropertyValue(Object o, String n, Object v){ ");
    // 存放getPropertyValue方法代码
    StringBuilder c2 = new StringBuilder("public Object getPropertyValue(Object o, String n){ ");
    // 存放invokeMethod方法代码
    StringBuilder c3 = new StringBuilder(
        "public Object invokeMethod(Object o, String n, Class[] p, Object[] v) throws "
        + InvocationTargetException.class.getName() + "{ ");


    // 生成类型转换代码及异常抛出代码
    c1.append(name).append(" w; try{ w = ((").append(name)
        .append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
    c2.append(name).append(" w; try{ w = ((").append(name)
        .append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
    c3.append(name).append(" w; try{ w = ((").append(name)
        .append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");

    // 存放属性<属性名,属性类型>
    Map<String, Class<?>> pts = new HashMap<>();
    // 存放方法<描述信息（可理解为方法签名）, Method 实例>
    Map<String, Method> ms = new LinkedHashMap<>();
    // 存放所有的方法名
    List<String> mns = new ArrayList<>();
    // 所有在当前类中声明的方法名
    List<String> dmns = new ArrayList<>();

    // 获取 public访问级别的字段
    for (Field f : c.getFields()) {
        String fn = f.getName();
        Class<?> ft = f.getType();
        // 如果是static 或 transient 修饰的变量，则忽略
        if (Modifier.isStatic(f.getModifiers()) || Modifier.isTransient(f.getModifiers())) {
            continue;
        }
        // 生成条件判断及赋值语句，比如：
        // if( $2.equals("name") ) { w.name = (java.lang.String) $3; return;}
        c1.append(" if( $2.equals(\"").append(fn).append("\") ){ w.").append(fn).append("=").append(arg(ft, "$3"))
            .append("; return; }");
        // 生成条件判断及返回语句，比如：
        // if( $2.equals("name") ) { return ($w)w.name; }
        c2.append(" if( $2.equals(\"").append(fn).append("\") ){ return ($w)w.").append(fn).append("; }");
        // 添加<属性名,属性类型>到集合中
        pts.put(fn, ft);
    }

    //获取所有public访问级别的方法
    Method[] methods = c.getMethods();
    // 检测是否包含在当前类中声明的方法
    boolean hasMethod = hasMethods(methods);
    if (hasMethod) {
        c3.append(" try{");
        for (Method m : methods) {
            // 忽略Object类声明的方法
            if (m.getDeclaringClass() == Object.class) {
                continue;
            }

            String mn = m.getName();
            // 生成方法名判断语句，比如：
            // if ( "setName".equals( $2 )
            c3.append(" if( \"").append(mn).append("\".equals( $2 ) ");
            //参数个数
            int len = m.getParameterTypes().length;
            // 生成“运行时传入的参数数量与方法参数列表长度”判断语句，比如：
            // && $3.length == 1
            c3.append(" && ").append(" $3.length == ").append(len);
            // 检测方法是否存在重载情况，条件为：方法对象不同 && 方法名相同
            boolean override = false;
            for (Method m2 : methods) {
                if (m != m2 && m.getName().equals(m2.getName())) {
                    override = true;
                    break;
                }
            }
            // 对重载方法进行处理。判断是统一个方法时除了方法名、参数列表长度相同外，还必须判断参数类型是否一致，如：
            // void setName(String name) 和  void setName(Integer name)
            if (override) {
                if (len > 0) {
                    for (int l = 0; l < len; l++) {
                        // 生成参数类型进行检测代码，比如：
                        // && $3[0].getName().equals("java.lang.String") 
                        c3.append(" && ").append(" $3[").append(l).append("].getName().equals(\"")
                            .append(m.getParameterTypes()[l].getName()).append("\")");
                    }
                }
            }
            // 添加 ) {，完成方法判断语句
            c3.append(" ) { ");
            // 上面的方法校验完成后的代码类似这样：
            // if ("setName".equals($2) && $3.length == 1 && $3[0].getName().equals("java.lang.String")) {

            // 根据返回值类型生成目标方法调用语句
            if (m.getReturnType() == Void.TYPE) {
                //返回值类型为空，则 w.setName((java.lang.String)$4[0]); return null;
                c3.append(" w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4")).append(");")
                    .append(" return null;");
            } else {
                //返回值类型不为空，则  // return ($w)w.getName();
                c3.append(" return ($w)w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4"))
                    .append(");");
            }
            // 添加 },
            c3.append(" }");
            /* 上面的方法校验完成后的代码类似这样：
		        *if ("setName".equals($2) && $3.length == 1 && $3[0].getName().equals("java.lang.String")) {
		        *   w.setName((java.lang.String)$4[0]); return null;
		        *  }
		        */

            ///添加方法名到集合中
            mns.add(mn);
            //如果是当前类声明的方法，则添加到声明方法集合中
            if (m.getDeclaringClass() == c) {
                dmns.add(mn);
            }
            //添加<方法描述,方法>到集合中
            ms.put(ReflectUtils.getDesc(m), m);
        }
        //添加异常捕获及抛出代码
        c3.append(" } catch(Throwable e) { ");
        c3.append("     throw new java.lang.reflect.InvocationTargetException(e); ");
        c3.append(" }");
    }
    //添加NoSuchMethodException异常代码
    c3.append(" throw new " + NoSuchMethodException.class.getName()
              + "(\"Not found method \\\"\"+$2+\"\\\" in class " + c.getName() + ".\"); }");

    // 处理getter和setter方法
    Matcher matcher;
    for (Map.Entry<String, Method> entry : ms.entrySet()) {
        String md = entry.getKey();
        Method method = entry.getValue();
        //是否是get方法
        if ((matcher = ReflectUtils.GETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
            //获取属性名
            String pn = propertyName(matcher.group(1));
            // 生成属性判断以及返回语句，示例如下：
            // if( $2.equals("name") ) { return ($w).w.getName(); }
            c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName())
                .append("(); }");
            //存放<属性名，属性类型>到集合中
            pts.put(pn, method.getReturnType());
            //判断是否是is|has|can开头方法，生成代码逻辑同get方法
        } else if ((matcher = ReflectUtils.IS_HAS_CAN_METHOD_DESC_PATTERN.matcher(md)).matches()) {
            String pn = propertyName(matcher.group(1));
            c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName())
                .append("(); }");
            pts.put(pn, method.getReturnType());
            //判断是set开头方法
        } else if ((matcher = ReflectUtils.SETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
            //获取参数(属性)类型
            Class<?> pt = method.getParameterTypes()[0];
            //获取属性名
            String pn = propertyName(matcher.group(1));
            //生成属性判断及set方法语句，示例如下：
            // if( $2.equals("name") ) { w.setName((java.lang.String)$3); return; }
            c1.append(" if( $2.equals(\"").append(pn).append("\") ){ w.").append(method.getName()).append("(")
                .append(arg(pt, "$3")).append("); return; }");
            //存放<属性名，属性类型>到集合中
            pts.put(pn, pt);
        }
    }
    // 添加 抛出 NoSuchPropertyException 异常代码
    c1.append(" throw new " + NoSuchPropertyException.class.getName()
              + "(\"Not found property \\\"\"+$2+\"\\\" field or setter method in class " + c.getName() + ".\"); }");
    c2.append(" throw new " + NoSuchPropertyException.class.getName()
              + "(\"Not found property \\\"\"+$2+\"\\\" field or setter method in class " + c.getName() + ".\"); }");

    // 生成class
    //包装类数量加1并获取，原子操作
    long id = WRAPPER_CLASS_COUNTER.getAndIncrement();
    //根据类加载器创建类生成器实例
    ClassGenerator cc = ClassGenerator.newInstance(cl);
    // 生成类名：有公共修饰符则org.apache.dubbo.common.bytecode.Wrapper，否则当前包装类名+$sw+当前包装类数量
    cc.setClassName((Modifier.isPublic(c.getModifiers()) ? Wrapper.class.getName() : c.getName() + "$sw") + id);
    // 设置父类
    cc.setSuperClass(Wrapper.class);
    // 设置默认构造函数
    cc.addDefaultConstructor();
    // 添加属性名称数组字段
    cc.addField("public static String[] pns;"); 
    // 属性即类类型字段
    cc.addField("public static " + Map.class.getName() + " pts;"); 
    // 添加方法名称集合属性
    cc.addField("public static String[] mns;");
    // 添加本类声明的方法名称集合字段
    cc.addField("public static String[] dmns;");
    // 添加类属性
    for (int i = 0, len = ms.size(); i < len; i++) {
        cc.addField("public static Class[] mts" + i + ";");
    }
    //添加属性名获取方法
    cc.addMethod("public String[] getPropertyNames(){ return pns; }");
    // 添加是否存在某个属性方法
    cc.addMethod("public boolean hasProperty(String n){ return pts.containsKey($1); }");
    // 获取某个属性类型
    cc.addMethod("public Class getPropertyType(String n){ return (Class)pts.get($1); }");
    // 获取方法名集合
    cc.addMethod("public String[] getMethodNames(){ return mns; }");
    //获取声明方法属性
    cc.addMethod("public String[] getDeclaredMethodNames(){ return dmns; }");
    // 添加setPropertyValue方法、getPropertyValue方法、invokeMethod方法代码
    cc.addMethod(c1.toString());
    cc.addMethod(c2.toString());
    cc.addMethod(c3.toString());

    try {
        Class<?> wc = cc.toClass();
        // 设置字段值
        wc.getField("pts").set(null, pts);
        wc.getField("pns").set(null, pts.keySet().toArray(new String[0]));
        wc.getField("mns").set(null, mns.toArray(new String[0]));
        wc.getField("dmns").set(null, dmns.toArray(new String[0]));
        int ix = 0;
        for (Method m : ms.values()) {
            wc.getField("mts" + ix++).set(null, m.getParameterTypes());
        }
        //创建Wrapper实例
        return (Wrapper) wc.newInstance();
    } catch (RuntimeException e) {
        throw e;
    } catch (Throwable e) {
        throw new RuntimeException(e.getMessage(), e);
    } finally {
        //清理缓存
        cc.release();
        ms.clear();
        mns.clear();
        dmns.clear();
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.dubbo.common.bytecode;

import com.healerjean.proj.service.MailClientService;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import org.apache.dubbo.common.bytecode.ClassGenerator.DC;

public class Wrapper0 extends Wrapper implements DC {
    public static String[] pns;
    public static Map pts;
    public static String[] mns;
    public static String[] dmns;
    public static Class[] mts0;

    public Wrapper0() {
    }

    public boolean hasProperty(String var1) {
        return pts.containsKey(var1);
    }

    public Class getPropertyType(String var1) {
        return (Class)pts.get(var1);
    }
	
    //第一个是代理对象
    //第二个是是方法名
    //第三个是参数类型的数组（同一个名字，不同参数类型）
    //第四个是代理对象的参数
    public Object invokeMethod(Object var1, String var2, Class[] var3, Object[] var4) throws InvocationTargetException {
        MailClientService var5;
        try {
            var5 = (MailClientService)var1;
        } catch (Throwable var8) {
            throw new IllegalArgumentException(var8);
        }

        try {
            if ("sentMail".equals(var2) && var3.length == 1) {
                var5.sentMail((String)var4[0]);
                return null;
            }
        } catch (Throwable var9) {
            throw new InvocationTargetException(var9);
        }

        throw new NoSuchMethodException("Not found method \"" + var2 + "\" in class com.healerjean.proj.service.MailClientService.");
    }

    public String[] getPropertyNames() {
        return pns;
    }

    public Object getPropertyValue(Object var1, String var2) {
        try {
            MailClientService var3 = (MailClientService)var1;
        } catch (Throwable var5) {
            throw new IllegalArgumentException(var5);
        }

        throw new NoSuchPropertyException("Not found property \"" + var2 + "\" field or setter method in class com.healerjean.proj.service.MailClientService.");
    }

    public void setPropertyValue(Object var1, String var2, Object var3) {
        try {
            MailClientService var4 = (MailClientService)var1;
        } catch (Throwable var6) {
            throw new IllegalArgumentException(var6);
        }

        throw new NoSuchPropertyException("Not found property \"" + var2 + "\" field or setter method in class com.healerjean.proj.service.MailClientService.");
    }

    public String[] getMethodNames() {
        return mns;
    }

    public String[] getDeclaredMethodNames() {
        return dmns;
    }
}

public abstract class AbstractProxyInvoker<T> implements Invoker<T> {
    Logger logger = LoggerFactory.getLogger(AbstractProxyInvoker.class);

    private final T proxy;

    private final Class<T> type;

    private final URL url;

    public AbstractProxyInvoker(T proxy, Class<T> type, URL url) {
        if (proxy == null) {
            throw new IllegalArgumentException("proxy == null");
        }
        if (type == null) {
            throw new IllegalArgumentException("interface == null");
        }
        if (!type.isInstance(proxy)) {
            throw new IllegalArgumentException(proxy.getClass().getName() + " not implement interface " + type);
        }
        this.proxy = proxy;
        this.type = type;
        this.url = url;
    }

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

    @Override
    public URL getUrl() {
        return url;
    }

    @Override
    public boolean isAvailable() {
        return true;
    }

    @Override
    public void destroy() {
    }

    @Override
    public Result invoke(Invocation invocation) throws RpcException {
        try {
            Object value = doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments());
			CompletableFuture<Object> future = wrapWithFuture(value);
            CompletableFuture<AppResponse> appResponseFuture = future.handle((obj, t) -> {
                AppResponse result = new AppResponse();
                if (t != null) {
                    if (t instanceof CompletionException) {
                        result.setException(t.getCause());
                    } else {
                        result.setException(t);
                    }
                } else {
                    result.setValue(obj);
                }
                return result;
            });
            return new AsyncRpcResult(appResponseFuture, invocation);
        } catch (InvocationTargetException e) {
            if (RpcContext.getContext().isAsyncStarted() && !RpcContext.getContext().stopAsync()) {
                logger.error("Provider async started, but got an exception from the original method, cannot write the exception back to consumer because an async result may have returned the new thread.", e);
            }
            return AsyncRpcResult.newDefaultAsyncResult(null, e.getTargetException(), invocation);
        } catch (Throwable e) {
            throw new RpcException("Failed to invoke remote proxy method " + invocation.getMethodName() + " to " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }

	private CompletableFuture<Object> wrapWithFuture(Object value) {
        if (RpcContext.getContext().isAsyncStarted()) {
            return ((AsyncContextImpl)(RpcContext.getContext().getAsyncContext())).getInternalFuture();
        } else if (value instanceof CompletableFuture) {
            return (CompletableFuture<Object>) value;
        }
        return CompletableFuture.completedFuture(value);
    }

    protected abstract Object doInvoke(T proxy, String methodName, Class<?>[] parameterTypes, Object[] arguments) throws Throwable;

    @Override
    public String toString() {
        return getInterface() + " -> " + (getUrl() == null ? " " : getUrl().toString());
    }


}

//代码有省略
public class InjvmProtocol extends AbstractProtocol implements Protocol {

@Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    	//创建一个InjvmExporter实例，InjvmExporter只是将道歉Invoker等缓存到本地
        return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
    }
    
}




class InjvmExporter<T> extends AbstractExporter<T> {

    private final String key;

    private final Map<String, Exporter<?>> exporterMap;

    InjvmExporter(Invoker<T> invoker, String key, Map<String, Exporter<?>> exporterMap) {
        super(invoker);
        this.key = key;
        this.exporterMap = exporterMap;
        exporterMap.put(key, this);
    }

    @Override
    public void unexport() {
        super.unexport();
        exporterMap.remove(key);
    }

}

		// 导出到远程的部分源码
String proxy = url.getParameter(PROXY_KEY);
if (StringUtils.isNotEmpty(proxy)) {
	//如果存在，则为注册地址添加代理实现参数
	registryURL = registryURL.addParameter(PROXY_KEY, proxy);
}

//为服务引用生成Invoker对象（和上面的本地导出代码差不多，这里变成了注册协议（将dubbo协议的地址作为export参数放入）
//registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=hlj-server-provider&dubbo=2.0.2&export=dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1&file=/Users/healerjean/Desktop/logs/hljServerProvider2001&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&registry=zookeeper&release=2.7.7&timestamp=1604408770574    
Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass,registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));

//生成提供者和配置包装Invoker(又多包装了一层)
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker,this);

//通过SPI自适应拓展获取Protocol的拓展实现，调用导出方法、这里使用的注册协议RegistryProtocol，还记得上面使用的是InJvmProtocol协议吧
Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);

//添加到导出器缓存
exporters.add(exporter);

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    // 获取注册中心 URL，以 zookeeper 注册中心为例，得到的示例 URL 如下：
    //zookeeper://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=hlj-server-provider&dubbo=2.0.2&export=dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1&file=/Users/healerjean/Desktop/logs/hljServerProvider2001&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&timestamp=1604408770574  

    URL registryUrl = getRegistryUrl(originInvoker);

    // 服务提供中地址（本地导出服务地址）
    // dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1
    URL providerUrl = getProviderUrl(originInvoker);

    // 获取订阅覆盖地址
    //provider://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&category=configurators&check=false&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);


    //创建覆盖监听器，存入缓存
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);


    //使用配置覆盖提供中者地址
   //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=13008&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605001242523&version=0.0.1
    providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);

    //导出服务，
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

    // 根据 URL 加载 Registry 实现类，比如 ZookeeperRegistry
    final Registry registry = getRegistry(originInvoker);
    
    // 获取已注册的服务提供者 URL
    final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
    
    // 获取 register 参数,默认为true
    boolean register = providerUrl.getParameter(REGISTER_KEY, true);

    if (register) {
        //为true则表示需要注册服务，向注册中心注册
        register(registryUrl, registeredProviderUrl);
    }
    

    // 不建议使用！订阅2.6.x或之前版本中的重写规则。
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    // 设置注册和订阅地址
    exporter.setRegisterUrl(registeredProviderUrl);
    exporter.setSubscribeUrl(overrideSubscribeUrl);
    //通知RegistryProtocolListener，服务导出
    notifyExport(exporter);
    //创建DestroyableExporter实例，确保每次导出时都返回一个新的导出器实例
    return new DestroyableExporter<>(exporter);
}





protected URL getRegistryUrl(Invoker<?> originInvoker) {
    URL registryUrl = originInvoker.getUrl();
    if (REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {
        String protocol = registryUrl.getParameter(REGISTRY_KEY, DEFAULT_REGISTRY);
        registryUrl = registryUrl.setProtocol(protocol).removeParameter(REGISTRY_KEY);
    }
    return registryUrl;
}

private URL getProviderUrl(final Invoker<?> originInvoker) {
    String export = originInvoker.getUrl().getParameterAndDecoded(EXPORT_KEY);
    if (export == null || export.length() == 0) {
        throw new IllegalArgumentException("The registry export url is null! registry: " + originInvoker.getUrl());
    }
    return URL.valueOf(export);
}

  private URL getSubscribedOverrideUrl(URL registeredProviderUrl) {
        return registeredProviderUrl.setProtocol(PROVIDER_PROTOCOL)
                .addParameters(CATEGORY_KEY, CONFIGURATORS_CATEGORY, CHECK_KEY, String.valueOf(false));
    }

//providerurl <--> exporter
private final ConcurrentMap<String, ExporterChangeableWrapper<?>> bounds = new ConcurrentHashMap<>();

private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
    //根据Invoker参数获取缓存key
    //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=13008&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605001242523&version=0.0.1
    String key = getCacheKey(originInvoker);

    //调用computeIfAbsent方法，将key和ExporterChangeableWrapper实例放入缓存

    return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
        // 创建InvokerDelegate委托类实例
        Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);

        // 创建ExporterChangeableWrapper实例，调用 DubboProtocol 的 export 方法导出服务
        return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
    });
}

protected final Map<String, Exporter<?>> exporterMap = new ConcurrentHashMap<String, Exporter<?>>();


@Override
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    // 获取URL dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4494&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604416434630&version=0.0.1
    URL url = invoker.getUrl();

    // 获取服务标识，理解成服务坐标也行。由服务组名，服务名，服务版本号以及端口组成。比如：
    // 163/com.healerjean.proj.service.MailClientService:0.0.1:20880
    String key = serviceKey(url);

    // 创建DubboExporter实例并放入缓存(其实到了这里基本上就算完事了，但是我们最重要的是启动dubbo服务)
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
    exporterMap.put(key, exporter);

    // 导出本地存根服务以发送事件
    Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
    Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
    if (isStubSupportEvent && !isCallbackservice) {
        String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
        if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
            if (logger.isWarnEnabled()) {
                logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY)
                                                      + "], has set stubproxy support event ,but no stub methods founded."));
            }

        }
    }

    // 启动服务器
    openServer(url);

    // 优化序列化
    optimizeSerialization(url);

    return exporter;
}

//dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=19748&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605004230369&version=0.0.1
private void openServer(URL url) {
    // 获取 host:port，并将其作为服务器实例的 key，用于标识当前的服务器实例
    //10.236.122.217:20880 
    String key = url.getAddress();

    // 在同一台机器上（单网卡），同一个端口上仅允许启动一个服务器实例。若某个端口上已有服务器实例，此时则调用 reset 方法重置服务器的一些配置。
    // 客户端可以导出只供服务器调用的服务，默认为true
    boolean isServer = url.getParameter(IS_SERVER_KEY, true);
    if (isServer) {
        // 双重检测创建服务（保证只创建一次）
        ProtocolServer server = serverMap.get(key);
        if (server == null) {
            synchronized (this) {
                server = serverMap.get(key);
                if (server == null) {
                    serverMap.put(key, createServer(url));
                }
            }
        } else {
            // 服务器已创建，则根据 url 中的配置重置服务器
            server.reset(url);
        }
    }
}


private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {


    private ProtocolServer createServer(URL url) {
        //第一步：检测是否存在`url`中 `server` 参数所代表的 `Transporter `拓展(默认是`netty`)，不存在则抛出异常。

        url = URLBuilder.from(url)
            // 服务器关闭时发送只读事件，默认情况下启用
            .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
            // 添加默认心跳检测参数60 * 1000
            .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
            // 添加编码解码器参数
            .addParameter(CODEC_KEY, DubboCodec.NAME).build();

        //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&channel.readonly.sent=true&codec=dubbo&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&heartbeat=60000&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=20112&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605004964820&version=0.0.1

        // 获取 server 参数，默认为 netty
        String str = url.getParameter(SERVER_KEY, DEFAULT_REMOTING_SERVER);

        // 通过 SPI 检测是否存在 server 参数所代表的 Transporter 拓展，不存在则抛出异常
        if (str != null && str.length() > 0
            && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
            throw new RpcException("Unsupported server type: " + str + ", url: " + url);
        }

        //第二步：创建服务器实例
        ExchangeServer server;
        try {// 创建 ExchangeServer
            server = Exchangers.bind(url, requestHandler);
        } catch (RemotingException e) {
            throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
        }

        //第三步：检测是否支持 `client` 参数所表示的` Transporter` 拓展，不存在也是抛出异常。 
        // 获取 client 参数，可指定 netty，mina。我这里默认进来是null。直接返回DubboProtocolServe服务
        str = url.getParameter(CLIENT_KEY);
        if (str != null && str.length() > 0) {
            // 通过SPI获取所有的 Transporter 实现类名称集合，比如 supportedTypes = [netty, mina]
            Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
            // 检测当前 Dubbo 所支持的 Transporter 实现类名称列表中， 是否包含 client 所表示的 Transporter，若不包含，则抛出异常
            if (!supportedTypes.contains(str)) {
                throw new RpcException("Unsupported client type: " + str);
            }
        }



        // 创建DubboProtocolServer实例并返回
        return new DubboProtocolServer(server);
    }

@SPI("netty")
public interface Transporter {

    /**
     * Bind a server.
     *
     * @param url     server url
     * @param handler
     * @return server
     * @throws RemotingException
     * @see org.apache.dubbo.remoting.Transporters#bind(URL, ChannelHandler...)
     */
    @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
    RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException;

    /**
     * Connect to a server.
     *
     * @param url     server url
     * @param handler
     * @return client
     * @throws RemotingException
     * @see org.apache.dubbo.remoting.Transporters#connect(URL, ChannelHandler...)
     */
    @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
    Client connect(URL url, ChannelHandler handler) throws RemotingException;

}

public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&channel.readonly.sent=true&codec=dubbo&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&heartbeat=60000&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=19940&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605006351222&version=0.0.1
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handler == null) {
        throw new IllegalArgumentException("handler == null");
    }

    //添加URL参数codec=exchange 
    url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");

    // 获取 Exchanger，默认为 HeaderExchanger。
    // 紧接着调用 HeaderExchanger 的 bind 方法创建 ExchangeServer 实例
    return getExchanger(url).bind(url, handler);
}


public static Exchanger getExchanger(URL url) {
    String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
    return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
    return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}

  @Override
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    	// 创建 HeaderExchangeServer 实例：
    	//   1. new HeaderExchangeHandler(handler)
    	//	 2. new DecodeHandler(new HeaderExchangeHandler(handler))
    	//   3. Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler)))
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }

public static RemotingServer bind(URL url, ChannelHandler... handlers) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handlers == null || handlers.length == 0) {
        throw new IllegalArgumentException("handlers == null");
    }
    ChannelHandler handler;
    if (handlers.length == 1) {
        handler = handlers[0];
    } else {
        // 如果 handlers 元素数量大于1，则创建 ChannelHandler 分发器
        handler = new ChannelHandlerDispatcher(handlers);
    }
    // 获取自适应 Transporter
    // 实例(ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();)，并调用bind实例方法
    return getTransporter().bind(url, handler);
}




//获取默认的NettyTransporter
public static Transporter getTransporter() {
    return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}

/**
 * Default extension of {@link Transporter} using netty4.x.
 */
public class NettyTransporter implements Transporter {

    public static final String NAME = "netty";

    @Override
    public RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException {
        return new NettyServer(url, handler);
    }

    @Override
    public Client connect(URL url, ChannelHandler handler) throws RemotingException {
        return new NettyClient(url, handler);
    }

}

public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
  //调用父类构造函数
  // 添加线程名称参数，可以在CommonConstants中按thread_name_KEY和THREADPOOL_KEY自定义客户机线程池的名称和类型,默认名称DubboServerHandler
  // 对handler进行包装MultiMessageHandler->HeartbeatHandler->handler
  super(ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME), ChannelHandlers.wrap(handler, url));
}

public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
    、、dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&channel.readonly.sent=true&codec=dubbo&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&heartbeat=60000&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=19940&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&threadname=DubboServerHandler-10.236.122.217:20880&timestamp=1605006351222&version=0.0.1
    // 调用父类构造方法(简单判断及解码器、超时时间等属性的获取赋值)
    super(url, handler);

    // 获取套接字地址
    localAddress = getUrl().toInetSocketAddress();

    //获取 ip 和端口
    String bindIp = getUrl().getParameter(Constants.BIND_IP_KEY, getUrl().getHost());
    int bindPort = getUrl().getParameter(Constants.BIND_PORT_KEY, getUrl().getPort());

    if (url.getParameter(ANYHOST_KEY, false) || NetUtils.isInvalidLocalHost(bindIp)) {
        // anyhost=true或者是无效的本地主机则设置ip为0.0.0.0
        bindIp = ANYHOST_VALUE;
    }

    // 创建绑定套接字地址
    bindAddress = new InetSocketAddress(bindIp, bindPort);
    // 获取最大可接受连接数,默认0
    this.accepts = url.getParameter(ACCEPTS_KEY, DEFAULT_ACCEPTS);
    // 获取超时时间 默认600000毫秒
    this.idleTimeout = url.getParameter(IDLE_TIMEOUT_KEY, DEFAULT_IDLE_TIMEOUT);
    try {
        // 打开服务
        doOpen();
        if (logger.isInfoEnabled()) {
            logger.info("Start " + getClass().getSimpleName() + " bind " + getBindAddress() + ", export "
                        + getLocalAddress());
        }
    } catch (Throwable t) {
        throw new RemotingException(url.toInetSocketAddress(), null, "Failed to bind " + getClass().getSimpleName()
                                    + " on " + getLocalAddress() + ", cause: " + t.getMessage(), t);
    }
    // 创建执行器
    executor = executorRepository.createExecutorIfAbsent(url);
}

protected void doOpen() throws Throwable {
    // 创建服务启动器
    bootstrap = new ServerBootstrap();
    // 创建 boss 和 worker 事件组
    bossGroup = NettyEventLoopFactory.eventLoopGroup(1, "NettyServerBoss");
    workerGroup = NettyEventLoopFactory.eventLoopGroup(
        getUrl().getPositiveParameter(IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS), "NettyServerWorker");
    // 创建NettyServer处理类实例
    final NettyServerHandler nettyServerHandler = new NettyServerHandler(getUrl(), this);
    channels = nettyServerHandler.getChannels();
    // 设置boss和worker事件组
    bootstrap.group(bossGroup, workerGroup)
        // 设置SocketChannel
        .channel(NettyEventLoopFactory.serverSocketChannelClass())
        // SO_REUSEADDR是让端口释放后立即就可以被再次使用。
        .option(ChannelOption.SO_REUSEADDR, Boolean.TRUE)
        // TCP_NODELAY选项是用来控制是否开启Nagle算法，该算法是为了提高较慢的广域网传输效率
        .childOption(ChannelOption.TCP_NODELAY, Boolean.TRUE)
        // 创建一个 池化或非池化的缓存区分配器
        .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
        // 添加孩子渠道初始化处理实例
        .childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                // 初始化通道时进行管道pipeline编码解码器等设置
                int idleTimeout = UrlUtils.getIdleTimeout(getUrl());
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
                if (getUrl().getParameter(SSL_ENABLED_KEY, false)) {
                    ch.pipeline().addLast("negotiation",
                                          SslHandlerInitializer.sslServerHandler(getUrl(), nettyServerHandler));
                }
                ch.pipeline().addLast("decoder", adapter.getDecoder()).addLast("encoder", adapter.getEncoder())
                    .addLast("server-idle-handler", new IdleStateHandler(0, 0, idleTimeout, MILLISECONDS))
                    .addLast("handler", nettyServerHandler);
            }
        });
    // 绑定到指定的 ip 和端口上
    ChannelFuture channelFuture = bootstrap.bind(getBindAddress());
    // 不间断同步
    channelFuture.syncUninterruptibly();
    channel = channelFuture.channel();

}

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    // 获取注册中心 URL，以 zookeeper 注册中心为例，得到的示例 URL 如下：
    //zookeeper://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=hlj-server-provider&dubbo=2.0.2&export=dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1&file=/Users/healerjean/Desktop/logs/hljServerProvider2001&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&timestamp=1604408770574  

    URL registryUrl = getRegistryUrl(originInvoker);

    // 服务提供中地址（本地导出服务地址）
    // dubbo://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1
    URL providerUrl = getProviderUrl(originInvoker);

    // 获取订阅覆盖地址
    //provider://127.0.0.1:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=127.0.0.1&bind.port=20880&category=configurators&check=false&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=4248&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1604408770580&version=0.0.1
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);


    //创建覆盖监听器，存入缓存
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);


    //使用配置覆盖提供中者地址
   //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&bind.ip=10.236.122.217&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=13008&qos.accept.foreign.ip=false&qos.enable=true&qos.port=40880&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605001242523&version=0.0.1
    providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);

    //导出服务，
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

    // 根据 URL 加载 Registry 实现类
    final Registry registry = getRegistry(originInvoker);
    
    // 获取已注册的服务提供者 URL
    //dubbo://10.236.122.217:20880/com.healerjean.proj.service.MailClientService?anyhost=true&application=hlj-server-provider&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=163&interface=com.healerjean.proj.service.MailClientService&methods=sentMail&pid=19940&release=2.7.7&revision=0.0.1&side=provider&timestamp=1605006351222&version=0.0.1
    final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
    
    // 获取 register 参数,默认为true
    boolean register = providerUrl.getParameter(REGISTER_KEY, true);

    if (register) {
        //为true则表示需要注册服务，向注册中心注册
        register(registryUrl, registeredProviderUrl);
    }
    

    // 不建议使用！订阅2.6.x或之前版本中的重写规则。
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    // 设置注册和订阅地址
    exporter.setRegisterUrl(registeredProviderUrl);
    exporter.setSubscribeUrl(overrideSubscribeUrl);
    //通知RegistryProtocolListener，服务导出
    notifyExport(exporter);
    //创建DestroyableExporter实例，确保每次导出时都返回一个新的导出器实例
    return new DestroyableExporter<>(exporter);
}