devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Dubbo Spring Boot Starter 开发微服务应用_dubbo-spring-boot-starter

作者：weixin_40725706 | 2024-03-22 01:00:30

赞

踩

dubbo-spring-boot-starter

环境要求

  • 系统：Windows、Linux、MacOS

  • JDK 8 及以上（推荐使用 JDK17）

  • Git

  • IntelliJ IDEA（可选）

  • Docker （可选）

项目介绍

在本任务中，将分为 3 个子模块进行独立开发，模拟生产环境下的部署架构。

  1. .  // apache/dubbo-samples/1-basic/dubbo-samples-spring-boot
  2. ├── dubbo-samples-spring-boot-interface       // 共享 API 模块
  3. ├── dubbo-samples-spring-boot-consumer        // 消费端模块
  4. └── dubbo-samples-spring-boot-provider        // 服务端模块

如上所示，共有 3 个模块，其中 interface 模块被 consumer 和 provider 两个模块共同依赖，存储 RPC 通信使用的 API 接口。

  1. .  // apache/dubbo-samples/1-basic/dubbo-samples-spring-boot
  2. ├── dubbo-samples-spring-boot-interface       // 共享 API 模块
  3. │   ├── pom.xml
  4. │   └── src
  5. │       └── main
  6. │           └── java
  7. │               └── org
  8. │                   └── apache
  9. │                       └── dubbo
  10. │                           └── springboot
  11. │                               └── demo
  12. │                                   └── DemoService.java // API 接口
  13. ├── dubbo-samples-spring-boot-consumer        // 消费端模块
  14. │   ├── pom.xml
  15. │   └── src
  16. │       ├── main
  17. │       │   ├── java
  18. │       │   │   └── org
  19. │       │   │       └── apache
  20. │       │   │           └── dubbo
  21. │       │   │               └── springboot
  22. │       │   │                   └── demo
  23. │       │   │                       └── consumer
  24. │       │   │                           ├── ConsumerApplication.java // 消费端启动类
  25. │       │   │                           └── Task.java                // 消费端模拟调用任务
  26. │       │   └── resources
  27. │       │       └── application.yml       // Spring Boot 配置文件
  28. ├── dubbo-samples-spring-boot-provider        // 服务端模块
  29. │   ├── pom.xml
  30. │   └── src
  31. │       └── main
  32. │           ├── java
  33. │           │   └── org
  34. │           │       └── apache
  35. │           │           └── dubbo
  36. │           │               └── springboot
  37. │           │                   └── demo
  38. │           │                       └── provider
  39. │           │                           ├── DemoServiceImpl.java         // 服务端实现类
  40. │           │                           └── ProviderApplication.java     // 服务端启动类
  41. │           └── resources
  42. │               └── application.yml       // Spring Boot 配置文件
  43. └── pom.xml

如上为本教程接下来会使用到的项目的文件结构。

快速部署（基于 Samples 直接启动）

本章将通过几个简单的命令，一步一步教你如何部署并运行一个基于 Dubbo x Spring Boot 的用例。

注：本章部署的代码细节可以在 apache/dubbo-samples 这个仓库中 1-basic/dubbo-samples-spring-boot 中找到，在下一章中也将展开进行讲解。

1. 获取测试工程

在开始整个教程之前，我们需要先获取测试工程的代码。Dubbo 的所有测试用例代码都存储在 apache/dubbo-samples 这个仓库中，以下这个命令可以帮你获取 Samples 仓库的所有代码。

git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git

2. 启动一个简易的注册中心

对于一个微服务化的应用来说，注册中心是不可或缺的一个组件。只有通过注册中心，消费端才可以成功发现服务端的地址信息，进而进行调用。

为了让本教程更易于上手，我们提供了一个基于 Apache Zookeeper 注册中心的简易启动器，如果您需要在生产环境部署注册中心，​ 请参考生产环境初始化一文部署高可用的注册中心。

  1. Windows:
  2. ./mvnw.cmd clean compile exec:java -pl tools/embedded-zookeeper
  3.  
  4. Linux / MacOS:
  5. ./mvnw clean compile exec:java -pl tools/embedded-zookeeper
  6.  
  7. Docker:
  8. docker run --name some-zookeeper -p 2181:2181 --restart always -d zookeeper

