1、Dubbo的前世今生

2011年10月27日，阿里巴巴开源了自己的SOA服务化治理方案的核心框架Dubbo，2018年才在国内火起来，服务治理和SOA的设计理念开始逐渐在国内软件行业中落地，并被广泛应用。

  • 早期版本的dubbo遵循SOA(分布式、面向服务)的思想，是面向服务架构的重要组件。
  • 如今版本的Dubbo作为Spring Cloud的二进制通信方案来发挥Dubbo的性能优势

2、Dubbo的快速入门

2.1、Dubbo的基本架构

image.png
节点角色说明：

节点 角色说明
Provider 暴露服务的服务提供方。
Consumer 调用远程服务的服务消费方。
Registry 服务注册与发现的注册中心。
Monitor 统计服务的调用次数和调用时间的监控中心。

调用关系说明：

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

2.2、Nacos

Nacos是阿里巴巴的产品，是一个集服务发现，配置管理的平台，在国内受欢迎程度较高。
image.png
1、找到今日资料中的nacos安装包
image.png
2、解压到没有中文和特殊字符的目录
3、进入bin目录，执行启动命令

  1. #进入bin目录
  2. cd bin
  3. #启动
  4. startup.cmd -m standalone

4、浏览器查看：http://127.0.0.1:8848/nacos

2.3、管理后台

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

  1. #1、下载代码: 
  2. 在今日资料中找到dubbo-admin.zip压缩包，然后解压。
  4. #2、在 dubbo-admin-server/src/main/resources/application.properties中指定注册中心地址
  5. admin.registry.address=zookeeper://127.0.0.1:2181
  6. admin.config-center=zookeeper://127.0.0.1:2181
  7. admin.metadata-report.address=zookeeper://127.0.0.1:2181
  8. 修改为
  9. server.port=端口号（默认是8080）  
  10. admin.registry.address=nacos://127.0.0.1:8848
  11. admin.config-center=nacos://127.0.0.1:8848
  12. admin.metadata-report.address=nacos://127.0.0.1:8848
  14. cd  dubbo-admin目录
  16. #3、构建
  17. mvn clean package -Dmaven.test.skip=true
  18. #4、启动
  19. cd dubbo-admin-distribution/target; 
  21. java -jar dubbo-admin-0.3.0-SNAPSHOT.jar
  22. #5、访问 http://localhost:你配置的端口号

注意： dubbo-admin没法监听spring-cloud整合dubbo的服务

2.4、入门案例

需求：基于素材的对现有项目进行拆分，拆分为服务的提供者与消费者

image.png

2.4.1 环境准备

  1. 今日资料中已经准备了Dubbo学习的案例工程，导入IDEA

