Dubbo快速入门（附案例）

悠哉iky

已于 2022-10-15 21:59:41 修改

阅读量2.3k

点赞数 5

分类专栏： Dubbo 文章标签：中间件后端

于 2022-10-15 17:16:13 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43162044/article/details/127330280

版权

Dubbo 专栏收录该内容

1 篇文章

订阅专栏

目录文末附云盘资料下载链接

一、Dubbo介绍

Dubbo是阿里巴巴公司开源的一个高性能、轻量级的 Java RPC 框架。

致力于提供高性能和透明化的 RPC 远程服务调用方案，以及 SOA 服务治理方案。

官网：http://dubbo.apache.org

目前Dubbo在企业中有两种开发思路

基于SOA思想

将传统单一应用拆分为web（消费者）模块和service（提供者）模块，基于Dubbo通信

辅助SpringCloud架构提升效率

Dubbo基于TCP（传输层）协议，效率更高。可以替换Feign(应用层)，提升高并发压力

二、Dubbo基本架构

远程调用面临以下问题：

服务消费者该如何获取服务提供者的地址信息？

当服务提供者发生变化时如何进行快速切换？

提供者和消费者如何监控？

服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者在启动时，向注册中心订阅自己所需的服务。

注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

服务消费者，从提供者地址列表中，基于负载均衡算法，选择提供者进行调用。

服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

三、Dubbo环境准备

1、搭建注册中心

下载地址：Releases · alibaba/nacos · GitHuban easy-to-use dynamic service discovery, configuration and service management platform for building cloud native applications. - Releases · alibaba/nacoshttps://github.com/alibaba/nacos/releases

1、将其解压到没有中文的目录

2、进入bin文件夹

3、右键打开控制台，运行命令.\startup.cmd -m standalone（不要直接点击bat，会报错）

4、网页访问地址http://127.0.0.1:8848/nacos，账号密码默认nacos

2、搭建监控中心Dubbo-Admin

DubboAdmin是阿里巴巴管理提供的管理控制台，可以实现服务查询，详情展示,服务测试等功能。借由DubboAdmin可以更好的帮助开发人员对服务进行管理和监控。

下载地址:Releases · apache/dubbo-admin · GitHubThe ops and reference implementation for Apache Dubbo - Releases · apache/dubbo-adminhttps://github.com/apache/dubbo-admin/releases/（记住，是下载代码）

  1、下载代码:
           git clone https://github.com/apache/dubbo-admin.git
        2、在 dubbo-admin-server/src/main/resources/application.properties中指定注册中心地址
        3、构建
        4、启动mvn clean package -Dmaven.test.skip=true
       mvn --projects dubbo-admin-server spring-boot:run
       或者
       cd dubbo-admin-distribution/target; java -jar dubbo-admin-0.1.jar
5、访问 http://localhost:8080

四、Dubbo入门案例

案例如下

1、前期测试

User

@Data
public class User implements Serializable {
    private Long id;
    private String username;
    private String address;
}

UserController

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 路径： /user/110
     * @param id 用户id
     * @return 用户
     */
    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }
}

UserMapper

public interface UserMapper {
    
    @Select("select * from tb_user where id = #{id}")
    User findById(@Param("id") Long id);
}

UserService

public interface UserService {

    User queryById(Long id);
}

UserServiceImpl

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id) {
        return userMapper.findById(id);
    }
}

application.yml

server:
  port: 8088
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dubbo-demo?useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

