dubbo 多注册中心

已于 2022-02-17 17:20:56 修改
阅读量2.6k 收藏 1
点赞数
分类专栏： dubbo 文章标签： dubbo
于 2022-02-15 09:24:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/122936258
版权

dubbo 多注册中心

               

官网：https://dubbo.apache.org/zh/docs/advanced/multi-registry/

                

              

                                  

多注册中心

            

同服务多注册中心注册：同时将服务注册到多个注册中心

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:application name="world"  />
    <!-- 多注册中心配置 -->
    <dubbo:registry id="hangzhouRegistry" address="10.20.141.150:9090" />
    <dubbo:registry id="qingdaoRegistry" address="10.20.141.151:9010" default="false" />

    <!-- 向多个注册中心注册 -->
    <dubbo:service interface="com.alibaba.hello.api.HelloService" version="1.0.0" ref="helloService" registry="hangzhouRegistry,qingdaoRegistry" />
</beans>

                   

不同服务向不同注册中心注册

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:application name="world"  />
    <!-- 多注册中心配置 -->
    <dubbo:registry id="chinaRegistry" address="10.20.141.150:9090" />
    <dubbo:registry id="intlRegistry" address="10.20.154.177:9010" default="false" />

    <!-- 向中文站注册中心注册 -->
    <dubbo:service interface="com.alibaba.hello.api.HelloService" version="1.0.0" ref="helloService" registry="chinaRegistry" />
    <!-- 向国际站注册中心注册 -->
    <dubbo:service interface="com.alibaba.hello.api.DemoService" version="1.0.0" ref="demoService" registry="intlRegistry" />
</beans>

              

多注册中心引用：客户端调用不同注册中心的同一接口

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:application name="world"  />
    <!-- 多注册中心配置 -->
    <dubbo:registry id="chinaRegistry" address="10.20.141.150:9090" />
    <dubbo:registry id="intlRegistry" address="10.20.154.177:9010" default="false" />

    <!-- 引用中文站服务 -->
    <dubbo:reference id="chinaHelloService" interface="com.alibaba.hello.api.HelloService" version="1.0.0" registry="chinaRegistry" />
    <!-- 引用国际站站服务 -->
    <dubbo:reference id="intlHelloService" interface="com.alibaba.hello.api.HelloService" version="1.0.0" registry="intlRegistry" />
</beans>

        

注册中心配置多个地址

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:application name="world"  />
    <!-- 多注册中心配置，竖号分隔表示同时连接多个不同注册中心，同一注册中心的多个集群地址用逗号分隔 -->
    <dubbo:registry address="10.20.141.150:9090|10.20.154.177:9010" />

    <!-- 引用服务 -->
    <dubbo:reference id="helloService" interface="com.alibaba.hello.api.HelloService" version="1.0.0" />
</beans>

             

                

                                  

实现原理

            

服务暴露加载注册中心调用栈

# ConfigValidationUtils加载注册中心
at org.apache.dubbo.config.utils.ConfigValidationUtils.loadRegistries(ConfigValidationUtils.java:194)

# ServiceConfig类
at org.apache.dubbo.config.ServiceConfig.doExportUrls(ServiceConfig.java:380)
at org.apache.dubbo.config.ServiceConfig.doExport(ServiceConfig.java:363)
	  - locked <0x1b6b> (a org.apache.dubbo.config.spring.ServiceBean)
at org.apache.dubbo.config.ServiceConfig.export(ServiceConfig.java:237)

# DefaultModuleDeployer类
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.exportServiceInternal(DefaultModuleDeployer.java:338)
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.exportServices(DefaultModuleDeployer.java:310)
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.start(DefaultModuleDeployer.java:142)
	  - locked <0x1ee7> (a org.apache.dubbo.config.deploy.DefaultModuleDeployer)

# DubboDeployApplicationListener类
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onContextRefreshedEvent(DubboDeployApplicationListener.java:108)
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onApplicationEvent(DubboDeployApplicationListener.java:98)
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onApplicationEvent(DubboDeployApplicationListener.java:44)