image.png

  1. 导入sql语句 ``sql CREATE TABLEtb_user(idbigint(20) NOT NULL AUTO_INCREMENT,usernamevarchar(100) DEFAULT NULL COMMENT '收件人',addressvarchar(255) DEFAULT NULL COMMENT '地址', PRIMARY KEY (id) USING BTREE, UNIQUE KEYusername(username`) USING BTREE ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;

/Data for the table tb_user /

insert into tb_user(id,username,address) values (1,’柳岩’,’湖南省衡阳市’),(2,’文二狗’,’陕西省西安市’),(3,’华沉鱼’,’湖北省十堰市’),(4,’张必沉’,’天津市’),(5,’郑爽爽’,’辽宁省沈阳市大东区’),(6,’范兵兵’,’山东省青岛市’);

  3. 3.  启动项目，使用浏览器访问 
  4. 3.  ![image.png](https://cdn.nlark.com/yuque/0/2022/png/26006407/1650465134760-68cf491b-9cd1-4769-b269-0b3bbf0f2b76.png#clientId=ua8884cfd-bbf7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=141&id=u522f7057&name=image.png&originHeight=141&originWidth=623&originalType=binary&ratio=1&rotation=0&showTitle=false&size=26004&status=done&style=none&taskId=ubb99a358-c58b-4710-a567-e378744380f&title=&width=623)
  6. 注意：dubbo拆分服务的提供者与消费者的原则：dao与service作为服务的提供者，controller作为消费者
  8. <a name="caa15a2b"></a>
  9. #### 2.4.1、服务提供者
  10. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/26006407/1650465152155-1cae197e-527d-415b-922a-7fd1aaf51b35.png#clientId=ua8884cfd-bbf7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=404&id=u16ad5f14&name=image.png&originHeight=404&originWidth=614&originalType=binary&ratio=1&rotation=0&showTitle=false&size=37912&status=done&style=none&taskId=u06f261ab-51ac-4e13-ad53-4c345456540&title=&width=614)
  11. <a name="3b3524ad"></a>
  12. ##### 搭建环境
  14. （1）创建user-provider模块导入依赖
  16. ```xml
  17.  <parent>
  18.         <groupId>org.springframework.boot</groupId>
  19.         <artifactId>spring-boot-starter-parent</artifactId>
  20.         <version>2.3.9.RELEASE</version>
  21.         <relativePath/>
  22.     </parent>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.projectlombok</groupId>
  27.             <artifactId>lombok</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-web</artifactId>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>mysql</groupId>
  35.             <artifactId>mysql-connector-java</artifactId>
  36.         </dependency>
  37.         <!--mybatis-->
  38.         <dependency>
  39.             <groupId>org.mybatis.spring.boot</groupId>
  40.             <artifactId>mybatis-spring-boot-starter</artifactId>
  41.         </dependency>
  43.         <!--dubbo的起步依赖-->
  44.         <dependency>
  45.             <groupId>org.apache.dubbo</groupId>
  46.             <artifactId>dubbo-spring-boot-starter</artifactId>
  47.             <version>2.7.8</version>
  48.         </dependency>
  50.         <dependency>
  51.             <groupId>org.apache.dubbo</groupId>
  52.             <artifactId>dubbo-registry-nacos</artifactId>
  53.             <version>2.7.8</version>
  54.         </dependency>
  56.         <!-- mysql驱动 -->
  57.         <dependency>
  58.             <groupId>mysql</groupId>
  59.             <artifactId>mysql-connector-java</artifactId>
  60.             <version>5.1.47</version>
  61.         </dependency>
  62.         <!--mybatis-->
  63.         <dependency>
  64.             <groupId>org.mybatis.spring.boot</groupId>
  65.             <artifactId>mybatis-spring-boot-starter</artifactId>
  66.             <version>2.1.1</version>
  67.         </dependency>
  68.     </dependencies>

（2）编写引导类

  1. package com.itheima;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. @MapperScan(basePackages = "com.itheima.mapper")
  8. @SpringBootApplication
  9. public class ProviderApplication {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(ProviderApplication.class, args);
  12.     }
  13. }

代码实现

（1）UserMapper

  1. package com.itheima.mapper;
  4. import com.itheima.domain.User;
  5. import org.apache.ibatis.annotations.Param;
  6. import org.apache.ibatis.annotations.Select;
  8. public interface UserMapper {
  10.     @Select("select * from tb_user where id = #{id}")
  11.     User findById(@Param("id") Long id);
  12. }

(2) UserService

  1. package com.itheima.service;
  4. import com.itheima.domain.User;
  6. public interface UserService {
  8.     User queryById(Long id);
  9. }

(3) UserServiceImpl

  1. package com.itheima.service.impl;
  4. import com.itheima.domain.User;
  5. import com.itheima.mapper.UserMapper;
  6. import com.itheima.service.UserService;
  7. import org.apache.dubbo.config.annotation.DubboService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  11. @DubboService
  12. public class UserServiceImpl implements UserService {
  14.     @Autowired(required = false)
  15.     private UserMapper userMapper;
  17.     public User queryById(Long id) {
  18.         return userMapper.findById(id);
  19.     }
  20. }

配置文件
  1. server:
  2.   port: 18081
  3. spring:
  4.   datasource:
  5.     url: jdbc:mysql://localhost:3306/dubbo-demo?useSSL=false
  6.     username: root
  7.     password: root
  8.     driver-class-name: com.mysql.jdbc.Driver
  9.   application:
  10.     name: dubbo-provider
  11. logging:
  12.   level:
  13.     com.itheima : debug
  14.   pattern:
  15.     dateformat: HH:mm:ss:SSS
  16. dubbo:
  17.   protocol:
  18.     name: dubbo # 指定使用dubbo协议传输数据
  19.     port: 20881  #端口号，默认是20880
  20.   registry: # 注册中心的地址
  21.     address: nacos://localhost:8848
  22.   scan:
  23.     base-packages: com.itheima.service #扫描dubbo服务所在的包

2.4.2、服务消费者

image.png

搭建环境

（1）创建user-consumer模块导入依赖

  1.  <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.3.9.RELEASE</version>
  5.         <relativePath/>
  6.     </parent>
  8.     <dependencies>
  9.         <dependency>
  10.             <groupId>org.projectlombok</groupId>
  11.             <artifactId>lombok</artifactId>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.springframework.boot</groupId>
  15.             <artifactId>spring-boot-starter-web</artifactId>
  16.         </dependency>
  19.         <!--dubbo的起步依赖-->
  20.         <dependency>
  21.             <groupId>org.apache.dubbo</groupId>
  22.             <artifactId>dubbo-spring-boot-starter</artifactId>
  23.             <version>2.7.8</version>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>org.apache.dubbo</groupId>
  28.             <artifactId>dubbo-registry-nacos</artifactId>
  29.             <version>2.7.8</version>
  30.         </dependency>
  31.     </dependencies>

（2）配置引导类

  1. package com.itheima;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class ConsumerApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(ConsumerApplication.class, args);
  10.     }
  11. }

