Dubbo使用指南

 
以根据用户id查询用户订单为例，user-service调用order-service，user-service是服务消费者，order-service是服务提供者。
 

公共接口

新建子模块api，存放微服务公用的实体类、服务提供者提供的服务接口。

只写实体类和接口，使用普通maven项目即可。
 

1、添加lombok的依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

 

2、每个服务都新建一个包，包下新建子包model、interface分别存放本服务提供的公用实体类、服务接口，实体类要可序列化

order-service.model

@Getter
@Setter
public class Order implements Serializable {
    private Long id;
    private Date createTime;
    private Integer userId;
    private List<OrderItem> orderItemList;
}

@Getter
@Setter
public class OrderItem implements Serializable {
    private Long id;
    private Integer goodsId;
    private Decimal price;  //商品价格可能变动，需要记录购买时的价格
    private Integer number;
    private Long orderId;  //所属order
}

 
order-service.interface

public interface OrderService {
    List<Order> findOrdersByUserId(Integer userId);
    //......
}

之所以把公用实体类和接口写在一个模块中，是因为接口中的参数、返回值类型往往要用到实体类。

 

3、maven打包为jar安装到maven仓库

自己开发可以安装到本地仓库，公司开发要安装到公司私服。

 

服务提供者

新建springboot项目order-service
 

1、添加依赖

<!-- api模块的jar包 -->
<dependency>
    <groupId>com.chy.mall</groupId>
    <artifactId>api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

<!-- dubbo的依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.6</version>
</dependency>

<!-- zk的依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-dependencies-zookeeper</artifactId>
    <version>2.7.6</version>
    <type>pom</type>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

zk的依赖要用去掉slf4j部分，因为spring-boot-strat已经包含了slf4j，如果不去掉会报错：slf4j绑定了多个jar包中的Logger

 

2、新建包service，实现服务接口

// 此处的@Service是dubbo的注解，不是spring的注解，不到导错了
@Service
public class OrderServiceImpl implements OrderService {

	//.....
	
    @Override
    public List<Order> findOrdersByUserId(Integer userId) {
        
    }

	//.....
	
}

 

3、application.properties

spring.application.name=order-service
#如果指定了spring应用名称，可以缺省dubbo的应用名称，这2个至少要配置1个。缺省dubbo的应用名称时默认为spring的应用名称
#dubbo.application.name=order-service


#注册中心地址，如果是zk集群，值逗号分隔即可
dubbo.registry.address=zookeeper://192.168.1.9:2181

#也可以分开写
#dubbo.registry.protocol=zookeeper   
#如果是集群，逗号分隔
#dubbo.registry.address=192.168.1.9:2181,192.168.1.10:2181   


#指定rpc远程调用使用的协议、端口
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880


#指定注册到zk server上的超时时间，ms。registry是消费者、提供者通用的
dubbo.registry.timeout=10000

#也可以用专用的。provider是提供者专用的，consumer是消费者专用的
#dubbo.provider.timeout=10000

#连接到注册中心进行注册很耗时，设置的超时时间要大一些，如果时间不够就超时取消了，可能会报错：zookeeper not connected


#指定实现服务接口的包
dubbo.scan.base-packages=com.chy.order-service.service

#也可以在引导类上用注解指定包的位置
# @DubboComponentScan(basePackages = "com.chy.order-service.service")
# @EnableDubbo  //也可以用这个注解，会扫描所有的包，从中找出dubbo的@Service标注的类

 

服务消费者

新建springboot项目user-service
 

1、添加依赖

<!-- api模块的jar包 -->
<dependency>
    <groupId>com.chy.mall</groupId>
    <artifactId>api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

<!-- dubbo的依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.6</version>
</dependency>

<!-- zk的依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-dependencies-zookeeper</artifactId>
    <version>2.7.6</version>
    <type>pom</type>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

 

2、新建包service

public interface UserService {
    //.....

    List<Order> findOrdersByUserId(Integer id);

    //.....
}

@Service  //此处是spring的注解
public class UserServiceImple implements UserService {
    @Reference  //注入要调用的远程服务接口
    private OrderService orderService;
    
    //.....

    @Override
    public List<Order> findOrdersByUserId(Integer id) {
        return userService.findOrdersByUserId(id);  //rpc远程调用
    }

    //.....
}

 

3、application.properties

spring.application.name=user-service
#dubbo.application.name=user-service


#注册中心地址，如果是zk集群，值逗号分隔即可
dubbo.registry.address=zookeeper://192.168.1.9:2181

#也可以分开写
#dubbo.registry.protocol=zookeeper   
#如果是集群，逗号分隔
#dubbo.registry.address=192.168.1.9:2181,192.168.1.10:2181   


#rpc远程调用使用的协议、端口
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880


#注册到zk server上的超时时间，ms
dubbo.registry.timeout=10000
#dubbo.consumer.timeout=10000


#启动应用时是否检查注册中心上有没有需要调用的服务，默认true
#dubbo.consumer.check=true

dubbo.consumer.check设置为true，启动消费者时会检查注册中心有没有要调用的服务，如果没有则消费者启动不了，报错：创建不了xxx bean，因为 Injection of @Reference dependencies is failed ，没有提供者提供要调用的服务。

设置为true可以提前发现提供者未启动的问题，但启动应用时要先启动提供者，再启动消费者。

设置为false，消费者启动时不检查注册中心有没有要调用的服务，不管有没有需要的提供者，消费者都能正常启动，只是如果没有需要的提供者，调用服务时会出错。

 

