SpringBoot使用Dubbo的全过程(直连模式)

2026-05-23 10:27:02 作者：城南蝈蝈

这篇文章给大家介绍SpringBoot使用Dubbo的全过程(直连模式),本文结合实例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧

1.什么是Dubbo

Dubbo 是一款高性能、轻量级的 Java 分布式服务框架（RPC 框架），专门用来做 “微服务之间的远程调用”。简单说：A 服务想调用 B 服务的方法，像调用本地方法一样方便，底层就是 Dubbo 帮你做通信。

Registry（注册中心）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
Consumer（服务消费者）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
Monitor（监控中心）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
Provider（服务提供者）暴露服务的服务提供方，服务提供者在启动时，向注册中心注
册自己提供的服务。

核心作用:
（1）远程服务调用（RPC）：让服务之间像调用本地方法一样调用远程接口，屏蔽网络细节。
（2）服务注册与发现：服务启动时把自己注册到注册中心（如 Nacos、ZooKeeper），调用方自动发现可用服务。
（3）负载均衡、容错、限流：自动把请求分给多台服务器，某台挂了自动切换，保证系统高可用。

说明：本文只简单搭建和使用Dubbo，后续文章会整合成分布式架构。

本文用的工具：
IDEA版本：2026.1
JDK版本：17
Spring Boot版本：3.x
Dubbo版本：3.3.0

本文先创建父模块，然后分别创建 生产者 和 消费者

本文项目结构如下：

D:\Project\test\dubbo_demo
│
├── pom.xml                          # 父工程 Maven 配置
│
├── dubbo-api/                       # 接口模块
│   ├── pom.xml
│   └── src/
│       ├── main/
│       │   ├── java/
│       │   │   ── com.guo.service/
│       │   │       └── DogService.java
│       │   └── resources/
│       └── test/java/
│
├── dubbo-provider/                  # 服务提供者模块
│   ├── pom.xml
│   ── src/
│       ├── main/
│       │   ├── java/
│       │   │   └── com.guo/
│       │   │       ├── ProviderApplication.java
│       │   │       └── service/
│       │   │           └── DogServiceImpl.java
│       │   └── resources/
│       │       └── application.yml
│       └── test/java/
│
└── dubbo-consumer/                  # 服务消费者模块
    ├── pom.xml
    └── src/
        ├── main/
        │   ├── java/
        │   │   └── com.guo/
        │   │       ├── ConsumerApplication.java
        │   │       └── controller/
        │   │           └── DogController.java
        │   └── resources/
        │       └── application.yml
        └── test/java/

2.搭建父模块

2.1 创建父模块项目

父模块本身没有其他代码，主要用来管理子模块（实际上就是一个空Maven项目）。

这里选择“Java”，构建系统选择“Maven”，JDK这里选17，然后点击下面的创建。

创建完毕后，默认界面如下：

父工程没有其他的代码，只有一些依赖，所以这里直接把src文件删除，右击src文件夹，然后选择“删除”

然后，需要修改packaging，打开pom.xml，把下面的内容放到pom.xml中。（这行的意思是表示父工程，负责管理，不负责代码）

    <packaging>pom</packaging>

2.2 添加公共依赖

因为后面会创建子模块，子模块需要依赖，如果子模块很多，需要填写的依赖就很多。此时，我们可以在父模块引入依赖，子模块沿用父模块的依赖即可。
打开父工程的pom.xml，然后添加spring boot、dubbo的一些依赖。
另外，也增加了上面关于版本的定义，比如
<spring-boot.version>3.5.14</spring-boot.version>

然后有三种方式来下载依赖：
第一种：点击下图的1位置。
第二种：先点击下图的A,再点击B。
第三种：双击下图绿的的框。