3. 本地打包 API 模块

为了成功编译服务端、消费端模块，需要先在本地打包安装 dubbo-samples-spring-boot-interface 模块。

  1. ./mvnw clean install -pl 1-basic/dubbo-samples-spring-boot
  2. ./mvnw clean install -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-interface

4. 启动服务提供者

在启动了注册中心之后，下一步是启动一个对外提供服务的服务提供者。在 dubbo-samples 中也提供了对应的示例，可以通过以下命令快速拉起。

  1. Windows:  
  2. ./mvnw.cmd clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-provider -Dexec.mainClass="org.apache.dubbo.springboot.demo.provider.ProviderApplication"  
  3.  
  4. Linux / MacOS:
  5. ./mvnw clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-provider -Dexec.mainClass="org.apache.dubbo.springboot.demo.provider.ProviderApplication"  
  6.  
  7. 注：需要开一个独立的 terminal 运行，命令将会保持一直执行的状态。

在执行完上述命令以后，等待一会出现如下所示的日志（Current Spring Boot Application is await）即代表服务提供者启动完毕，标志着该服务提供者可以对外提供服务了。

  1. 2023-02-08 17:13:00.357  INFO 80600 --- [lication.main()] o.a.d.c.d.DefaultApplicationDeployer     :  [DUBBO] Dubbo Application[1.1](dubbo-springboot-demo-provider) is ready., dubbo version: 3.2.0-beta.4, current host: 30.221.128.96
  2. 2023-02-08 17:13:00.369  INFO 80600 --- [lication.main()] o.a.d.s.d.provider.ProviderApplication   : Started ProviderApplication in 9.114 seconds (JVM running for 26.522)
  3. 2023-02-08 17:13:00.387  INFO 80600 --- [pool-1-thread-1] .b.c.e.AwaitingNonWebApplicationListener :  [Dubbo] Current Spring Boot Application is await...

5. 启动服务消费者

最后一步是启动一个服务消费者来调用服务提供者，也即是 RPC 调用的核心，为服务消费者提供调用服务提供者的桥梁。

  1. Windows:  
  2. ./mvnw.cmd clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-consumer -Dexec.mainClass="org.apache.dubbo.springboot.demo.consumer.ConsumerApplication"
  3.  
  4. Linux / MacOS:
  5. ./mvnw clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-consumer -Dexec.mainClass="org.apache.dubbo.springboot.demo.consumer.ConsumerApplication"

在执行完上述命令以后，等待一会出现如下所示的日志（Hello world），打印出的数据就是服务提供者处理之后返回的，标志着一次服务调用的成功。

  1. 2023-02-08 17:14:33.045  INFO 80740 --- [lication.main()] o.a.d.s.d.consumer.ConsumerApplication   : Started ConsumerApplication in 11.052 seconds (JVM running for 31.62)
  2. Receive result ======> Hello world
  3. 2023-02-08 17:14:33.146  INFO 80740 --- [pool-1-thread-1] .b.c.e.AwaitingNonWebApplicationListener :  [Dubbo] Current Spring Boot Application is await...
  4. Wed Feb 08 17:14:34 CST 2023 Receive result ======> Hello world
  5. Wed Feb 08 17:14:35 CST 2023 Receive result ======> Hello world
  6. Wed Feb 08 17:14:36 CST 2023 Receive result ======> Hello world
  7. Wed Feb 08 17:14:37 CST 2023 Receive result ======> Hello world

动手实践（从零代码开发版）

本章将通过手把手的教程一步一步教你如何从零开发一个微服务应用。

1. 启动注册中心

对于一个微服务化的应用来说，注册中心是不可或缺的一个组件。只有通过注册中心，消费端才可以成功发现服务端的地址信息，进而进行调用。

