目录

Life in Flow

知不知，尚矣；不知知，病矣。
不知不知，殆矣。

X

Dubbo

   
    0 0 410686931

Dubbo 项目分层

项目分层

传送门

Duboo 开发环境的搭建

创建项目

# 创建dubbo项目并删除src目录

# 右键dubbo项目，创建user-api子项目

# 右键dubbo项目，创建user-service子项目

# 右键dubbo项目，创建user-web子项目

parent 父项目限定版本

<build>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

添加 Maven 依赖：user-service、user-web

<!-- spring-boot-starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- Dubbo Spring Boot Starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>
	<!-- spring-boot-starter-web   user-web项目 需要引入此依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

user-api 项目
 假设存在一个 Dubbo RPC API ，由服务提供方为服务消费方暴露接口

public interface UserService {
    String sayHello();
}

user-service 项目
 实现 UserService 接口

import org.apache.dubbo.config.annotation.Service;

@Service(version = "1.0.0")
public class UserServiceImpl implements UserService {
    public String sayHello() {
        return "hello";
    }
}

 修改 SpringBoot 启动类添（加注解@EnableAutoConfiguration）

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

public class ServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class);
    }
}

 添加配置文件 application.yml

spring:
  application:
    name: dubbo-auto-configuration-provider-demo

dubbo:
  scan:
    base-packages: com.soulboy.user.service.impl
  protocol:
    name: dubbo
    port: 12345
  registry:
    address: N/A

user-web 项目
 创建 Controller 层

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Reference(version = "1.0.0", url = "dubbo://127.0.0.1:12345")
    private UserService userService;

    @RequestMapping("/sayHello")
    public String sayHello() {
        return userService.sayHello();
    }
}

 添加启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebApplication.class);
    }
}

 添加配置文件 application.yml

spring:
  application:
    name: dubbo-auto-configure-consumer-sample

 测试

http://localhost:8080/sayHello
hello

Dubbo 架构流程

  • Provider：暴露服务的服务提供方。
  • Consumer：调用远程服务的服务消费方。
  • Registry：服务注册与发现的注册中心。
  • Monitor：统计服务的调用次数和调用时间的监控中心。
  • Container：服务运行容器。

Dubbo架构流程

  1. 服务容器负责启动，加载，运行服务提供者。
  2. 服务提供者在启动时，向注册中心注册自己提供的服务。
  3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
  4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
  5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

Dubbo 常见开发方式

  • XML 配置
  • 注解配置（2018 年开始支持）

常见注册中心

  • simple 注册中心 ----不支持集群，不适用于生产环境
  • Multicast 注册中心 ----开发阶段使用
  • zookeeper 注册中心 ----目前企业中最常用，也是官方推荐
  • Redis 注册中心 ----虽然支持，但是较少使用
  • acos 注册中心 ----后起之秀，传送门。

Zookeeper 整合 Dubbo（注解）

zookeeper数据模型

Provider：user-service 项目
 添加依赖

<!-- Zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
        </dependency>

 修改配置文件

spring:
  application:
    name: dubbo-auto-configuration-provider-demo

dubbo:
  scan:
    base-packages: com.soulboy.user.service.impl
  protocol:
    name: dubbo
    port: 12345
  registry:
    address: zookeeper://192.168.31.220:2181

 启动服务