domain实体类

  1. package com.itheima.domain;
  3. import lombok.Data;
  5. import java.io.Serializable;
  7. @Data
  8. public class User implements Serializable {
  9.     private Long id;
  10.     private String username;
  11.     private String address;
  12. }

service服务接口

  1. package com.itheima.service;
  4. import com.itheima.domain.User;
  6. public interface UserService {
  8.     User queryById(Long id);
  9. }

代码实现
  1. package com.itheima.controller;
  3. import com.itheima.domain.User;
  4. import com.itheima.service.UserService;
  5. import org.apache.dubbo.config.annotation.DubboReference;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  12. @RestController
  13. @RequestMapping("/user")
  14. public class UserController {
  16.     @DubboReference
  17.     private UserService userService;
  20.     /**
  21.      * 路径： /user/110
  22.      * @param id 用户id
  23.      * @return 用户
  24.      */
  25.     @GetMapping("/{id}")
  26.     public User queryById(@PathVariable("id") Long id) {
  27.         return userService.queryById(id);
  28.     }
  29. }

配置文件
  1. server:
  2.   port: 18080
  3. spring:
  4.   application:
  5.     name: user-consumer
  6. logging:
  7.   level:
  8.     cn.itcast: debug
  9.   pattern:
  10.     dateformat: HH:mm:ss:SSS
  11. dubbo:
  12.   registry:
  13.     address: nacos://localhost:8848

小结

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/26006407/1650465191105-3e6603d1-873d-49fe-a833-749fbc23d1f2.png#clientId=ua8884cfd-bbf7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=252&id=ue95771d4&name=image.png&originHeight=252&originWidth=607&originalType=binary&ratio=1&rotation=0&showTitle=false&size=24439&status=done&style=none&taskId=uac15521d-e07b-45f3-b608-80f7a3fdfe3&title=&width=607)
  • 提供者需要配置哪些参数？
    • 协议、端口号
    • 注册中地址
    • 服务包扫描
  • 消费者需要配置哪些参数?
    • 注册中心的地址

2.5、代码优化

存在的问题

目前服务的提供者与消费者存在着服务接口\实体类冗余\的情况，为了提高代码的复用性，我们可以单独把服务接口抽离出来独立为一个模块。

步骤：

（1）创建user-api模块引入依赖

image.png

（2）将UserService接口和User对象导入user-api模块下

image.png

（3）user-provider 添加user-api的依赖

  1.     <!--依赖user-api-->
  2.         <dependency>
  3.             <groupId>com.itheima</groupId>
  4.             <artifactId>user-api</artifactId>
  5.             <version>1.0-SNAPSHOT</version>
  6.         </dependency>

（4）user-provider 删除User与UserService

（5）user-consumer 添加user-api的依赖

  1.     <!--依赖user-api-->
  2.         <dependency>
  3.             <groupId>com.itheima</groupId>
  4.             <artifactId>user-api</artifactId>
  5.             <version>1.0-SNAPSHOT</version>
  6.         </dependency>

（6）user-consumer 删除User与UserService

3、Dubbo高级特性

3.2、超时与重试

超时与重试