为了让本教程更易于上手，我们提供了一个基于 Apache Zookeeper 注册中心的简易启动器，如果您需要在生产环境部署注册中心，请参考生产环境初始化一文部署高可用的注册中心。

  1. Windows:
  2. git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git
  3. cd dubbo-samples
  4. ./mvnw.cmd clean compile exec:java -pl tools/embedded-zookeeper
  5.  
  6. Linux / MacOS:
  7. git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git
  8. cd dubbo-samples
  9. ./mvnw clean compile exec:java -pl tools/embedded-zookeeper
  10.  
  11. Docker:
  12. docker run --name some-zookeeper -p 2181:2181 --restart always -d zookeeper

2. 初始化项目

从本小节开始，将基于 IntelliJ IDEA 进行工程的搭建以及测试。

img

如上图所示，可以建立一个基础的项目。

搭建了基础项目之后，我们还需要创建 dubbo-spring-boot-demo-interface 、dubbo-spring-boot-demo-provider 和 dubbo-spring-boot-demo-consumer 三个子模块。

 

 

img

img

img

img

创建了三个子模块之后，需要创建一下几个文件夹：

  1. 在 dubbo-spring-boot-demo-consumer/src/main/java 下创建 org.apache.dubbo.springboot.demo.consumer package

  2. 在 dubbo-spring-boot-demo-interface/src/main/java 下创建 org.apache.dubbo.springboot.demo package

  3. 在 dubbo-spring-boot-demo-provider/src/main/java 下创建 org.apache.dubbo.springboot.demo.provider package

 

img

最终的文件夹参考如上图所示。

3. 添加 Maven 依赖

在初始化完项目以后，我们需要先添加 Dubbo 相关的 maven 依赖。

对于多模块项目，首先需要在父项目的 pom.xml 里面配置依赖信息。

 

img

编辑 ./pom.xml 这个文件，添加下列配置。

  1.     <groupId>org.apache.dubbo</groupId>
  2.     <artifactId>dubbo-spring-boot-demo</artifactId>
  3.     <version>1.0-SNAPSHOT</version>
  4.     <packaging>pom</packaging>
  5.  
  6.     <modules>
  7.         <module>dubbo-spring-boot-demo-interface</module>
  8.         <module>dubbo-spring-boot-demo-provider</module>
  9.         <module>dubbo-spring-boot-demo-consumer</module>
  10.     </modules>
  11.  
  12.     <properties>
  13.         <dubbo.version>3.2.0-beta.4</dubbo.version>
  14.         <spring-boot.version>2.7.8</spring-boot.version>
  15.         <maven.compiler.source>17</maven.compiler.source>
  16.         <maven.compiler.target>17</maven.compiler.target>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  19.  
  20.     <dependencyManagement>
  21.         <dependencies>
  22.             <!-- Spring Boot -->
  23.             <dependency>
  24.                 <groupId>org.springframework.boot</groupId>
  25.                 <artifactId>spring-boot-dependencies</artifactId>
  26.                 <version>${spring-boot.version}</version>
  27.                 <type>pom</type>
  28.                 <scope>import</scope>
  29.             </dependency>
  30.  
  31.             <!-- Dubbo -->
  32.             <dependency>
  33.                 <groupId>org.apache.dubbo</groupId>
  34.                 <artifactId>dubbo-bom</artifactId>
  35.                 <version>${dubbo.version}</version>
  36.                 <type>pom</type>
  37.                 <scope>import</scope>
  38.             </dependency>
  39.  
  40.             <dependency>
  41.                 <groupId>org.apache.dubbo</groupId>
  42.                 <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
  43.                 <version>${dubbo.version}</version>
  44.                 <type>pom</type>
  45.             </dependency>
  46.         </dependencies>
  47.     </dependencyManagement>
  48.  
  49.  
  50.     <build>
  51.         <pluginManagement>
  52.             <plugins>
  53.                 <plugin>
  54.                     <groupId>org.springframework.boot</groupId>
  55.                     <artifactId>spring-boot-maven-plugin</artifactId>
  56.                     <version>${spring-boot.version}</version>
  57.                 </plugin>
  58.             </plugins>
  59.         </pluginManagement>
  60.     </build>