# SimpleApplicationEventMulticaster
at org.springframework.context.event.SimpleApplicationEventMulticaster.doInvokeListener(SimpleApplicationEventMulticaster.java:176)
at org.springframework.context.event.SimpleApplicationEventMulticaster.invokeListener(SimpleApplicationEventMulticaster.java:169)
at org.springframework.context.event.SimpleApplicationEventMulticaster.multicastEvent(SimpleApplicationEventMulticaster.java:143)

# AbstractApplicationContext类
at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:421)
at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:378)
at org.springframework.context.support.AbstractApplicationContext.finishRefresh(AbstractApplicationContext.java:938)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:586)
	  - locked <0x1ee8> (a java.lang.Object)

# ServletWebServerApplicationContext类
at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145)

# SpringApplication类
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:730)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:412)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:302)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1301)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1290)

# 项目启动入口
at com.example.demo.DemoApplication.main(DemoApplication.java:12)

                

ServiceConfig

public class ServiceConfig<T> extends ServiceConfigBase<T> {

    protected synchronized void doExport() {  //服务暴露
        if (unexported) {
            throw new IllegalStateException("The service " + interfaceClass.getName() + " has already unexported!");
        }
        if (exported) {
            return;
        }

        if (StringUtils.isEmpty(path)) {
            path = interfaceName;
        }
        doExportUrls();    //服务暴露
        exported();
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    private void doExportUrls() {
        ModuleServiceRepository repository = getScopeModel().getServiceRepository();
        ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
        providerModel = new ProviderModel(getUniqueServiceName(),
            ref,
            serviceDescriptor,
            this,
            getScopeModel(),
            serviceMetadata);

        repository.registerProvider(providerModel);

        List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
                                                       //加载注册中心

        for (ProtocolConfig protocolConfig : protocols) {
            String pathKey = URL.buildKey(getContextPath(protocolConfig)
                    .map(p -> p + "/" + path)
                    .orElse(path), group, version);
            // In case user specified path, register service one more time to map it to path.
            repository.registerService(pathKey, interfaceClass);
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

               

ConfigValidationUtils

public class ConfigValidationUtils {

    public static List<URL> loadRegistries(AbstractInterfaceConfig interfaceConfig, boolean provider) {
                            //加载注册中心
        // check && override if necessary
        List<URL> registryList = new ArrayList<URL>();
        ApplicationConfig application = interfaceConfig.getApplication();
        List<RegistryConfig> registries = interfaceConfig.getRegistries();
        if (CollectionUtils.isNotEmpty(registries)) {
            for (RegistryConfig config : registries) {
                String address = config.getAddress();
                if (StringUtils.isEmpty(address)) {
                    address = ANYHOST_VALUE;
                }
                if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
                    Map<String, String> map = new HashMap<String, String>();  //存储url参数
                    AbstractConfig.appendParameters(map, application);
                    AbstractConfig.appendParameters(map, config);
                    map.put(PATH_KEY, RegistryService.class.getName());
                    AbstractInterfaceConfig.appendRuntimeParameters(map);
                    if (!map.containsKey(PROTOCOL_KEY)) {
                        map.put(PROTOCOL_KEY, DUBBO_PROTOCOL);
                    }
                    List<URL> urls = UrlUtils.parseURLs(address, map);  //解析address，转换生成url

                    for (URL url : urls) {
                        url = URLBuilder.from(url)
                            .addParameter(REGISTRY_KEY, url.getProtocol())
                            .setProtocol(extractRegistryType(url))
                            .setScopeModel(interfaceConfig.getScopeModel())
                            .build();
                        if ((provider && url.getParameter(REGISTER_KEY, true))
                            || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) {
                            registryList.add(url);
                        }
                    }
                }
            }
        }
        return genCompatibleRegistries(interfaceConfig.getScopeModel(), registryList, provider);
    }

    private static List<URL> genCompatibleRegistries(ScopeModel scopeModel, List<URL> registryList, boolean provider) {
                             //生成注册中心地址：接口粒度、应用粒度地址
        List<URL> result = new ArrayList<>(registryList.size());
        registryList.forEach(registryURL -> {
            if (provider) {
                // for registries enabled service discovery, automatically register interface compatible addresses.
                String registerMode;
                if (SERVICE_REGISTRY_PROTOCOL.equals(registryURL.getProtocol())) {
                                   //registryURL.getProtocol()为registry，与"service-discovery-registry"不等
                    registerMode = registryURL.getParameter(REGISTER_MODE_KEY, ConfigurationUtils.getCachedDynamicProperty(scopeModel, DUBBO_REGISTER_MODE_DEFAULT_KEY, DEFAULT_REGISTER_MODE_INSTANCE));
                    if (!isValidRegisterMode(registerMode)) {
                        registerMode = DEFAULT_REGISTER_MODE_INSTANCE;
                    }
                    result.add(registryURL);
                    if (DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode)
                        && registryNotExists(registryURL, registryList, REGISTRY_PROTOCOL)) {
                        URL interfaceCompatibleRegistryURL = URLBuilder.from(registryURL)
                            .setProtocol(REGISTRY_PROTOCOL)
                            .removeParameter(REGISTRY_TYPE_KEY)
                            .build();
                        result.add(interfaceCompatibleRegistryURL);
                    }
                } else {  //不相等，跳转到此处执行
                    registerMode = registryURL.getParameter(REGISTER_MODE_KEY, ConfigurationUtils.getCachedDynamicProperty(scopeModel, DUBBO_REGISTER_MODE_DEFAULT_KEY, DEFAULT_REGISTER_MODE_ALL));
                                 //获取registerMode
                    if (!isValidRegisterMode(registerMode)) {
                        registerMode = DEFAULT_REGISTER_MODE_INTERFACE;
                    }  //检验registerMode
                    if ((DEFAULT_REGISTER_MODE_INSTANCE.equalsIgnoreCase(registerMode) || DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode))
                        && registryNotExists(registryURL, registryList, SERVICE_REGISTRY_PROTOCOL)) {
                        URL serviceDiscoveryRegistryURL = URLBuilder.from(registryURL)
                            .setProtocol(SERVICE_REGISTRY_PROTOCOL)
                            .removeParameter(REGISTRY_TYPE_KEY)
                            .build();    //生成应用粒度地址：协议为service-discovery-registry
                        result.add(serviceDiscoveryRegistryURL);
                    }   //添加应用粒度注册地址

                    if (DEFAULT_REGISTER_MODE_INTERFACE.equalsIgnoreCase(registerMode) || DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode)) {
                        result.add(registryURL);
                    }   //如果registerMode为interface或者all，添加接口粒度注册地址
                }

                FrameworkStatusReportService reportService = ScopeModelUtil.getApplicationModel(scopeModel).getBeanFactory().getBean(FrameworkStatusReportService.class);
                reportService.reportRegistrationStatus(reportService.createRegistrationReport(registerMode));
            } else {
                result.add(registryURL);
            }
        });

        return result;
    }