2019-07-25 13:57:05.937  INFO 9492 --- [           main] o.a.c.f.imps.CuratorFrameworkImpl        : Default schema
2019-07-25 13:57:10.450  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Opening socket connection to server 192.168.31.220/192.168.31.220:2181. Will not attempt to authenticate using SASL (unknown error)
2019-07-25 13:57:10.453  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Socket connection established to 192.168.31.220/192.168.31.220:2181, initiating session
2019-07-25 13:57:10.466  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Session establishment complete on server 192.168.31.220/192.168.31.220:2181, sessionid = 0x10014aa999f0014, negotiated timeout = 40000
2019-07-25 13:57:10.475  INFO 9492 --- [ain-EventThread] o.a.c.f.state.ConnectionStateManager     : State change: CONNECTED
2019-07-25 13:57:11.805  INFO 9492 --- [           main] o.a.c.f.imps.CuratorFrameworkImpl        : Starting
2019-07-25 13:57:11.805  INFO 9492 --- [           main] org.apache.zookeeper.ZooKeeper           : Initiating client connection, connectString=192.168.31.220:2181 sessionTimeout=60000 watcher=org.apache.curator.ConnectionState@4f8caaf3
2019-07-25 13:57:11.806  INFO 9492 --- [           main] o.a.c.f.imps.CuratorFrameworkImpl        : Default schema
2019-07-25 13:57:16.318  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Opening socket connection to server 192.168.31.220/192.168.31.220:2181. Will not attempt to authenticate using SASL (unknown error)
2019-07-25 13:57:16.319  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Socket connection established to 192.168.31.220/192.168.31.220:2181, initiating session
2019-07-25 13:57:16.331  INFO 9492 --- [68.31.220:2181)] org.apache.zookeeper.ClientCnxn          : Session establishment complete on server 192.168.31.220/192.168.31.220:2181, sessionid = 0x10014aa999f0015, negotiated timeout = 40000
2019-07-25 13:57:16.331  INFO 9492 --- [ain-EventThread] o.a.c.f.state.ConnectionStateManager     : State change: CONNECTED
2019-07-25 13:57:16.400  INFO 9492 --- [           main] c.x.user.service.ServiceApplication      : Started ServiceApplication in 20.668 seconds (JVM running for 21.827)
2019-07-25 13:57:16.404  INFO 9492 --- [pool-1-thread-1] .b.c.e.AwaitingNonWebApplicationListener :  [Dubbo] Current Spring Boot Application is await...

Consumer：user-web 项目
 添加依赖

<!-- Zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
        </dependency>

 修改配置文件

spring:
  application:
    name: dubbo-auto-configure-consumer-sample

dubbo:
  registry:
    address: zookeeper://192.168.31.220:2181

 修改 Controller 层代码

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Reference(version = "1.0.0")
    private UserService userService;

    @RequestMapping("/sayHello")
    public String sayHello() {
        return userService.sayHello();
    }
}

测试

http://localhost:8080/sayHello
hello

使用 zkCli 连接 zookeeper：并查看数据模型

[zk: 192.168.31.220:2181(CONNECTED) 0] ls /
[zookeeper, dubbo, soulboy0000000000]
[zk: 192.168.31.220:2181(CONNECTED) 1] ls /dubbo
[com.soulboy.user.service.UserService]
[zk: 192.168.31.220:2181(CONNECTED) 10] ls /dubbo/com.soulboy.user.service.UserService

Node does not exist: /dubbo/com.soulboy.user.service.UserService
[zk: 192.168.31.220:2181(CONNECTED) 11] ls /dubbo
[com.xdclass.user.service.UserService]
[zk: 192.168.31.220:2181(CONNECTED) 12] ls /dubbo/com.soulboy.user.service.UserService
[consumers, configurators, routers, providers]
[zk: 192.168.31.220:2181(CONNECTED) 13] ls /dubbo/com.soulboy.user.service.UserService/consumers
[consumer://169.254.192.38/com.xdclass.user.service.UserService?application=dubbo-auto-configure-consumer-sample&category=consumers&check=false&dubbo=2.0.2&interface=com.xdclass.user.service.UserService&methods=sayHello&pid=10400&qos.enable=false&release=2.7.0&revision=1.0.0&side=consumer&timestamp=1564035312365&version=1.0.0]

Zookeeper 整合 Dubbo（XML）

Provider：user-service 项目
 修改配置文件 properties.yml

spring:
  application:
    name: dubbo-auto-configuration-provider-demo

 新增配置文件 provider.xml

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:protocol name="dubbo" port="12345"/>
    <bean id="userService" class="com.soulboy.user.service.impl.UserServiceImpl"/>
    <dubbo:service interface="com.soulboy.user.service.UserService" ref="userService"/>
</beans>

 修改实现类，去掉@Service 注解

import org.springframework.stereotype.Service;

public class UserServiceImpl implements UserService {
    public String sayHello() {
        return "hello";
    }
}

 修改启动类，添加@ImportResource 注解导入 XML 配置文件

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ImportResource;

@EnableAutoConfiguration
@ImportResource("provider.xml")
public class ServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class);
    }
}