提供者1秒钟能够处理1000个请求

在一秒钟中有10000个消费者请求你，9000处于等待处理的状态，那么就是对应有9000个线程在等待

image.png

超时与重试

  • 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。
  • 在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。
  • dubbo提供的超时与重试可以解决上面问题

服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。

在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。

  • dubbo 利用超时机制来解决这个问题（使用timeout属性配置超时时间，默认值1000，单位毫秒）
  • 若超时时间较短，当网络波动时请求就会失败，Dubbo通过重试机制避免此类问题的发生

user-consumer模块中添加配置信息

  1. dubbo:
  2.   registry:
  3.     address: nacos://127.0.0.1:8848
  4.   consumer:
  5.     retries: 2 #默认重试2次的
  6.     timeout: 1000  #超时时间为默认1秒

演示

  1. package com.itheima.service.impl;
  4. import com.itheima.domain.User;
  5. import com.itheima.mapper.UserMapper;
  6. import com.itheima.service.UserService;
  7. import org.apache.dubbo.config.annotation.DubboService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  11. @DubboService
  12. public class UserServiceImpl implements UserService {
  14.     @Autowired(required = false)
  15.     private UserMapper userMapper;
  17.     public User queryById(Long id) {
  18.         System.out.println("========userserviceImpl被调用===========");
  19.         try {
  20.             Thread.sleep(2000); //模拟超时
  21.         } catch (InterruptedException e) {
  22.             e.printStackTrace();
  23.         }
  24.         return userMapper.findById(id);
  25.     }
  26. }

结果

超时

image.png
控制台总共输出三次
image.png

3.3、启动检查

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

image.png

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

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

可以通过check=false关闭

user-consumer模块中添加配置信息

  1. dubbo:
  2.   registry:
  3.     address: nacos://127.0.0.1:8848
  4.   consumer:
  5.     check: false

在DubboReference注解上配置

  1.  @DubboReference(check = false)  //check=false代表启动时不去检查是否有该服务接口的提供者
  2. private UserService userService;

3.4、多版本

灰度发布

  • 灰度发布：当发行新功能时，会让一部分用户先使用新功能，用户反馈没问题时，再将所有用户迁移到新功能。
  • dubbo 中使用version 属性来设置和调用同一个接口的不同版本

image.png

演示：启动2次服务，同时指定版本。消费者可以根据版本调用新老服务。

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

（1）user-provider定义新的服务实现类UserServiceImpl2，指定版本

  1. package com.itheima.service.impl;
  4. import com.itheima.domain.User;
  5. import com.itheima.mapper.UserMapper;
  6. import com.itheima.service.UserService;
  7. import org.apache.dubbo.config.annotation.DubboService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  11. @DubboService(version = "1.0")
  12. public class UserServiceImpl implements UserService {
  14.     @Autowired(required = false)
  15.     private UserMapper userMapper;
  17.     public User queryById(Long id) {
  18.         System.out.println("========version1.0版本被调用===========");
  19.         return userMapper.findById(id);
  20.     }
  21. }
  1. package com.itheima.service.impl;
  4. import com.itheima.domain.User;
  5. import com.itheima.mapper.UserMapper;
  6. import com.itheima.service.UserService;
  7. import org.apache.dubbo.config.annotation.DubboService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  10. @DubboService(version = "2.0")
  11. public class UserServiceImpl2 implements UserService {
  13.     @Autowired(required = false)
  14.     private UserMapper userMapper;
  16.     public User queryById(Long id) {
  17.         System.out.println("========version2.0版本被调用===========");
  18.         return userMapper.findById(id);
  19.     }
  20. }

（2）user-consumer消费者调用时，指定版本调用

  1. package com.itheima.controller;
  3. import com.itheima.domain.User;
  4. import com.itheima.service.UserService;
  5. import org.apache.dubbo.config.annotation.DubboReference;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  12. @RestController
  13. @RequestMapping("/user")
  14. public class UserController {
  16.     @DubboReference(version = "2.0")
  17.     private UserService userService;
  20.     /**
  21.      * 路径： /user/110
  22.      * @param id 用户id
  23.      * @return 用户
  24.      */
  25.     @GetMapping("/{id}")
  26.     public User queryById(@PathVariable("id") Long id) {
  27.         return userService.queryById(id);
  28.     }
  29. }

