⾸先，新建两个 SpringBoot 项⽬，⼀个叫consumer，⼀个叫provider

1. provider 项⽬

1.1 项⽬结构

1.2 pom⽂件

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.6.6</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
</dependencies>

1.3 ProviderApplication

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

1.4 User

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String uid;
    private String username;
}

1.5 UserService

@Service
public class UserService {
    public User getUser(String uid) {
        User zhouyu = new User(uid, "zhouyu");
        return zhouyu;
    }
}

1.6 UserController

@RestController
public class UserController {
    @Resource
    private UserService userService;

    @GetMapping("/user/{uid}")
    public User getUser(@PathVariable("uid") String uid) {
        return userService.getUser(uid);
    }
}

1.7 application.properties

server.port=8080

2. consumer项⽬

2.1 项⽬结构

2.2 pom⽂件

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.6.6</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
</dependencies>

2.3 ConsumerApplication

@SpringBootApplication
public class ConsumerApplication {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

2.4 User

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String uid;
    private String username;
}

2.5 OrderService

@Service
public class OrderService {
    @Resource
    private RestTemplate restTemplate;

    public String createOrder() {
        User user =
                restTemplate.getForObject("http://localhost:8080/user/1", User.class);
        System.out.println("创建订单");
        return user.toString() + " succeeded in creating the order";
    }
}

2.6 OrderController

@RestController
public class OrderController {
    @Resource
    private OrderService orderService;

    @GetMapping("/createOrder")
    public String createOrder() {
        return orderService.createOrder();
    }
}

2.7 application.properties

server.port=8081

consumer 中的 OrderService 会通过 RestTemplate 调⽤ provider 中的 UserService。

3. 改造成Dubbo

改造成Dubbo项⽬，有⼏件事情要做：

1. 添加dubbo核⼼依赖

2. 添加要使⽤的注册中⼼依赖

3. 添加要使⽤的协议的依赖

4. 配置dubbo相关的基本信息

5. 配置注册中⼼地址

6. 配置所使⽤的协议

3.1 增加依赖

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>3.0.7</version>
</dependency>

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-rpc-dubbo</artifactId>
    <version>3.0.7</version>
</dependency>

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-registry-zookeeper</artifactId>
    <version>3.0.7</version>
</dependency>

3.2 配置properties

dubbo.application.name=provider-application
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
dubbo.registry.address=zookeeper://127.0.0.1:2181

3.3 改造服务

consumer 和 provider 中都⽤到了 User 类，所以可以单独新建⼀个 maven 项⽬⽤来存 consumer 和 provider 公⽤的⼀些类，新增⼀个 common 模块，把User类转移到这个模块中。

要改造成 Dubbo，得先抽象出来服务，⽤接⼝表示。

像 UserService 就是⼀个服务，不过我们得额外定义⼀个接⼝，我们把之前的 UserService 改为 UserServiceImpl，然后新定义⼀个接⼝UserService，该接⼝表示⼀个服务，UserServiceImpl 为该服务的具体实现。

public interface UserService {
    public User getUser(String uid);
}

@DubboService
public class UserServiceImpl implements UserService {
    public User getUser(String uid) {
        User zhouyu = new User(uid, "zhouyu");
        return zhouyu;
    }
}

注意

要把 Spring 中的 @Service 注解替换成 Dubbo 中的 @DubboService 注解。

然后把 UserService 接⼝也转移到 common 模块中去，在 provider 中依赖 common。

改造之后的 provider 为：

其实 UserController 也可以去掉，去掉之后 provider 就更加简单了

此时就可以启动该Provider了，注意先启动zookeeper（⾼版本的Zookeeper启动过程中不仅会占⽤2181，也会占⽤8080，所以可以把provider的端⼝改为8082）

3.4 开启Dubbo

在ProviderApplication 上加上 @EnableDubbo(scanBasePackages = "com.zhouyu.service") ，表示 Dubbo 会去扫描某个路径下的@DubboService，从⽽对外提供该 Dubbo 服务。

@SpringBootApplication
@EnableDubbo(scanBasePackages = "com.zhouyu.service")
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class);
    }
}

4. 调⽤Dubbo服务

4.1 引⼊依赖

在 consumer 中如果想要调⽤ Dubbo 服务，也要引⼊相关的依赖：

1. 引⼊common，主要是引⼊要⽤调⽤的接⼝
2. 引⼊dubbo依赖
3. 引⼊需要使⽤的协议的依赖
4. 引⼊需要使⽤的注册中⼼的依赖

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>3.0.7</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-rpc-dubbo</artifactId>
    <version>3.0.7</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-registry-zookeeper</artifactId>
    <version>3.0.7</version>
</dependency>
<dependency>
    <groupId>com.zhouyu</groupId>
    <artifactId>common</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

4.2 引⼊服务

通过 @DubboReference 注解来引⼊⼀个Dubbo服务。

@Service
public class OrderService {
    @DubboReference
    private UserService userService;

    public String createOrder() {
        User user = userService.getUser("1");
        System.out.println("创建订单");
        return user.toString() + " succeeded in creating the order";
    }
}

这样就不需要⽤RestTemplate了。

4.3 配置properties

dubbo.application.name=consumer-application
dubbo.registry.address=zookeeper://127.0.0.1:2181

4.4 调用

如果 User 没有实现 Serializable 接⼝，则会报错。

5. 总结

⾃此，Dubbo的改造就完成了，总结⼀下：

1. 添加 pom 依赖

2. 配置 dubbo 应⽤名、协议、注册中⼼

3. 定义服务接⼝和实现类

4. 使⽤ @DubboService 来定义⼀个 Dubbo 服务

5. 使⽤ @DubboReference 来使⽤⼀个 Dubbo 服务

6. 使⽤ @EnableDubbo 开启 Dubbo