然后在 dubbo-spring-boot-consumer 和 dubbo-spring-boot-provider 两个模块 pom.xml 中进行具体依赖的配置。

 

img

编辑 ./dubbo-spring-boot-consumer/pom.xml 和 ./dubbo-spring-boot-provider/pom.xml 这两文件，都添加下列配置。

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.apache.dubbo</groupId>
  4.             <artifactId>dubbo-spring-boot-demo-interface</artifactId>
  5.             <version>${project.parent.version}</version>
  6.         </dependency>
  7.  
  8.         <!-- dubbo -->
  9.         <dependency>
  10.             <groupId>org.apache.dubbo</groupId>
  11.             <artifactId>dubbo-spring-boot-starter</artifactId>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.apache.dubbo</groupId>
  15.             <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
  16.             <type>pom</type>
  17.             <exclusions>
  18.                 <exclusion>
  19.                     <artifactId>slf4j-reload4j</artifactId>
  20.                     <groupId>org.slf4j</groupId>
  21.                 </exclusion>
  22.             </exclusions>
  23.         </dependency>
  24.  
  25.         <!-- spring boot starter -->
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter</artifactId>
  29.         </dependency>
  30.  
  31.     </dependencies>

在这份配置中，定义了 dubbo 和 zookeeper（以及对应的连接器 curator）的依赖。

添加了上述的配置以后，可以通过 IDEA 的 Maven - Reload All Maven Projects 刷新依赖。

4. 定义服务接口

服务接口 Dubbo 中沟通消费端和服务端的桥梁。

 

img

在 dubbo-spring-boot-demo-interface 模块的 org.apache.dubbo.samples.api 下建立 DemoService 接口，定义如下：

  1. package org.apache.dubbo.springboot.demo;
  2.  
  3. public interface DemoService {
  4.  
  5.     String sayHello(String name);
  6. }

在 GreetingsService 中，定义了 sayHi 这个方法。后续服务端发布的服务，消费端订阅的服务都是围绕着 GreetingsService 接口展开的。

5. 定义服务端的实现

定义了服务接口之后，可以在服务端这一侧定义对应的实现，这部分的实现相对于消费端来说是远端的实现，本地没有相关的信息。

img

在dubbo-spring-boot-demo-provider 模块的 org.apache.dubbo.samples.provider 下建立 DemoServiceImpl 类，定义如下：

  1. package org.apache.dubbo.springboot.demo.provider;
  2.  
  3. import org.apache.dubbo.config.annotation.DubboService;
  4. import org.apache.dubbo.springboot.demo.DemoService;
  5.  
  6. @DubboService
  7. public class DemoServiceImpl implements DemoService {
  8.  
  9.     @Override
  10.     public String sayHello(String name) {
  11.         return "Hello " + name;
  12.     }
  13. }

在 DemoServiceImpl 中，实现了 DemoService 接口，对于 sayHello 方法返回 Hello name。

注：在DemoServiceImpl 类中添加了 @DubboService 注解，通过这个配置可以基于 Spring Boot 去发布 Dubbo 服务。

6. 配置服务端 Yaml 配置文件

从本步骤开始至第 7 步，将会通过 Spring Boot 的方式配置 Dubbo 的一些基础信息。

首先，我们先创建服务端的配置文件。

 

img

在 dubbo-spring-boot-demo-provider 模块的 resources 资源文件夹下建立 application.yml 文件，定义如下：

  1. dubbo:
  2.   application:
  3.     name: dubbo-springboot-demo-provider
  4.   protocol:
  5.     name: dubbo
  6.     port: -1
  7.   registry:
  8.     address: zookeeper://${zookeeper.address:127.0.0.1}:2181

在这个配置文件中，定义了 Dubbo 的应用名、Dubbo 协议信息、Dubbo 使用的注册中心地址。

7. 配置消费端 YAML 配置文件

同样的，我们需要创建消费端的配置文件。

img