Consumer：user-web 项目
 修改配置文件 properties.yml

spring:
  application:
    name: dubbo-auto-configure-consumer-sample

 新增配置文件 consumer.xml

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:reference id="userService" check="false" interface="com.soulboy.user.service.UserService"/>
</beans>

 修改 Controller 层

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
  
    @Autowired
    private UserService userService;

    @RequestMapping("/sayHello")
    public String sayHello() {
        return userService.sayHello();
    }
}

 修改启动类，添加@ImportResource 注解导入 XML 配置文件

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
@ImportResource("consumer.xml")
public class WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebApplication.class);
    }
}

测试

http://localhost:8080/sayHello
hello

启动依赖检查

 Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题，默认 check="true"。 也就是说 consumer 的启动依赖于 provider。可以通过 check="false" 关闭检查，比如，测试时，有些服务不关心，或者出现了循环依赖，必须有一方先启动。另外，如果你的 Spring 容器是懒加载的，或者通过 API 编程延迟引用服务，请关闭 check，否则服务临时不可用时，会抛出异常，拿到 null 引用，如果 check="false"，总是会返回引用，当服务恢复时，能自动连上。

方式一：

@Reference(version = "1.0.0",check =false)
	private UserService userService;

方式二：（推荐）

dubbo
  registry:
    address: zookeeper://192.168.31.220:2181
  reference:
    com:
	#接口的全限定名
      soulboy:
        user:
          service:
            UserService:
              check: false

各种配置对比

*   dubbo.reference.check=false，强制改变所有 reference 的 check 值，就算配置中有声明，也会被覆盖。
*   dubbo.consumer.check=false，是设置 check 的缺省值，如果配置中有显式的声明，如：<dubbo:reference check="true"/>，不会受影响。
*   dubbo.registry.check=false，前面两个都是指订阅成功，但提供者列表是否为空,是否报错，如果注册订阅失败时，也允许启动，需使用此选项，将在后台定时重试。

配置加载流程

 配置优先级是从上往下一次递减，JVM -D 参数是优先级最高的，本地配置文件 dubbo.properties 是优先级最低的。配置来源如下：

  • VM System Properties，-D 参数
  • Externalized Configuration，外部化配置（2.7 版本）
  • ServiceConfig、ReferenceConfig 等编程接口采集的配置
  • 本地配置文件 dubbo.properties

超时机制与容错机制

 当服务调用失败的时候，默认情况下，dubbo 会进行重试，默认重试次数为 2（不包含第一次），所以一共调用了 3 次。通过 retries="4" 设置重试次数。

<dubbo:reference id="userService" check="false" interface="com.xdclass.user.service.UserService" retries="4"/>

服务提供方配置

  • 方法级别（方法优先级设置高于服务优先级设置）
<dubbo:service interface="com.xdclass.user.service.UserService" ref="userService" timeout="3000">
	<dubbo:method name="sayHello" timeout="6000"></dubbo:method>
    </dubbo:service>
  • 服务级别
<dubbo:service interface="com.xdclass.user.service.UserService" ref="userService" timeout="3000"/>

服务消费方配置
 如果服务提供方跟服务消费方同时设置了超时时间，则以服务消费方为准。

  • 方法级别
  • 服务级别
<dubbo:reference id="userService" check="false" interface="com.xdclass.user.service.UserService" timeout="6000"/>