    private static boolean isValidRegisterMode(String mode) {
        return StringUtils.isNotEmpty(mode)
            && (DEFAULT_REGISTER_MODE_INTERFACE.equalsIgnoreCase(mode)
            || DEFAULT_REGISTER_MODE_INSTANCE.equalsIgnoreCase(mode)
            || DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(mode)
        );  //mode不为空，且为instance、interface、all三者之一，返回true
    }

       

UrlUtils

public class UrlUtils {

    public static List<URL> parseURLs(String address, Map<String, String> defaults) {
        if (StringUtils.isEmpty(address)) {
            throw new IllegalArgumentException("Address is not allowed to be empty, please re-enter.");
        }
        String[] addresses = REGISTRY_SPLIT_PATTERN.split(address);
                            //CommonConstants.REGISTRY_SPLIT_PATTERN = Pattern.compile("\\s*[|;]+\\s*");
                            //使用｜、;，分割字符串adress，转换为数组存储
        if (addresses == null || addresses.length == 0) {
            throw new IllegalArgumentException("Addresses is not allowed to be empty, please re-enter."); //here won't be empty
        }
        List<URL> registries = new ArrayList<URL>();
        for (String addr : addresses) {
            registries.add(parseURL(addr, defaults));
        }
        return registries;
    }

          

               

消费端加载注册中心调用栈

# ConfigValidationUtils.loadRegistries：加载注册中心
at org.apache.dubbo.config.utils.ConfigValidationUtils.loadRegistries(ConfigValidationUtils.java:194)

# ReferenceConfig类
at org.apache.dubbo.config.ReferenceConfig.aggregateUrlFromRegistry(ReferenceConfig.java:462)
at org.apache.dubbo.config.ReferenceConfig.createProxy(ReferenceConfig.java:383)
at org.apache.dubbo.config.ReferenceConfig.init(ReferenceConfig.java:275)
	  - locked <0x1da2> (a org.apache.dubbo.config.ReferenceConfig)
at org.apache.dubbo.config.ReferenceConfig.get(ReferenceConfig.java:216)

# SimpleReferenceCache类
at org.apache.dubbo.config.utils.SimpleReferenceCache.get(SimpleReferenceCache.java:110)

# DefaultModuleDeployer类
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.lambda$referServices$6(DefaultModuleDeployer.java:384)
at org.apache.dubbo.config.deploy.DefaultModuleDeployer$$Lambda$880/0x0000000801039dc8.accept(Unknown Source:-1)
	  at java.util.concurrent.ConcurrentHashMap$ValuesView.forEach(ConcurrentHashMap.java:4780)
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.referServices(DefaultModuleDeployer.java:364)
at org.apache.dubbo.config.deploy.DefaultModuleDeployer.start(DefaultModuleDeployer.java:151)
	  - locked <0x21b8> (a org.apache.dubbo.config.deploy.DefaultModuleDeployer)

# DubboDeployApplicationListener类
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onContextRefreshedEvent(DubboDeployApplicationListener.java:108)
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onApplicationEvent(DubboDeployApplicationListener.java:98)
at org.apache.dubbo.config.spring.context.DubboDeployApplicationListener.onApplicationEvent(DubboDeployApplicationListener.java:44)

# SimpleApplicationEventMulticaster类
at org.springframework.context.event.SimpleApplicationEventMulticaster.doInvokeListener(SimpleApplicationEventMulticaster.java:176)
at org.springframework.context.event.SimpleApplicationEventMulticaster.invokeListener(SimpleApplicationEventMulticaster.java:169)
at org.springframework.context.event.SimpleApplicationEventMulticaster.multicastEvent(SimpleApplicationEventMulticaster.java:143)

# AbstractApplicationContext类
at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:421)
at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:378)
at org.springframework.context.support.AbstractApplicationContext.finishRefresh(AbstractApplicationContext.java:938)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:586)
	  - locked <0x21b9> (a java.lang.Object)

