跳至主要內容

Dubbo快速入门实战

cheniy2025/8/15大约 4 分钟Java微服务DubboRPC分布式

Dubbo快速入门实战

前置知识

在开始本教程之前，建议您具备以下基础知识：

  • Java基础语法和面向对象编程
  • Spring框架基础
  • Maven或Gradle构建工具
  • 了解Dubbo的基本概念（可参考上一篇文章）

环境准备

在开始使用Dubbo之前，我们需要准备以下环境：

1. JDK安装

Dubbo 3.x版本要求JDK 8或以上版本。您可以通过以下命令检查JDK版本：

java -version

2. Maven安装

Dubbo项目推荐使用Maven进行依赖管理。您可以通过以下命令检查Maven版本：

mvn -version

3. 注册中心安装

Dubbo支持多种注册中心，本教程以ZooKeeper为例。

ZooKeeper安装

  1. 下载ZooKeeper：https://zookeeper.apache.org/releases.html
  2. 解压下载的文件
  3. 在conf目录下创建zoo.cfg文件（可复制zoo_sample.cfg并重命名）
# ZooKeeper基本配置
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/tmp/zookeeper
clientPort=2181
  1. 启动ZooKeeper服务
# Windows
bin\zkServer.cmd

# Linux/Mac
bin/zkServer.sh start

创建Dubbo项目

我们将创建一个完整的Dubbo示例项目，包含以下模块：

  • dubbo-api：公共接口模块
  • dubbo-provider：服务提供者模块
  • dubbo-consumer：服务消费者模块

1. 创建父项目

父项目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.example</groupId>
    <artifactId>dubbo-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>dubbo-api</module>
        <module>dubbo-provider</module>
        <module>dubbo-consumer</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.7.8</spring-boot.version>
        <dubbo.version>3.2.0</dubbo.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- Dubbo -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- Dubbo Spring Boot Starter -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
            
            <!-- ZooKeeper -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-zookeeper</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 创建API模块

创建dubbo-api模块，定义服务接口和实体类：

User.java 实体类
package com.example.dubbo.api;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
UserService.java 接口
package com.example.dubbo.api;

import java.util.List;

public interface UserService {
    User getUser(Long id);
    List<User> listUsers();
    Long createUser(User user);
    void updateUser(User user);
    void deleteUser(Long id);
}

3. 创建服务提供者模块

UserServiceImpl.java 服务实现
package com.example.dubbo.provider;

import com.example.dubbo.api.User;
import com.example.dubbo.api.UserService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@DubboService
@Service
public class UserServiceImpl implements UserService {
    private final Map<Long, User> users = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong();

    @Override
    public User getUser(Long id) {
        return users.get(id);
    }

    @Override
    public List<User> listUsers() {
        return new ArrayList<>(users.values());
    }

    @Override
    public Long createUser(User user) {
        Long id = idGenerator.incrementAndGet();
        user.setId(id);
        users.put(id, user);
        return id;
    }

    @Override
    public void updateUser(User user) {
        users.put(user.getId(), user);
    }

    @Override
    public void deleteUser(Long id) {
        users.remove(id);
    }
}

配置application.yml：

server:
  port: 8081

spring:
  application:
    name: dubbo-provider

dubbo:
  application:
    name: ${spring.application.name}
  protocol:
    name: dubbo
    port: 20880
  registry:
    address: zookeeper://127.0.0.1:2181

4. 创建服务消费者模块

创建REST接口调用Dubbo服务：

package com.example.dubbo.consumer;

import com.example.dubbo.api.User;
import com.example.dubbo.api.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {
    @DubboReference
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }

    @GetMapping
    public List<User> listUsers() {
        return userService.listUsers();
    }

    @PostMapping
    public Long createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping
    public void updateUser(@RequestBody User user) {
        userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

配置application.yml：

server:
  port: 8082

spring:
  application:
    name: dubbo-consumer

dubbo:
  application:
    name: ${spring.application.name}
  registry:
    address: zookeeper://127.0.0.1:2181

运行和测试

  1. 启动ZooKeeper
  2. 启动服务提供者
  3. 启动服务消费者
  4. 测试服务
# 创建用户
curl -X POST http://localhost:8082/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"张三","age":25,"email":"zhangsan@example.com"}'

# 查询用户
curl http://localhost:8082/users/1

# 更新用户
curl -X PUT http://localhost:8082/users \
  -H 'Content-Type: application/json' \
  -d '{"id":1,"name":"张三","age":26,"email":"zhangsan@example.com"}'

# 删除用户
curl -X DELETE http://localhost:8082/users/1

总结

本文通过一个完整的示例演示了如何：

  1. ✅ 搭建Dubbo开发环境
  2. ✅ 创建多模块Dubbo项目
  3. ✅ 实现服务提供者和消费者
  4. ✅ 使用REST API测试服务

下一步学习

  • 了解Dubbo的高级特性
  • 学习服务治理能力
  • 探索性能优化方案

希望这篇文章对您有所帮助！如果您有任何问题，欢迎在评论区讨论。

最近更新
贡献者: cheniy