结果

image.png

image.png

3.5、负载均衡

  • 介绍
    image.png
    负载均衡策略（4种）：

    介绍
    • random ：按权重随机，默认值。按权重设置随机概率。
    • roundrobin ：按权重轮询
    • leastactive：最少活跃调用数，相同活跃数的随机。
    • consistenthash：一致性 Hash，相同参数的请求总是发到同一提供者。

演示：准备三台机器，权重分别是100/200/100，测试负载均衡策略。本例使用random随机。

user-provider

  1. package com.itheima.service.impl;
  4. import com.itheima.domain.User;
  5. import com.itheima.mapper.UserMapper;
  6. import com.itheima.service.UserService;
  7. import org.apache.dubbo.config.annotation.DubboService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  11. @DubboService
  12. public class UserServiceImpl implements UserService {
  14.     @Autowired(required = false)
  15.     private UserMapper userMapper;
  17.     public User queryById(Long id) {
  18.         System.out.println("========queryById===========");
  19.         return userMapper.findById(id);
  20.     }
  21. }

image.png

配置三台服务器

image.png

user-consumer消费者

  1. package com.itheima.controller;
  3. import com.itheima.domain.User;
  4. import com.itheima.service.UserService;
  5. import org.apache.dubbo.config.annotation.DubboReference;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  12. @RestController
  13. @RequestMapping("/user")
  14. public class UserController {
  16.     @DubboReference(loadbalance = "random")
  17.     private UserService userService;
  20.     /**
  21.      * 路径： /user/110
  22.      * @param id 用户id
  23.      * @return 用户
  24.      */
  25.     @GetMapping("/{id}")
  26.     public User queryById(@PathVariable("id") Long id) {
  27.         return userService.queryById(id);
  28.     }
  29. }

4、SpringCloud整合Dubbo

通常来说，dubbo协议比http具有更好的性能。很多开发人员希望享受Spring Cloud的生态，同时有兼顾dubbo的效率的效率。SpringCloud Alibaba很好的解决了这个问题。

4.1、功能概述

将Dubbo集成至SpringCloud主要是替换Ribbo或者Feign实现远程调用。加入Dubbo后，整体的架构如下：

image.png

4.2、入门案例

4.2.1、项目依赖

消费者和提供者引入nacos注册中心和Dubbo依赖

  1.  <dependencyManagement>
  2.         <dependencies>
  3.             <!--引入spring-cloud的依赖pom文件-->
  4.             <dependency>
  5.                 <groupId>org.springframework.cloud</groupId>
  6.                 <artifactId>spring-cloud-dependencies</artifactId>
  7.                 <version>Hoxton.SR10</version>
  8.                 <type>pom</type>
  9.                 <scope>import</scope>
  10.             </dependency>
  12.             <!--引入spring-cloud-alibaba的依赖pom文件-->
  13.             <dependency>
  14.                 <groupId>com.alibaba.cloud</groupId>
  15.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  16.                 <version>2.2.5.RELEASE</version>
  17.                 <type>pom</type>
  18.                 <scope>import</scope>
  19.             </dependency>
  20.         </dependencies>
  21.     </dependencyManagement>
  23.     <dependencies>
  24.         <!--nacos 服务发现-->
  25.         <dependency>
  26.             <groupId>com.alibaba.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  28.         </dependency>
  30.         <!--spring-cloud 整合dubbo的依赖-->
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-dubbo</artifactId>
  34.         </dependency>
  35.     </dependencies>

4.2.3、服务提供者

在application.yml中添加配置

  1. server:
  2.   port: ${sport:8081}
  3. spring:
  4.   datasource:
  5.     url: jdbc:mysql://localhost:3306/dubbo-demo?useSSL=false
  6.     username: root
  7.     password: root
  8.     driver-class-name: com.mysql.jdbc.Driver
  9.   application:
  10.     name: dubbo-provider
  11.   cloud:
  12.     nacos:
  13.       server-addr: localhost:8848
  15. logging:
  16.   level:
  17.     com.itheima : debug
  18.   pattern:
  19.     dateformat: HH:mm:ss:SSS
  20. dubbo:
  21.   protocol:
  22.     name: dubbo
  23.     port: ${dport:20880}
  24.   registry:
  25.     address: spring-cloud://localhost
  26.   scan:
  27.     base-packages: com.itheima.service