# ServletWebServerApplicationContext类
at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145)

# SpringApplication类
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:730)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:412)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:302)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1301)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1290)

# 项目启动入口
at com.example.demo.DemoApplication.main(DemoApplication.java:14)

                

ConfigValidationUtils：加载注册中心

public class ConfigValidationUtils {

    public static List<URL> loadRegistries(AbstractInterfaceConfig interfaceConfig, boolean provider) {
                            //加载注册中心，消费端provider为false
        // check && override if necessary
        List<URL> registryList = new ArrayList<URL>();
        ApplicationConfig application = interfaceConfig.getApplication();
        List<RegistryConfig> registries = interfaceConfig.getRegistries();
        if (CollectionUtils.isNotEmpty(registries)) {
            for (RegistryConfig config : registries) {
                String address = config.getAddress();
                if (StringUtils.isEmpty(address)) {
                    address = ANYHOST_VALUE;
                }
                if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
                    Map<String, String> map = new HashMap<String, String>();
                    AbstractConfig.appendParameters(map, application);
                    AbstractConfig.appendParameters(map, config);
                    map.put(PATH_KEY, RegistryService.class.getName());
                    AbstractInterfaceConfig.appendRuntimeParameters(map);
                    if (!map.containsKey(PROTOCOL_KEY)) {
                        map.put(PROTOCOL_KEY, DUBBO_PROTOCOL);
                    }
                    List<URL> urls = UrlUtils.parseURLs(address, map);  //解析生成url地址

                    for (URL url : urls) {
                        url = URLBuilder.from(url)
                            .addParameter(REGISTRY_KEY, url.getProtocol())
                            .setProtocol(extractRegistryType(url))
                            .setScopeModel(interfaceConfig.getScopeModel())
                            .build();  //设置url参数，构建url
                        if ((provider && url.getParameter(REGISTER_KEY, true))
                            || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) {
                            registryList.add(url);
                        }
                    }
                }
            }
        }
        return genCompatibleRegistries(interfaceConfig.getScopeModel(), registryList, provider);
               //生成注册中心地址
    }

    private static List<URL> genCompatibleRegistries(ScopeModel scopeModel, List<URL> registryList, boolean provider) {
        List<URL> result = new ArrayList<>(registryList.size());
        registryList.forEach(registryURL -> {
            if (provider) {  //provider为false
                // for registries enabled service discovery, automatically register interface compatible addresses.
                String registerMode;
                if (SERVICE_REGISTRY_PROTOCOL.equals(registryURL.getProtocol())) {
                    registerMode = registryURL.getParameter(REGISTER_MODE_KEY, ConfigurationUtils.getCachedDynamicProperty(scopeModel, DUBBO_REGISTER_MODE_DEFAULT_KEY, DEFAULT_REGISTER_MODE_INSTANCE));
                    if (!isValidRegisterMode(registerMode)) {
                        registerMode = DEFAULT_REGISTER_MODE_INSTANCE;
                    }
                    result.add(registryURL);
                    if (DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode)
                        && registryNotExists(registryURL, registryList, REGISTRY_PROTOCOL)) {
                        URL interfaceCompatibleRegistryURL = URLBuilder.from(registryURL)
                            .setProtocol(REGISTRY_PROTOCOL)
                            .removeParameter(REGISTRY_TYPE_KEY)
                            .build();
                        result.add(interfaceCompatibleRegistryURL);
                    }
                } else {
                    registerMode = registryURL.getParameter(REGISTER_MODE_KEY, ConfigurationUtils.getCachedDynamicProperty(scopeModel, DUBBO_REGISTER_MODE_DEFAULT_KEY, DEFAULT_REGISTER_MODE_ALL));
                    if (!isValidRegisterMode(registerMode)) {
                        registerMode = DEFAULT_REGISTER_MODE_INTERFACE;
                    }
                    if ((DEFAULT_REGISTER_MODE_INSTANCE.equalsIgnoreCase(registerMode) || DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode))
                        && registryNotExists(registryURL, registryList, SERVICE_REGISTRY_PROTOCOL)) {
                        URL serviceDiscoveryRegistryURL = URLBuilder.from(registryURL)
                            .setProtocol(SERVICE_REGISTRY_PROTOCOL)
                            .removeParameter(REGISTRY_TYPE_KEY)
                            .build();
                        result.add(serviceDiscoveryRegistryURL);
                    }

                    if (DEFAULT_REGISTER_MODE_INTERFACE.equalsIgnoreCase(registerMode) || DEFAULT_REGISTER_MODE_ALL.equalsIgnoreCase(registerMode)) {
                        result.add(registryURL);
                    }
                }

                FrameworkStatusReportService reportService = ScopeModelUtil.getApplicationModel(scopeModel).getBeanFactory().getBean(FrameworkStatusReportService.class);
                reportService.reportRegistrationStatus(reportService.createRegistrationReport(registerMode));
            } else {  //provider为false
                result.add(registryURL);  //直接返回url地址
            }
        });

        return result;
    }

         