集群容错模式

  • Failover Cluster：失败自动切换，当出现失败，重试其它服务器通常用于读操作，但重试会带来更长延迟。可通过retries="2" 来设置重试次数(不含第一次)。
  • Failfast Cluster：失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。
  • Failback Cluster：失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。
  • Forking Cluster：并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过forks="2" 来设置最大并行数。
  • Broadcast Cluster：广播调用所有提供者，逐个调用，任意一台报错则报错 。通常用于通知所有提供者更新缓存或日志等本地资源信息。
     按照以下示例在服务提供方和消费方配置集群模式：
<dubbo:service  cluster="failsafe" />
或
<dubbo:reference  cluster="failsafe" />

Dubbo 多协议配置

 缺省协议，使用基于 Mina 1.1.7 和 hessian 3.2.1 的 tbremoting 交互。

  • 连接个数：单连接
  • 连接方式：长连接
  • 传输协议：TCP
  • 传输方式：NIO 异步传输
  • 序列化：Hessian 二进制序列化
  • 适用范围：传入传出参数数据包较小（建议小于 100K），消费者比提供者个数多，单一消费者无法压满提供者，尽量不要用 dubbo 协议传输大文件或超大字符串。
  • 适用场景：常规远程服务方法调用

 多协议配置示例（HTTP）如下：

API：user-api 项目新增接口

public interface FileService {
    void upload(String msg);
}

Provider：user-service 添加实现类

public class FileServiceImpl implements FileService {
    @Override
    public void upload(String msg) {
        System.out.println("服务被调用" + msg);
    }
}

 
修改配置文件

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:protocol name="dubbo" port="12345"/>
    <dubbo:protocol name="http" port="8888"/>
    <bean id="userService" class="com.soulboy.user.service.impl.UserServiceImpl"/>
    <bean id="fileService" class="com.soulboy.user.service.impl.FileServiceImpl"/>
    <dubbo:service interface="com.soulboy.user.service.UserService" ref="userService" timeout="3000"/>
    <dubbo:service interface="com.soulboy.user.service.FileService" ref="fileService" protocol="http"/>
</beans>

 
服务提供者加入相应的依赖

<!-- 多协议配置 http  -->
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-util</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.eclipse.jetty/jetty-server -->
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.eclipse.jetty/jetty-servlet -->
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-servlet</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

 修改启动类

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.ImportResource;

@EnableAutoConfiguration
@ImportResource("provider.xml")
public class ServiceApplication {
    public static void main(String[] args) {
        new SpringApplicationBuilder(ServiceApplication.class).web(WebApplicationType.NONE).run();
    }
}

Consumer：user-web 修改配置文件

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:reference id="userService" check="false" interface="com.soulboy.user.service.UserService"/>
    <dubbo:reference id="fileService" check="false" interface="com.soulboy.user.service.FileService"/>
</beans>

 修改 Controller 层代码

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private FileService fileService;

    @RequestMapping("/sayHello")
    public String sayHello() {
        return userService.sayHello();
    }

    @RequestMapping("/upload")
    public void upload(@RequestParam(value = "msg") String msg){
        fileService.upload(msg);
    }
}

测试

http://localhost:8080/upload?msg=123
user-service控制台输出：
	服务被调用123

Dubbo 多注册中心

 一个 Provider 可以同时想多个注册中心暴露自己的服务。

  • 新增 <dubbo:registry address="zookeeper://192.1.1.101:2181"/>
  • 多个注册中心使用 id 属性进行区分 id="remote".
  • 服务暴露时，多个注册中心使用逗号分隔：registry="local,remote"
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry id="local" address="zookeeper://192.168.31.220:2181"/>
    <dubbo:registry id="remote" address="zookeeper://192.168.31.240:2181"/>
    <dubbo:protocol name="dubbo" port="12345"/>
    <bean id="userService" class="com.soulboy.user.service.impl.UserServiceImpl"/>
    <dubbo:service interface="com.soulboy.user.service.UserService" ref="userService" timeout="3000"/ registry="local,remote">
</beans>

