通俗易懂的 Dubbo 教程（二）：Dubbo 与 Spring Boot 的整合

准备

首先我们需要搭建 Dubbo 的注册中心 zookeeper 环境以及搭建好 Dubbo 管理平台 dubbo-admin，由于这个不是本文的重点，在这里直接略过，需要了解细节的读者可以查阅相关资料。

搭建项目

我们创建一个项目名为 dubbo-test 的 Spring Boot 项目，然后在项目中新建三个模块，分别如下：

1. api：接口层，存放提供者与消费者调用的接口
2. producer：提供者，用于向消费者提供接口实现
3. consumer：消费者，调用提供者远程提供的接口实现

项目目录如下：

api 模块的实现

我们在 api 模块中定义一个接口，该接口用于修改名称。

package edu.szu.api.service;

/**
 * 修改名称的接口
 */
public interface NameService {
    String updateName(String name);
}

producer 模块的实现

首先我们在 producer 模块中得引入相关的依赖 dubbo-spring-boot-starter 以及上面实现的 api 模块，其 pom 文件实现如下：

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>edu.szu</groupId>
    <artifactId>producer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>producer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入api模块 -->
        <dependency>
            <groupId>edu.szu</groupId>
            <artifactId>api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!-- 引入dubbo环境 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

接下来我们需要编写 api 模块定义的 NameService 接口的实现，需要注意的是，在实现类上我们需要加上 @com.alibaba.dubbo.config.annotation.Service 的注解。

package edu.szu.producer.serviceImpl;

import com.alibaba.dubbo.config.annotation.Service;
import edu.szu.api.service.NameService;
import org.springframework.stereotype.Component;

@Component
@Service
public class NameServiceImpl implements NameService {

    @Override
    public String updateName(String name) {
        return "修改后的名称:" + name;
    }
}

然后在启动类上添加 @EnableDubbo 注解表示开启 Dubbo 服务

package edu.szu.producer;

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

@SpringBootApplication
@EnableDubbo
public class ProducerApplication {

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

}

最后修改一下配置文件，其实配置文件的注释已经非常详细了，所以在这里就不过多介绍每个配置的具体含义了。

server.port=8080
#提供方应用信息，用于计算依赖关系
dubbo.application.name=producer
#注册中心地址
dubbo.registry.address=127.0.0.1:2181
#使用zookeeper作为注册中心
dubbo.registry.protocol=zookeeper
#使用dubbo协议
dubbo.protocol.name=dubbo
#使用dubbo协议在20880端口暴露服务
dubbo.protocol.port=20880

consumer 模块的实现

首先引入相关的依赖 dubbo-spring-boot-starter 以及 api 模块，pom 文件如下：

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>edu.szu</groupId>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入api模块 -->
        <dependency>
            <groupId>edu.szu</groupId>
            <artifactId>api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!-- 引入dubbo环境 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

然后我们定义相关的，在消费者中实现的接口

package edu.szu.consumer.service;

public interface ChangeService {
    String change(String name);
}

然后提供接口的一个实现，在这里我们调用远程服务 nameService，需要注意的是我们在调用的远程服务接口上需要加上一个 @Reference 注解。

package edu.szu.consumer.serviceImpl;

import com.alibaba.dubbo.config.annotation.Reference;
import edu.szu.api.service.NameService;
import edu.szu.consumer.service.ChangeService;
import org.springframework.stereotype.Component;

@Component
public class ChangeServiceImpl implements ChangeService {

    @Reference
    NameService nameService;

    @Override
    public String change(String name) {
        return nameService.updateName(name);
    }
}

然后我们简单实现一下控制层

package edu.szu.consumer.controller;

import edu.szu.consumer.service.ChangeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChangeController {

    @Autowired
    private ChangeService changeService;

    @RequestMapping("/change/{name}")
    public String change(@PathVariable("name") String name) {
        return changeService.change(name);
    }

}

然后在启动类上添加 @EnableDubbo 注解表示开启 Dubbo 服务

package edu.szu.consumer;

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

@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {

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

}

最后修改一下配置文件

server.port=8081
#提供方应用信息，用于计算依赖关系
dubbo.application.name=consumer
#注册中心地址
dubbo.registry.address=127.0.0.1:2181
#使用zookeeper作为注册中心
dubbo.registry.protocol=zookeeper

测试

我们打开 Dubbo 的注册中心 zookeeper，然后分别启动 producer 和 consumer，在浏览器上输入 http://localhost:8081/change/HelloDubbo ，发现显示如下：

说明了消费者确实成功远程调用了提供者提供的服务。

然后我们再启动 dubbo-admin，其显示如下：

dubbo-admin 已成功监控到我们的提供者与消费者，同时表示我们的 Dubbo 与 Spring Boot 整合成功。