4.2.4、服务消费者

导入依赖

  1.     <dependencyManagement>
  2.         <dependencies>
  4.             <dependency>
  5.                 <groupId>org.springframework.cloud</groupId>
  6.                 <artifactId>spring-cloud-dependencies</artifactId>
  7.                 <version>Hoxton.SR10</version>
  8.                 <type>pom</type>
  9.                 <scope>import</scope>
  10.             </dependency>
  12.             <dependency>
  13.                 <groupId>com.alibaba.cloud</groupId>
  14.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  15.                 <version>2.2.5.RELEASE</version>
  16.                 <type>pom</type>
  17.                 <scope>import</scope>
  18.             </dependency>
  19.         </dependencies>
  20.     </dependencyManagement>
  22.     <dependencies>
  24.         <!--spring cloud 注册到nacos中-->
  25.         <dependency>
  26.             <groupId>com.alibaba.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  28.         </dependency>
  30.         <!--spring-cloud整合dubbo-->
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-dubbo</artifactId>
  34.         </dependency>
  35. </dependencies>

application.yaml文件

在OrderController中引入dubbo服务。调用UserService查询用户

  1. package cn.itcast.order.controller;
  3. import cn.itcast.dubbo.api.UserService;
  4. import cn.itcast.dubbo.domain.Order;
  5. import cn.itcast.dubbo.domain.User;
  6. import cn.itcast.order.service.OrderService;
  7. import org.apache.dubbo.config.annotation.DubboReference;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.web.bind.annotation.GetMapping;
  10. import org.springframework.web.bind.annotation.PathVariable;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RestController;
  14. @RestController
  15. @RequestMapping("order")
  16. public class OrderController {
  18.     @Autowired
  19.     private OrderService orderService;
  21.     @DubboReference
  22.     private UserService userService;
  24.     @GetMapping("{orderId}")
  25.     public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
  26.         //根据id查询订单
  27.         Order order = orderService.queryOrderById(orderId);
  28.         //获取用户id
  29.         Long userId = order.getUserId();
  30.         //查询用户
  31.         User user = userService.queryById(userId);
  32.         //设置用户对象
  33.         order.setUser(user);
  34.         // 根据id查询订单并返回
  35.         return order;
  36.     }
  37. }

在Order-service的模块中添加dubbo配置

  1. spring:
  2.   application:
  3.     name: order-service
  4.   cloud:
  5.     nacos:
  6.       discovery:
  7.         server-addr: localhost:8848
  8. #dubbo配置
  9. dubbo:
  10.   registry:
  11.     address: spring-cloud://localhost  #使用cloud的注册中心
  12.   consumer:
  13.     check: false   #dubbo默认有启动检查
  14.     retries: 0     #dubbo内置的重试机制

4.2.5 网关模块

  1. 创建模块

image.png

  1. 导入依赖
  1.     <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.3.9.RELEASE</version>
  5.         <relativePath/>
  6.     </parent>
  9.     <dependencyManagement>
  10.         <dependencies>
  12.             <dependency>
  13.                 <groupId>org.springframework.cloud</groupId>
  14.                 <artifactId>spring-cloud-dependencies</artifactId>
  15.                 <version>Hoxton.SR10</version>
  16.                 <type>pom</type>
  17.                 <scope>import</scope>
  18.             </dependency>
  20.             <dependency>
  21.                 <groupId>com.alibaba.cloud</groupId>
  22.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  23.                 <version>2.2.5.RELEASE</version>
  24.                 <type>pom</type>
  25.                 <scope>import</scope>
  26.             </dependency>
  27.         </dependencies>
  28.     </dependencyManagement>
  30.     <dependencies>
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.springframework.cloud</groupId>
  37.             <artifactId>spring-cloud-starter-gateway</artifactId>
  38.         </dependency>
  39.     </dependencies>
  1. 编写application.yml文件
  1. server:
  2.   port: 10010
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     nacos:
  8.       server-addr: localhost:8848
  9.     gateway:
  10.       routes:
  11.         - id: userservice
  12.           uri: lb://user-consumer
  13.           predicates:
  14.             - Path=/user/**
  1. 启动类
  1. package com.itheima;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class GatewayApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(GatewayApplication.class, args);
  10.     }
  11. }