Dubbo 服务分组

 一个 interface 可能会存在多个实现，这样会导致 Consumer 每次都随机消费同一个接口的不同实现类提供的服务。因此需要 Consumer 对调用做出明确的描述，Provider 可以通过服务分组的概念来解决此类问题。
新增实现类

public class UserServiceImpl2 implements UserService {
    @Override
    public String sayHello() {
        return "hello 2";
    }
}

修改 Provider 配置文件

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:protocol name="dubbo" port="12345"/>
    <bean id="userService" class="com.soulboy.user.service.impl.UserServiceImpl"/>
    <dubbo:service group="user1" interface="com.soulboy.user.service.UserService" ref="userService" timeout="3000"/>

    <bean id="userService2" class="com.soulboy.user.service.impl.UserServiceImpl2"/>
    <dubbo:service group="user2" interface="com.soulboy.user.service.UserService" ref="userService2" timeout="3000"/>
</beans>

修改 Consumer 配置文件

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:registry address="zookeeper://192.168.31.220:2181"/>
    <dubbo:reference id="userService" group="user2" interface="com.soulboy.user.service.UserService"/>
</beans>

测试

# 多次刷新依然是消费group="user2" 的接口实现类
http://localhost:8080/sayHello
hello 2

Dubbo 服务多版本化

 当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。

  • 在低压力时间段，先升级一半提供者为新版本 再将所有消费者升级为新版本 然后将剩下的一半提供者升级为新版本。
  • 一旦服务提供者制定了版本，那么所有的服务消费者也是需要去指定相应的版本。
  • 建议：暴露服务的时候，最好都指定下服务的版本，方便后续接口的不兼容升级。
<!-- 老版本服务提供者配置 -->
<dubbo:service  interface="com.foo.BarService"  version="1.0.0" />
<!-- 老版本服务消费者配置 -->
<dubbo:reference  id="barService"  interface="com.foo.BarService"  version="1.0.0" />

<!-- 新版本服务提供者配置 -->
<dubbo:service  interface="com.foo.BarService"  version="2.0.0" />
<!-- 新版本服务消费者配置 -->
<dubbo:reference  id="barService"  interface="com.foo.BarService"  version="2.0.0" />

管控台 Dubbo-ops

 管控台的主要功能：服务查询，服务治理(包括 Dubbo2.7 中新增的治理规则)以及服务测试、配置管理。

# 环境准备
maven npm

# 克隆项目到本地
[root@localhost test]# git clone https://github.com/apache/incubator-dubbo-ops.git

# 修改配置文件：指定注册中心地址（本地就有zookeeper，因此不修改修改）
[root@localhost test]# vim incubator-dubbo-ops/dubbo-admin-server/src/main/resources/application.properties 
admin.registry.address=zookeeper://127.0.0.1:2181
admin.config-center=zookeeper://127.0.0.1:2181
admin.metadata-report.address=zookeeper://127.0.0.1:2181

# 构建
[root@localhost test]# cd /test/incubator-dubbo-ops/
[root@localhost incubator-dubbo-ops]# mvn clean package

# 启动
[root@localhost test]# mvn --projects dubbo-admin-server spring-boot:run
或者
[root@localhost test]# cd dubbo-admin-distribution/target
 [root@localhost dubbo-admin-distribution]# java -jar dubbo-admin-0.1.jar

# 访问
http://192.168.31.220:8080

Dubbo-admin

添置条件安装npm
安装 Dubbo-admin

# 下载
git clone https://github.com/apache/dubbo-admin.git

# 配置
vim dubbo-admin-server/src/main/resources/application.properties
server.port=7001
admin.registry.address=zookeeper://127.0.0.1:2181
admin.config-center=zookeeper://127.0.0.1:2181
admin.metadata-report.address=zookeeper://127.0.0.1:2181

# build
mvn clean package

# 启动
cd dubbo-admin-distribution/target 
nohup java -jar dubbo-admin-0.1.jar &

# 访问
http://192.168.31.251:7001
作者：Soulboy