zk server上，dubbo的根目录是/dubbo，一个服务接口对应一个znode，包名.服务接口名 的形式，eg. /dubbo/order-service.UserService。

子节点providers存储此服务接口所有的提供者的信息，子节点consumers存储此服务接口所有的消费者的信息。

提供者实现服务接口，并使用dubbo的@Service注解标识该类是服务提供者，提供的服务就是实现的接口；消费者使用@Reference来引用服务接口，标识该类是服务消费者。
 

很多时候，一个模块既是提供者、又是消费者。

 

可视化监控 dubbo admin

dubbo admin是dubbo的网页版控制台，可管理服务，由springboot+vue编写，前后端分离。
 
1、git clone，或者下载压缩包再解压

https://github.com/apache/dubbo-admin

 

2、修改dubbo-admin-server的springboot配置文件

修改注册中心、配置中心、元数据中心的配置，我们使用zk同时作为这3个中心，值都是一样的。

设置dobbo admin的用户名、密码。

dubbo admin是springboot项目，默认使用8080，可以在application.properties中修改为其它端口。

 

3、命令行打包、运行

#cd到项目根目录
cd C:\Users\chy\Desktop\dubbo-admin-develop

#清理并打包。命令行执行maven命令需要先配置maven的环境变量
mvn clean package

#maven方式运行
mvn --projects dubbo-admin-server spring-boot:run

#也可以先cd到打包好的jar所在目录，执行jar
cd dubbo-admin-distribution/target
java -jar dubbo-admin-0.1.jar

访问 127.0.0.1:8080 即可进入dubbo admin控制台。ip、port是运行dubbo admin的机器ip、项目使用的端口。

 

使用zk作为配置中心

使用zk作为配置管理中心，统一管理各个服务的配置。

dubbo admin控制台 -> 配置管理 -> 创建
 

1、全局配置名称使用global，对所有的服务提供者、消费者均有效，写公共配置

#注册中心地址，如果是zk集群，值逗号分隔即可
dubbo.registry.address=zookeeper://192.168.1.9:2181

#也可以分开写
#dubbo.registry.protocol=zookeeper   
#如果是集群，逗号分隔
#dubbo.registry.address=192.168.1.9:2181,192.168.1.10:2181   


#rpc远程调用使用的协议、端口
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880


#注册到zk server上的超时时间，ms
dubbo.registry.timeout=10000

 

2、再写各个服务模块独有的配置（应用级配置），配置名称使用服务模块名

order-service

spring.application.name=order-service
#dubbo.application.name=order-service

#指定实现服务接口的包
dubbo.scan.base-packages=com.chy.order-service.service

 
user-service

spring.application.name=user-service
#dubbo.application.name=user-service

#启动应用时是否检查注册中心上有没有需要调用的服务，默认true
#dubbo.consumer.check=true

如果全局配置、应用配置中有冲突的配置项，以应用配置为准。

修改配置后，需要重启对应的应用、重新获取配置，才会生效。

 

3、使用配置中心后，提供者、消费者在applciation.properties中只写配置中心的配置

#配置中心地址，同样可以分开写，集群逗号分隔
dubbo.config-center.address=zookeeper://192.168.1.9:2181

#连接到配置中心的超时时间，ms
dubbo.config-center.timeout=10000

应用启动时，会自动连接到配置中心，从配置中心获取配置。

配置存储在 zk server的/dubbo/config 中，其中全局配置保存在/dubbo/config/dubbo/dubbo.properties 中。

 

使用zk作为元数据中心

元数据中心用于存储服务提供者、消费者的信息，比如服务接口的信息（方法名、形参表、返回值类型）。

元数据中心主要用于测试服务接口，配置元数据中心以后，可以在dubbo admin中测试服务接口。
 

1、在消费者、提供者中t添加zk作为元数据中心的依赖

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-metadata-report-zookeeper</artifactId>
    <version>2.7.6</version>
    <scope>test</scope>
</dependency>

看到作用域是test就知道这玩意儿是测试用的
 

2、在dubbo admin的全局配置中加入元数据中心的配置

#元数据中心地址，同样可以分开写，集群逗号分隔
dubbo.metadata-report.address=zookeeper://192.168.1.9:2181

#连接到元数据中心的超时时间
dubbo.metadata-report.timeout=10000

 

理论

1、dubbo的架构

http://dubbo.apache.org/zh-cn/docs/user/preface/architecture.html

 

2、dubbo配置加载流程

http://dubbo.apache.org/zh-cn/docs/user/configuration/configuration-load-process.html

 

3、dubbo的rpc协议

http://dubbo.apache.org/zh-cn/docs/user/references/protocol/introduction.html

最常用的是dubbo协议

 

4、系统容错

http://dubbo.apache.org/zh-cn/docs/user/demos/fault-tolerent-strategy.html

rpc远程调用服务时，如果调用失败，默认会重试2次，总共3次

 

5、升级系统时dubbo的服务接口不兼容怎么办？

使用版本号。dubbo的@Service、@Reference都可以指定version属性，@Service指定提供的是该服务接口哪个版本的实现，@Reference指定调用该服务接口的哪个版本，提供者、消费者使用版本号来对接。

 

6、相比于springcloud，dubbo的特点是简单、高性能

高性能是由于使用rpc调用服务，协议很关键，dubbo底层使用netty实现网络通信，NIO异步方式提升性能、支持更高的并发。

 

7、dubbo特性

• 启动检查
• 负载均衡
• 分组聚合
• 版本控制
• 多协议支持