在 dubbo-spring-boot-demo-consumer 模块的 resources 资源文件夹下建立 application.yml 文件，定义如下：

  1. dubbo:
  2.   application:
  3.     name: dubbo-springboot-demo-consumer
  4.   protocol:
  5.     name: dubbo
  6.     port: -1
  7.   registry:
  8.     address: zookeeper://${zookeeper.address:127.0.0.1}:2181

在这个配置文件中，定义了 Dubbo 的应用名、Dubbo 协议信息、Dubbo 使用的注册中心地址。

8. 基于 Spring 配置服务端启动类

除了配置 Yaml 配置文件之外，我们还需要创建基于 Spring Boot 的启动类。

首先，我们先创建服务端的启动类。

 

img

在 dubbo-spring-boot-demo-provider 模块的 org.apache.dubbo.springboot.demo.provider 下建立 Application 类，定义如下：

  1. package org.apache.dubbo.springboot.demo.provider;
  2.  
  3. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6.  
  7. @SpringBootApplication
  8. @EnableDubbo
  9. public class ProviderApplication {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(ProviderApplication.class, args);
  12.     }
  13. }

在这个启动类中，配置了一个 ProviderApplication 去读取我们前面第 6 步中定义的 application.yml 配置文件并启动应用。

9. 基于 Spring 配置消费端启动类

同样的，我们需要创建消费端的启动类。

img

在 dubbo-spring-boot-demo-consumer 模块的 org.apache.dubbo.springboot.demo.consumer 下建立 Application 类，定义如下：

  1. package org.apache.dubbo.springboot.demo.consumer;
  2.  
  3. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6.  
  7. @SpringBootApplication
  8. @EnableDubbo
  9. public class ConsumerApplication {
  10.  
  11.     public static void main(String[] args) {
  12.         SpringApplication.run(ConsumerApplication.class, args);
  13.     }
  14. }

在这个启动类中，配置了一个 ConsumerApplication 去读取我们前面第 7 步中定义的 application.yml 配置文件并启动应用。

10. 配置消费端请求任务

除了配置消费端的启动类，我们在 Spring Boot 模式下还可以基于 CommandLineRunner去创建

img

 

在 dubbo-spring-boot-demo-consumer 模块的 org.apache.dubbo.springboot.demo.consumer 下建立 Task 类，定义如下：

  1. package org.apache.dubbo.springboot.demo.consumer;
  2.  
  3. import java.util.Date;
  4.  
  5. import org.apache.dubbo.config.annotation.DubboReference;
  6. import org.apache.dubbo.springboot.demo.DemoService;
  7. import org.springframework.boot.CommandLineRunner;
  8. import org.springframework.stereotype.Component;
  9.  
  10. @Component
  11. public class Task implements CommandLineRunner {
  12.     @DubboReference
  13.     private DemoService demoService;
  14.  
  15.     @Override
  16.     public void run(String... args) throws Exception {
  17.         String result = demoService.sayHello("world");
  18.         System.out.println("Receive result ======> " + result);
  19.  
  20.         new Thread(()-> {
  21.             while (true) {
  22.                 try {
  23.                     Thread.sleep(1000);
  24.                     System.out.println(new Date() + " Receive result ======> " + demoService.sayHello("world"));
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                     Thread.currentThread().interrupt();
  28.                 }
  29.             }
  30.         }).start();
  31.     }
  32. }

在 Task 类中，通过@DubboReference 从 Dubbo 获取了一个 RPC 订阅，这个 demoService 可以像本地调用一样直接调用。在 run方法中创建了一个线程进行调用。

11. 启动应用

截止第 10 步，代码就已经开发完成了，本小节将启动整个项目并进行验证。

 

img

首先是启动 org.apache.dubbo.samples.provider.Application ，等待一会出现如下图所示的日志（Current Spring Boot Application is await）即代表服务提供者启动完毕，标志着该服务提供者可以对外提供服务了。

[Dubbo] Current Spring Boot Application is await...

然后是启动org.apache.dubbo.samples.client.Application ，等待一会出现如下图所示的日志（Hello world ）即代表服务消费端启动完毕并调用到服务端成功获取结果。

imgimg

 

Receive result ======> Hello world

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/284096
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号