下面的pom.xml中内容的参考(请参考下图的依赖)。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.guo</groupId>
    <artifactId>dubbo-demo2</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.5.14</spring-boot.version>
        <dubbo.version>3.3.0</dubbo.version>
        <jdk.version>17</jdk.version>
    </properties>
    <!-- 依赖管理：子模块可直接继承，无需重复引入 -->
    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot 核心依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
                <version>${spring-boot.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${spring-boot.version}</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${spring-boot.version}</version>
            </dependency>
            <!-- Dubbo 核心依赖 -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 插件管理，子模块继承 -->
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

下载依赖后的参考界面如下：

父模块无需编写 Java 代码，仅负责依赖版本管理和子模块关联，后续子模块直接继承父模块的依赖配置，避免版本冲突。

3.搭建api部分

3.1 创建api模块

api模块只对外提供接口，所有调用关系都有api模块来完成。

新建模块这里选择“Java”，名称填写“dubbo-api”，构建方式选Maven，JDK这里选17的版本，然后点击“创建”

创建完了后项目如下：
可以看到，父级的pom文件中，自动增加了我们刚才创建的module

3.2 创建一个接口

我们创建一个Service接口。创建之前，先创建包。
右击 dubbo-api模块的java文件夹。
选择“新建”—>“软件包”。

包名可以参考下面这样，可以写成这样的的目录。

com.guo.service

注意：我们这里只是简单的提供了一个service层，实际开发中，可能还有其他的软件包，比如
com.guo.entity等，这里不做演示。
创建完后，项目结构如下:

然后，右击刚才创建的文件夹service，选择"新建"—>“Java类”

这里创建的接口的名字假如是 DogService
注意：这里选的是“接口”，(interface ),不是类。然后按回车确认。

在里面增加一行代码：

   String sayHello(String name);

完整代码参考如下：

package com.guo.service;
public interface DogService {
    //一个接口
    String sayHello(String name);
}

3.搭建生成者（服务提供者）模块

这里的生产者主要的功能是提供服务（数据等），往前要去实现前面的接口，往后要做一些查询操作。本文只演示实现接口部分。

3.1 创建模块

右击父工程，选择“新建”—>“模块”

填写相关的内容，然后点击创建。

创建完后，项目结构如下：

3.2 添加依赖

这个模块需要增加一些依赖，打开dubbo-provider模块的pom.xml文件，增加下面的依赖

整体代码参考如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.guo</groupId>
        <artifactId>dubbo_demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>dubbo-provider</artifactId>
    <dependencies>
        <!--dubbo 与 spring-boot 整合包-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <!--springboot 启动核心包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3.3 添加实现类

这里主要实现api模块的DogService接口。
先创建项目包。
右击dubbo-provider中的java文件夹，选择“新建”—>“软件包”。

软件包的包名参考为 com.guo.service，然后按回车确定。

右击刚才创建的service文件夹，选择“新建”—>“Java类”

实现类的名字是 DogServiceImpl

然后我们让这个实现类去实现api模块的接口。
参考代码如下：

package com.guo.service;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;
@DubboService
@Component
public class DogServiceImpl  implements  DogService{
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + " (from direct provider)";
    }
}

注意，当你去实现DogService这个接口时候，报错是正常的，

解决这个报错很简单，把鼠标放上去，会看到一个“更多操作”，然后点击“更多操作"

在弹出的菜单里面点击“添加对模块xxxx的依赖”

此时，你会发现，当前这个模块的pom.xml文件中多了一个依赖（就是我们前面创建的dubbo-api模块）。

3.4 创建启动类

右击dubbo-provider中的 “guo”这个文件夹（注意启动类的位置）

类名为：ProviderApplication
然后按回车

启动类的参考代码如下:

package com.guo;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableDubbo
@SpringBootApplication
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
        System.out.println("Dubbo Provider started.");
    }
}

添加完代码后，项目参考如下：

3.5 添加配置文件

右击dubbo-provider中的resources文件夹，选择“新建" ,然后点击“文件”

这个配置文件的名字叫：application.yml
里面参考的配置内容如下：

server:
  port: 8081
dubbo:
  application:
    name: dubbo-provider
  protocol:
    name: dubbo
    port: 20880          # dubbo 服务端口，消费者直连时需要
  qos:
    enable: false

添加后，项目内容如下：

4.搭建消费者模块

消费者模块和生产者模块非常类似。

4.1 创建模块

右击项目名，点击“新建”—>“模块”。

然后参考输入下面的内容

创建完毕以后，项目结构如下：

4.2 添加依赖

打开dubbo-provider模块的依赖文件，参考增加下面的内容

参考代码：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.guo</groupId>
        <artifactId>dubbo_demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>dubbo-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

4.3 添加Contorller

先新建软件包，右击java，选择“新建”——>“软件包”

参考输入下面的内容：

com.guo.controller

然后，继续右击Controller，点击“新建”，然后点击“Java 类”

Controller的名字假定为：DogController

代码参考如下：

package com.guo.controller;
import com.guo.service.DogService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DogController {
    // 直连模式：直接指定 Provider 的地址和 Dubbo 端口
    @DubboReference(url = "dubbo://127.0.0.1:20880")
    private DogService dogService;
    @GetMapping("/hello")
    public String sayHello(@RequestParam("name") String name) {
        return dogService.sayHello(name);
    }
}

4.4 创建启动类

右击“guo”这个文件夹，选择“新建”—>“Java类”

类名为：ConsumerApplication

代码参考：

package com.guo;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableDubbo
@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

4.5 添加配置文件

右击“resources”文件，选择 “新建”—>“文件”

文件的名字为：
application.yml

内容参考如下：

server:
  port: 8082
dubbo:
  application:
    name: dubbo-demo-consumer
  # 不需要任何注册中心配置
  qos:
    enable: false

5.启动测试

先启动生产者Provider模块

再启动消费者模块（Consumer）

可以看到正常启动：

然后打开浏览器，在浏览器中输入下面的地址：

http://localhost:8082/hello?name=张三

看到下面内容，表示成功：

本文参考代码如下：dubbo_demo.zip

链接: https://pan.baidu.com/s/1ScG54D-WSSHw6k33hnH7ig?pwd=29r2

提取码: 29r2

到此这篇关于SpringBoot使用Dubbo的全过程(直连模式)的文章就介绍到这了,更多相关SpringBoot使用Dubbo内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！