注册中心地址设置为loclahost:2181|localhost:2182，loadRegistries读取的地址

# application.yml
dubbo:
  application:
    name: dubbo-consumer
  registry:
    group: dubbo
    protocol: zookeeper
    address: localhost:2181|localhost:2182

            

                  

ReferenceConfig

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {

    private T createProxy(Map<String, String> referenceParameters) {
        if (shouldJvmRefer(referenceParameters)) {
            createInvokerForLocal(referenceParameters);
        } else {
            urls.clear();
            if (url != null && url.length() > 0) {
                // user specified URL, could be peer-to-peer address, or register center's address.
                parseUrl(referenceParameters);
            } else {
                // if protocols not in jvm checkRegistry
                if (!LOCAL_PROTOCOL.equalsIgnoreCase(getProtocol())) {
                    aggregateUrlFromRegistry(referenceParameters);
                }
            }
            createInvokerForRemote();   //创建远程服务invoker
        }

        if (logger.isInfoEnabled()) {
            logger.info("Referred dubbo service " + interfaceClass.getName());
        }

        URL consumerUrl = new ServiceConfigURL(CONSUMER_PROTOCOL, referenceParameters.get(REGISTER_IP_KEY), 0,
            referenceParameters.get(INTERFACE_KEY), referenceParameters);
        consumerUrl = consumerUrl.setScopeModel(getScopeModel());
        consumerUrl = consumerUrl.setServiceModel(consumerModel);
        MetadataUtils.publishServiceDefinition(consumerUrl);

        // create service proxy
        return (T) proxyFactory.getProxy(invoker, ProtocolUtils.isGeneric(generic));
    }

   private void createInvokerForRemote() {
        if (urls.size() == 1) {    //单注册中心
            URL curUrl = urls.get(0);
            invoker = protocolSPI.refer(interfaceClass,curUrl);
            if (!UrlUtils.isRegistry(curUrl)){
                List<Invoker<?>> invokers = new ArrayList<>();
                invokers.add(invoker);
                invoker = Cluster.getCluster(scopeModel, Cluster.DEFAULT).join(new StaticDirectory(curUrl, invokers), true);
            }
        } else {                  //多注册中心
            List<Invoker<?>> invokers = new ArrayList<>();
            URL registryUrl = null;
            for (URL url : urls) {    //遍历注册中心，创建invoker
                // For multi-registry scenarios, it is not checked whether each referInvoker is available.
                // Because this invoker may become available later.
                invokers.add(protocolSPI.refer(interfaceClass, url));

                if (UrlUtils.isRegistry(url)) {
                    // use last registry url
                    registryUrl = url;   //使用最后一个注册中心地址
                }
            }

            if (registryUrl != null) {
                // registry url is available
                // for multi-subscription scenario, use 'zone-aware' policy by default
                String cluster = registryUrl.getParameter(CLUSTER_KEY, ZoneAwareCluster.NAME);
                // The invoker wrap sequence would be: ZoneAwareClusterInvoker(StaticDirectory) -> FailoverClusterInvoker
                // (RegistryDirectory, routing happens here) -> Invoker
                invoker = Cluster.getCluster(registryUrl.getScopeModel(), cluster, false).join(new StaticDirectory(registryUrl, invokers), false);
                         //先用staticDirectory构建ZoneAwareClusterInvoker，
                         //ZoneAwareClusterInvoker先执行，
                         //再执行failoverClusterInvoker（默认为该incoker，也可为其他invoker，由容错策略cluster设置）
            } else {
                // not a registry url, must be direct invoke.
                if (CollectionUtils.isEmpty(invokers)) {
                    throw new IllegalArgumentException("invokers == null");
                }
                URL curUrl = invokers.get(0).getUrl();
                String cluster = curUrl.getParameter(CLUSTER_KEY, Cluster.DEFAULT);
                invoker = Cluster.getCluster(scopeModel, cluster).join(new StaticDirectory(curUrl, invokers), true);
            }
        }
    }

              

            

                                  

配置示例

         

，间隔 ==> 表示同一集群

# 服务提供端（dubbo-provider）
dubbo:
  application:
    name: dubbo-provider
    #register-mode: instance
  registry:
    group: dubbo
    protocol: zookeeper
    address: localhost:2181,localhost:2182    #localhost:2181、localhost:2182为同一集群


# 服务消费端（dubbo-consumer）
dubbo:
  application:
    name: dubbo-consumer
  registry:
    group: dubbo
    protocol: zookeeper
    address: localhost:2181,localhost:2182    #localhost:2181、localhost:2182为同一集群

                   

| 或者 ；间隔 ==> 表示不在同一集群内

# 服务提供端（dubbo-provider）
dubbo:
  application:
    name: dubbo-provider
    #register-mode: instance
  registry:
    group: dubbo
    protocol: zookeeper                        #使用zookeeper
    address: localhost:2181｜localhost:2182    #localhost:2181、localhost:2182为不同集群

# 服务消费端（dubbo-onsumer）
dubbo:
  application:
    name: dubbo-provider
    #register-mode: instance
  registry:
    group: dubbo
    protocol: zookeeper
    address: localhost:2181｜localhost:2182    #localhost:2181、localhost:2182为不同集群

                

                  

注册中心分别配置

# 服务提供端（dubbo-provider）
dubbo:
  application:
    name: dubbo-provider
  registries:
    2181:                     //注册中心的key
      group: dubbo4
      protocol: zookeeper
      address: localhost:2181
    2182:                     //注册中心的key
      group: dubbo3
      protocol: zookeeper
      address: localhost:2182
      default: true           //如果不指定，默认使用该注册中心
  protocol:
    name: dubbo
    port: 20880

            

服务暴露

@DubboService(registry = {"2182"})
//@DubboService(registry = {"2181","2182"})
public class HelloServiceImpl implements HelloService {

    @Override
    public List<String> hello() {
        System.out.println("hello provider");

        return Collections.singletonList("hello provider");
    }
}

           

服务调用

@RestController
public class HelloController {

    @DubboReference(registry = {"2181"})
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello(){
        helloService.hello().forEach(System.out::print);

        return "hello consumer 2";
    }
}

              

                      

o_瓜田李下_o
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud | Dubbo 微服务实战——注册中心详解
Why_does_it_work的博客
12-04 6845
Eureka,Nacos,Consul,Zookeeper在Spring Cloud和Dubbo中实战
Dubbo 注册中心详解
weixin_56018532的博客
08-20 2079
Dubbo 注册中心详解
dubbo服务消费的实现原理：单注册+多注册中心+直连服务消费原理
2401_83384536的博客
03-23 905
在介绍了服务暴露原理之后，我们重点探讨服务是如何消费的。本节主要讲解如何通过注册中心进行服务发现(包括多注册中心服务消费)和绕过注册中心进行远程服务调用等细节。服务端会执行调用拦截，客户端拦截也会在本节探讨。
SpringCloud Dubbo 微服务实战——注册中心详解_dubbo微服务注册中心(2)
最新发布
2401_84007049的博客
05-12 814
Spring Cloud 微服务快速上手》介绍了当下*主流的属于Spring生态的微服务框架，它继承了Spring Boot的优点，开发部署都非常简单。本书内容全面，介绍了微服务架构的发展历程，包含Spring Cloud Netflix 和 Spring Cloud Alibaba的组件，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等。在解读核心组件的实现原理的同时，配以案例进行实践。本书内容包含微服务架构和云原生架构，读者在掌握微服务之后，可以进一步掌握云原生知识。
Dubbo中应用级，与接口级配置中心的使用，包括单配置中心与多配置中心
weixin_43988251的博客
02-13 1613
Dubbo3 默认采用 “应用级服务发现 + 接口级服务发现” 的双注册模式，dubbo单配置中心，dubbo多配置中心使用
dubbo多注册中心
飞奔的波大爷的博客
10-19 6201
多注册中心 Dubbo 支持同一服务向多注册中心同时注册，或者不同服务分别注册到不同的注册中心上去，甚至可以同时引用注册在不同注册中心上的同名服务。另外，注册中心是支持自定义扩展的。 多注册中心注册 比如：中文站有些服务来不及在成都部署，只在杭州部署，而成都的其它应用需要引用此服务，就可以将服务同时注册到两个注册中心。 &lt;?xml version="1.0" encoding="UTF-8"...
springboot dubbo 无注册中心 直连模式 demo
07-21
在本项目中，我们探讨的是如何在SpringBoot环境中配置Dubbo服务，实现无注册中心的直连模式。这种模式在一些简单的微服务架构或者测试环境中非常常见，它省去了中间注册中心的环节，使得消费者和服务提供者可以直接...
dubbo monitor dubbo注册中心
09-21
dubbo-monitor-simple-2.5.10-assembly.tar.gz 这是自己编译的内容 因为现在资源价格飞起 所以搞掂东西买卖 不要24 不要14 只要3积分 如果积分张了 我可以改
dubbo2.53 注册中心
04-25
这个压缩包文件“dubbo-registry-simple-2.5.3”包含了Dubbo注册中心的基础实现。 1. **注册中心的作用**： - **服务注册**：服务提供者启动时，会将自己提供的服务注册到注册中心，以便其他服务能够找到。 - **...
springboot dubbo 融合以及支持多注册中心
04-13
springboot dubbo 融合以及支持多注册中心，演示了多注册中心如何配置，协议api参考：https://download.csdn.net/download/itexplorersfather/10346692
dubbo注册客户端，客户端监测工具
07-05
dubbo注册客户端，客户端管理工具，dubbo-admin是Dubbo RPC框架的“管理端”，可以对注册的服务(provider)和服务调用方(comsumer)进行服务治理，包括路由、监控、配置等功能；
dubbo注册中心文件
11-12
dubbo-admin-0.2.0-SNAPSHOT.jar ====> dubbo-admin 后台管理服务 start.sh ====> 容器服务启动脚本，通过这个脚本，同时运行两个服务 dubbo.tar ====> 我自己的镜像文件 使用说明 1、dubbo.tar为我...
Java-dubbo实践代码（注册中心）
11-23
本实践代码是基于Java的Dubbo框架和Zookeeper作为注册中心的一个示例，旨在帮助开发者理解如何在实际项目中配置和使用这两种技术。 首先，让我们深入了解Dubbo的核心概念： 1. **服务提供者（Provider）**：提供...
Dubbo简易注册中心发布包（2.5.4开发版）
10-27
总的来说，"Dubbo简易注册中心发布包（2.5.4开发版）"是一个方便开发者快速体验和测试Dubbo注册中心功能的工具，它简化了部署步骤，适用于学习、实验或者小型项目的快速开发。不过，对于大型复杂系统，可能需要考虑...
Dubbo zookeeper注册中心文档
07-27
Zookeeper一个分布式的服务框架，是树型的目录服务的数据存储，能做到集群管理数据 ，这里能很好的作为Dubbo服务的注册中心，Dubbo能与Zookeeper做到集群部署，当提供者出现断电等异常停机时，Zookeeper注册中心能...
Dubbo —— 监控中心
03-10
incubator-ops-master.rar，控制台进入到incubator-dubbo-ops-master\dubbo-admin\target目录下，输入命令 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar 启动监控中心，但是前提是开启了ZooKeeper注册中心
Dubbo：注册多个注册中心（不是集群，而是多个不同环境）
不花的花和尚的博客
01-22 3717
第1步：配置多个provider   第2步： 三个provider截图：   第3步: 第4步： 第5步：    
五：Dubbo中Provider参数配置及源码讲解
web18484626332的博客
08-30 1320
智能决策接口级还是应用级地址，双订阅 （先查询接口级 在查询应用级）接口级注册与应用级注册并存（/dubbo && /service）在上一节中有说到 服务启动流程 中会执行到不同版本的。只消费接口级地址，如无地址则报错，单订阅2.x地址。只消费应用级地址，如无地址则报错，单订阅3.x地址。获取URL， 我们具体看下 该方法调用。只应用级注册（/service）只接口级注册（/dubbo）方法， 在方法内部调用。...
dubbo 知识总结 dubbo配置参考
热门推荐
一言不合吃吃吃的博客
11-03 5万+
dubbo官方文档项目的规模越来越大，总得解耦，不能在一个项目里，这时候，公司采用了dubbo作为分布式应用，将多项业务拆分，并做了库存服务统一、价格服务统一等等一些特殊需要统一性的服务。作为dubbo我也接触了快一年的时间，总会有一些自己的对dubbo的想法。下面是对dubbo的说明：节点角色说明： Provider: 暴露服务的服务提供方。 Consumer: 调用远程服务的服务

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值