数据库语句dubbo-demo

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tb_order
-- ----------------------------
DROP TABLE IF EXISTS `tb_order`;
CREATE TABLE `tb_order`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '订单id',
  `userId` bigint(20) NOT NULL COMMENT '用户id',
  `name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '商品名称',
  `price` bigint(20) NOT NULL COMMENT '商品价格',
  `num` int(10) NULL DEFAULT 0 COMMENT '商品数量',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`name`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 109 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = COMPACT;

-- ----------------------------
-- Records of tb_order
-- ----------------------------
INSERT INTO `tb_order` VALUES (101, 1, '苹果12 ', 699900, 1);
INSERT INTO `tb_order` VALUES (102, 2, '新国标电动车', 209900, 1);
INSERT INTO `tb_order` VALUES (103, 3, '休闲运动鞋女', 43900, 1);
INSERT INTO `tb_order` VALUES (104, 4, '双模5G', 359900, 1);
INSERT INTO `tb_order` VALUES (105, 5, 'Reno3 Pro 双模5G 视频双防抖', 299900, 1);
INSERT INTO `tb_order` VALUES (106, 6, '新能效 冷静星II ', 544900, 1);
INSERT INTO `tb_order` VALUES (107, 2, '体工学电脑椅子', 79900, 1);
INSERT INTO `tb_order` VALUES (108, 3, '休闲男鞋', 31900, 1);

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '收件人',
  `address` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`username`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = COMPACT;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES (1, '劳定位', '湖南省衡阳市');
INSERT INTO `tb_user` VALUES (2, '文二狗', '陕西省西安市');
INSERT INTO `tb_user` VALUES (3, '华沉鱼', '湖北省十堰市');
INSERT INTO `tb_user` VALUES (4, '张必沉', '天津市');
INSERT INTO `tb_user` VALUES (5, '郑的爽', '辽宁省沈阳市大东区');
INSERT INTO `tb_user` VALUES (6, '范的兵', '山东省青岛市');

SET FOREIGN_KEY_CHECKS = 1;

启动UserServiceApplication，访问其接口，看是否能查出信息

2、服务拆分——提供者

1、创建提供者模块并引入依赖

创建模块user-provider

引入依赖

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>

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

    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <version>2.7.8</version>
    </dependency>
</dependencies>

2、将service，mapper，domain导入到提供者模块中

将user-service的service，mapper，domain复制到user-provider

启动类：

@MapperScan("cn.test.user.mapper")
@SpringBootApplication
public class UserProviderApplication {

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

}

3、将UserSerivice暴露为dubbo服务

也就是将@Service注解改为@DubboService

4、application.yml配置

server:
  port: 18081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dubbo-demo?useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: user-provider
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: HH:mm:ss:SSS
#配置dubbo提供者
#dubbo协议和访问端口
dubbo:
  protocol:
    name: dubbo
    port: 20881
#注册中心的地址
  registry:
    address: nacos://127.0.0.1:8848
#dubbo注解的包扫描
  scan:
    base-packages: cn.test.user.service

5、启动，在dubbo-admin中心可以查询到服务

细节：tomcat是运行在18080，为什么dubbo还有设置一个20881端口，dubbo框架内部会帮我们创建一个netty服务器，他的作用是网络编程，所以我们暴露的服务最终借助netty服务器对外提供接口，最终消费者调用的不是tomcat端口，而是netty服务器端口。netty你可以理解为socket，dubbo内部是相当于开一个netty服务器，而消费者作为一个客户端来访问他，tomcat理解为netty的容器。

3、服务拆分——消费者

1、创建提供者模块并引入依赖

创建模块user-consumer

依赖

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--dubbo的起步依赖-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-nacos</artifactId>
            <version>2.7.8</version>
        </dependency>
    </dependencies>

2、将controller，service接口导入到提供者模块中

将user-service的controller，service（只引接口，不引实现类），domin接口复制到user-consumer

启动类

@SpringBootApplication
public class UserConsumerApplication {

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

3、在Controller中引入dubbo服务

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @DubboReference
    private UserService userService;

    /**
     * 路径： /user/110
     * @param id 用户id
     * @return 用户
     */
    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }
}

4、application.yml配置

server:
  port: 18080
spring:
  application:
    name: user-consumer
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: HH:mm:ss:SSS
dubbo:
  registry:
    address: nacos://127.0.0.1:8848

4、dubbo最佳实践

1、创建模块user-api

2、将user-service的service（只引接口，不引实现类），domin接口复制到user-api

3、删除user-provider和user-consumer的domin，以及service的接口

4、ser-provider和user-consumer引入依赖

        <dependency>
            <groupId>cn.test</groupId>
            <artifactId>user-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

5、测试

启动消费者和生产者

访问接口

6、细节问题

有些小伙伴没注意，实体类会忘记实现Serializable接口，从而导致访问出现以下情况

java.lang.IllegalStateException: Serialized class cn.itcast.user.domain.User must implement java.io.Serializable

这涉及到序列化的知识

五、Dubbo高级特性

1、启动检查

为了保障服务的正常可用，Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userController': Injection of @DubboReference dependencies is failed;

在正式环境这是很有必要的一项配置，可以保证整个调用链路的平稳运行

在开发时，往往会存在没有提供者的情况。由于启动检查的原因，可能导致开发测试出现问题

可以通过配置文件 check=false 关闭

2、多版本支持

在正式系统中，为了保证系统可用性和更好的并发性，往往通过集群部署。

问：如果提供者代码出现重大更新。如何对提供者升级部署呢？

答：Dubbo提供了提供者多版本的支持，平滑处理项目功能升级部署

灰度发布：当出现新功能时，会让一部分用户先使用新功能，用户反馈没问题时，再将所有用户迁移到新功能。

多版本代码示例：

1、编写新的UserServce实现类，作为新版本代码

2、在暴露服务时，指定服务版本

@DubboService(version = “2.0.0”)
public class UserServiceImpl2 implements UserService {
…………..
}

3、消费者引用服务时，指定引用的服务版本

@RestController
@RequestMapping("/user")
public class UserController {
    //引用远程服务
    @DubboReference(version = "2.0.0")
    private UserService userService;
    ………..
}

3、超时与重试

服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。

Dubbo 利用超时机制来解决这个问题

若超时时间较短，当网络波动时请求就会失败，Dubbo通过重试机制避免此类问题的发生

4、负载均衡

在集群部署时，Dubbo提供了4种负载均衡策略，帮助消费者找到最优提供者并调用

Random ：按权重随机，默认值。按权重设置随机概率。（内部将全部权重相加，1号机器占区间0-2，2号2-5，3号5-10，随机将以权重和为基数随机，看落在哪个数字区间）

RoundRobin ：按权重轮询

LeastActive：最少活跃调用数，相同活跃数的随机。

ConsistentHash：一致性 Hash，相同参数的请求总是发到同一提供者。

六、SpringCloud整合Dubbo

1、为什么需要Dubbo

Feign基于Http协议（应用层），在高并发场景下性能不够理想，容易成为性能瓶颈

Dubbo框架的通信协议采用TCP协议（数据传输层）

Dubbo默认通过Netty构造TCP长连接的方式进行通信，性能较高

使用SpringCloud整合Dubbo，即为强强联合。

2、整合操作

这边依旧提供了一个工程，结构如下

我们先把项目运行起来

需求：根据订单id查询订单的同时，把订单所属的用户信息一起返回

1、抽取接口模块

引入实体类模块依赖，抽取接口

public interface UserService {
    User queryById(Long id);
}

2、改造服务提供者

2.1引入依赖

<!--nacos注册中心的依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

<!--springcloud alibaba dubbo依赖   -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>

<dependency>
    <groupId>cn.itcast</groupId>
    <artifactId>dubbo-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

2.2编写实现类，暴露服务

//暴露服务
@DubboService
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id) {
        return userMapper.findById(id);
    }
}

2.3 配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dubbo-demo?useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
#配置dubbo，注册中心，暴露的端口和协议，dubbo注解的包扫描
dubbo:
  protocol:
    name: dubbo
    port: 20881
  registry:
    address: spring-cloud://localhost   #使用SpringCloud中的注册中心
  scan:
    base-packages: cn.test.user.service  #dubbo中包扫描

3、改造消费者

3.1引入Dubbo起步依赖（同上）

3.2使用@DubboReference引入Dubbo服务，调用远程服务

@RestController
@RequestMapping("order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @DubboReference
    private UserService userService;

    @GetMapping("{orderId}")
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
        //根据id查询订单
        Order order = orderService.queryOrderById(orderId);
        //获取用户id
        Long userId = order.getUserId();
        //查询用户
        User user = userService.queryById(userId);
        //设置用户对象
        order.setUser(user);
        // 根据id查询订单并返回
        return order;
    }
}

3.3 配置文件

spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
#dubbo配置
dubbo:
  registry:
    address: spring-cloud://localhost  #使用cloud的注册中心
  consumer:
    check: false   #dubbo默认有启动检查
    retries: 0     #dubbo内置的重试机制

启动服务user信息查询出来了

注册中心也有信息