超简单，手把手教你搭建Dubbo工程（内附源码）

系列文章目录

【建议收藏】精通Dubbo的SPI机制，一文即可
面试Dubbo ，却问我和Springcloud有什么区别？

---

---

前言

今天又是手把手教程的一篇————手把手教你搭建Dubbo项目，边搭建边教，一共两种模式的工程，文中还有工程源码压缩包，也欢迎下载

📕作者简介：战斧，多年开发及管理经验，爱好广泛，致力于创作更多高质量内容
📗本文收录于 Dubbo专栏，有需要者，可直接订阅专栏实时获取更新
📘高质量专栏 RabbitMQ、Spring全家桶 等仍在更新，欢迎指导
📙Zookeeper Redis kafka docker netty等诸多框架，以及架构与分布式专题即将上线，敬请期待

---

一、本地调用工程

1. 本地模型介绍

我们首先看Dubbo的宏观模型

我们不难看出，Dubbo至少有 服务提供者 、服务消费者、注册中心 三个部件，但是其实我们可以先不引入额外的注册中心，只在本地进行调用，Dubbo提供了本地调用的功能，即同一个JVM进程内进行的Dubbo服务调用，且在2.2.0 后默认为所有的服务都进行本地暴露，其模型如下：

那么我们可以创建这样一个工程，其中分为两个模块，一个api模块负责定义接口，一个service模块负责实现服务提供方 和 服务消费者的代码，工程如下图，我已经上传本工程，可以 点此下载

2. 工程分析

首先要做的就是确定版本了，因为是验证形的工程，所以选用的是最新的稳定版dubbo3.1.8，配合spring-boot2.7.10

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zhanfu.dubbo</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>demo</name>
    <description>Dubbo Demo</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <dubbo.version>3.1.8</dubbo.version>
        <spring-boot.version>2.7.10</spring-boot.version>
    </properties>

    <modules>
        <module>demo-api</module>
        <module>demo-service</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-zookeeper</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.zhanfu.dubbo</groupId>
                <artifactId>demo-api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.zhanfu.dubbo</groupId>
                <artifactId>demo-service</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

我们先定义一下API了，就是写一个接口，非常简单

package com.zhanfu.dubbo.demo.dubbo.api;

public interface DemoService {
    String sayHello(String name);
}

接下来写实现类，这里的关键就是，在该实现类上加上 @DubboService 注解

package com.zhanfu.dubbo.demo.dubbo.service;

import com.zhanfu.dubbo.demo.dubbo.api.DemoService;
import org.apache.dubbo.config.annotation.DubboService;

@DubboService
public class DemoServiceImpl implements DemoService {

    @Override
    public String sayHello(String name) {
        return "你好啊， " + name;
    }
}

然后写消费者，在消费者里引用API，并写上 @DubboReference 注解。此处的 @Component 注解和实现 CommandLineRunner 接口是为了让其在Springboot 工程内被发现，和自动执行

package com.zhanfu.dubbo.demo.dubbo.consumer;

import com.zhanfu.dubbo.demo.dubbo.api.DemoService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class Consumer implements CommandLineRunner {
    @DubboReference
    private DemoService demoService;

    @Override
    public void run(String... args) throws Exception {

        String result = demoService.sayHello("战斧");
        System.out.println("收到消息：" + result);
    }
}

接着别忘了写工程的启动类，注意启动类上的注解：@EnableDubbo

package com.zhanfu.dubbo.demo;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

最后写上配置类 application.properties

# 设置dubbo传输协议
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
# Dubbo 应用名
dubbo.application.name=DemoApplication
dubbo.application.logger=slf4j

3. 启动验证

点击启动类进行启动

工程成功启动，且消费者本地调用成功

---

二、RPC工程

1. ZK 安装

要想进行RPC的功能，我们必须得先弄好注册中心，这里选取Zookeeper作为我们的注册中心，如果你的环境已经有zk，可跳出此步骤。如果没有，你可以 点击此处 进入具体安装的教程，安装完成后记得启动

2. 工程分析

消费者与实现类代码其实同单机一样，只是需要把服务提供者和消费者拆开，拆成不同的模块单独启动，这里拆到了client和server两个模块，点此下载 其工程压缩包

然后再写两个模块的配置文件，服务端要加入注册中心地址，然后先启动，其配置如下

# Dubbo 应用名
dubbo.application.name=DubboServer
dubbo.application.logger=slf4j
# 设置dubbo传输协议
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
dubbo.registry.address=zookeeper://127.0.0.1:2181

消费者的配置如下，因为qos默认端口22222已经被服务端占用，所以消费端定义成了22223

# Dubbo 应用名
dubbo.application.name=DubboClient
dubbo.application.logger=slf4j
# 服务质量端口
dubbo.application.qos-port=22223
# 设置dubbo传输协议
dubbo.protocol.name=dubbo
dubbo.protocol.port=20881
dubbo.registry.address=zookeeper://127.0.0.1:2181

3. 启动验证

先启动server，然后再启动client，观察其输出

效果符合预期，我们再进入ZKUI看看现在Zookeeper的情况，可以看到接口已经注册到Zk，消费者和提供者也注册成功

三、总结

本次，我们学习了两种dubbo的调用模式 ———— RPC和本地调用，也初步接触到了几个关键注解，如

• @EnableDubbo
• @DubboReference
• @DubboService

但现在我们还没有解释这些注解的作用和其原理，以及 Dubbo 是如何和 Spring 框架相辅相成的。别急，这些内容将在后面的博文仔细为你解答