Apache Dubbo 框架的使用（五）

小辰哥哥

已于 2022-07-17 20:42:38 修改

阅读量1.2k

点赞数 1

分类专栏： Dubbo 文章标签： dubbo

于 2021-04-25 16:10:36 首次发布

本文链接：https://blog.csdn.net/weixin_43630831/article/details/116003603

版权

Dubbo 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

*Springboot_Dubbo_Zookeeper整合的三种方式*
1.使用XML的方式进行整合
2.使用注解API的方式进行整合
总结

Springboot_Dubbo_Zookeeper整合的三种方式

三种方式如下：
1：在application.yml中配置属性，@Service【暴露服务】，@Reference【引用服务】，@EnableDubbo【开启基于注解的dubbo功能】（详情请见Apache Dubbo 框架的使用（三、四））

2：保留provider.xml、consumer.xml配置文件（需要注释application.yml相关dubbo配置属性），使用@ImportResource导入dubbo的配置文件即可

3：使用注解API的方式，将每一个组件手动创建到容器中，让dubbo来扫描其他的组件

1.使用XML的方式进行整合

注意（关于配置覆盖关系）：
1：方法级优先，接口级次之，全局配置再次之（先考虑）
2：如果级别一样，则消费方优先，提供方次之

provider.xml（生产者）相关配置信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 1:指定当前服务/应用的名字（同样的服务名字相同，不要和别的服务同名） -->
    <dubbo:application name="boot-provider"></dubbo:application>

    <!-- 2:指定注册中心的位置、启动时检查 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" check="true"></dubbo:registry>
    <!--或者-->
    <!--<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>-->

    <!-- 3:指定通信规则（通信协议?通信端口）-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

    <!-- 4:声明需要暴露的服务接口 ref:指向服务的真正的实现对象、超时、重试次数、多版本 -->
    <dubbo:service interface="com.kd.opt.service.FoodService" ref="foodServiceImpl" timeout="1000" retries="3" version="1.0.0">
        <!-- 配置提供者方法一（foodServiceImpl实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAll" timeout="1000" retries="3"></dubbo:method>

        <!-- 配置提供者方法二（foodServiceImpl实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAllNew" timeout="1000" retries="3"></dubbo:method>
    </dubbo:service>
    <!-- ref:指向服务的真正的实现对象（服务的实现） -->
    <bean id="foodServiceImpl" class="com.kd.opt.service.impl.FoodServiceImpl"/>

    <!-- 5:配置多版本 -->
    <dubbo:service interface="com.kd.opt.service.FoodService" ref="foodServiceImpl2" timeout="1000" retries="3" version="2.0.0">
        <!-- 配置提供者方法一（foodServiceImpl2实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAll" timeout="1000" retries="3"></dubbo:method>

        <!-- 配置提供者方法二（foodServiceImpl2实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAllNew" timeout="1000" retries="3"></dubbo:method>
    </dubbo:service>
    <bean id="foodServiceImpl2" class="com.kd.opt.service.impl.FoodServiceImpl2"/>

    <!-- 6:监控中心配置（自动发现）-->
    <dubbo:monitor protocol="registry"></dubbo:monitor>
    <!--或者-->
    <!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

    <!-- 7:配置当前提供者的统一规则，全部服务超时属性，全部服务重试次数 -->
    <dubbo:provider timeout="1000" retries="3"></dubbo:provider>

</beans>

consumer.xml（消费者）相关配置信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 1:指定当前服务/应用的名字（同样的服务名字相同，不要和别的服务同名） -->
    <dubbo:application name="boot-consumer"></dubbo:application>

    <!-- 2:指定注册中心的位置、启动时检查 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" check="true"></dubbo:registry>
    <!--或者-->
    <!--<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>-->

    <!-- 3:声明需要调用的远程服务的接口，生成远程服务代理、启动时检查、超时、重试次数、多版本、本地存根 -->
    <dubbo:reference id="userService" interface="com.kd.opt.service.FoodService" check="true" timeout="6000" retries="3" version="2.0.0" stub="com.kd.opt.service.impl.FoodServiceImpl3">
        <!-- 配置消费者调用提供者的方法一（foodServiceImpl实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAll" timeout="6000" retries="3"></dubbo:method>

        <!-- 配置消费者调用提供者的方法二（foodServiceImpl实现类）、单个方法超时、单个方法重试次数 -->
        <dubbo:method name="getFoodAllNew" timeout="6000" retries="3"></dubbo:method>
    </dubbo:reference>

    <!-- 4:监控中心配置（自动发现）-->
    <dubbo:monitor protocol="registry"></dubbo:monitor>
    <!--或者-->
    <!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

    <!-- 5:配置当前消费者的统一规则，全部服务启动时检查，全部服务超时属性，全部服务重试次数，全部服务多版本，全部服务本地存根 -->
    <dubbo:consumer check="true" timeout="6000" retries="3" version="1.0.0" stub="com.kd.opt.service.impl.FoodServiceImpl3"></dubbo:consumer>

</beans>

项目结构如下（boot-interface-all、boot-provider、boot-consumer）：
在这里插入图片描述
boot-interface-all 更新代码如下（参考Apache Dubbo 框架的使用（三、四））：

package com.kd.opt.service;

import com.kd.opt.entity.Food;

import java.util.List;

public interface FoodService {

  /**
   * 获取全部食物信息（方法一）
   *
   * @return
   * @author 小辰哥哥
   */
  List<Food> getFoodAll();

  /**
   * 获取全部食物信息（方法二）
   *
   * @return
   * @author 小辰哥哥
   */
  List<Food> getFoodAllNew();
}

package com.kd.opt.service;

import com.kd.opt.entity.User;

public interface UserService {

  /**
   * 获取用户相关信息（方法一）
   *
   * @return
   * @author 小辰哥哥
   */
  User getUserAndFood();

  /**
   * 获取用户相关信息（方法二）
   *
   * @return
   * @author 小辰哥哥
   */
  User getUserAndFoodNew();
}

package com.kd.opt.service.impl;

import com.kd.opt.entity.Food;
import com.kd.opt.service.FoodService;

import java.util.List;

/**
 * 实现FoodService接口（本地存根）
 *
 * @author 小辰哥哥
 */
public class FoodServiceImpl3 implements FoodService {


  private final FoodService foodService;

  /**
   * 传入的是FoodService远程代理对象
   *
   * @author 小辰哥哥
   * @param foodService
   */
  public FoodServiceImpl3(FoodService foodService) {
    this.foodService = foodService;
  }

  @Override
  public List<Food> getFoodAll() {

    // 相当于个拦截器，可以先进行一系列的小验证
    if("1".equals("0")){

      // 当不满足某种条件时，返回值为Null
      return null;
    }
    return foodService.getFoodAll();
  }

  @Override
  public List<Food> getFoodAllNew() {
    // 相当于个拦截器，可以先进行一系列的小验证
    if("1".equals("0")){

      // 当不满足某种条件时，返回值为Null
      return null;
    }
    return foodService.getFoodAllNew();
  }
}

在这里插入图片描述
boot-provider 更新代码如下（参考Apache Dubbo 框架的使用（三、四））：

# 日志级别设置
logging:
  level:
    root: info # 最基础的日志输出级别
    com.kd.opt: debug  # 指定包下的日志输出级别
    org.springframework.web: debug # 指定类下的日志输出级别

# 端口号和上下文路径
server:
  port: 8088
  servlet:
    context-path: /boot-provider

# 支持名称相同的bean的覆盖（如果不配置的话会发生报错）
spring:
  main:
    allow-bean-definition-overriding: true

在这里插入图片描述

package com.kd.opt.service.impl;

import com.kd.opt.entity.Food;
import com.kd.opt.service.FoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 实现FoodService接口
 *
 * @author 小辰哥哥
 */

// org.springframework.stereotype.Service（Spring家的）
@Service
public class FoodServiceImpl implements FoodService {

  // 打印日志
  private static final Logger LOGGER = LoggerFactory.getLogger(FoodServiceImpl.class);

  @Override
  public List<Food> getFoodAll() {

    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("1","蓝色妖姬"));
    foodList.add(new Food("2","骨肉相连"));
    foodList.add(new Food("3","螺蛳粉"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }

  @Override
  public List<Food> getFoodAllNew() {
    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("7","炸鸡"));
    foodList.add(new Food("8","火锅"));
    foodList.add(new Food("9","过桥米线"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }
}

package com.kd.opt.service.impl;

import com.kd.opt.entity.Food;
import com.kd.opt.service.FoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 实现FoodService接口
 *
 * @author 小辰哥哥
 */

// org.springframework.stereotype.Service（Spring家的）
@Service
public class FoodServiceImpl2 implements FoodService {

  // 打印日志
  private static final Logger LOGGER = LoggerFactory.getLogger(FoodServiceImpl2.class);

  @Override
  public List<Food> getFoodAll() {

    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("4","麻辣烫"));
    foodList.add(new Food("5","土豆粉"));
    foodList.add(new Food("6","冷面"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }

  @Override
  public List<Food> getFoodAllNew() {
    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("10","黄焖鸡"));
    foodList.add(new Food("11","烤鸭"));
    foodList.add(new Food("12","干豆腐"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }
}

package com.kd.opt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
// 引入provider.xml文件
@ImportResource(locations = "classpath:provider.xml")
public class BootProviderApplication {

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

在这里插入图片描述
boot-consumer 更新代码如下（参考Apache Dubbo 框架的使用（三、四））：

# 日志级别设置
logging:
  level:
    root: info # 最基础的日志输出级别
    com.kd.opt: debug  # 指定包下的日志输出级别
    org.springframework.web: debug # 指定类下的日志输出级别

package com.kd.opt.service.impl;

import com.kd.opt.entity.Food;
import com.kd.opt.entity.User;
import com.kd.opt.service.FoodService;
import com.kd.opt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 实现UserService接口
 *
 * @author 小辰哥哥
 */
// org.springframework.stereotype.Service（Spring家的）
@Service
public class UserServiceImpl implements UserService {

  // 引入食物业务层（依赖注入）
  @Autowired
  private FoodService foodService;

  @Override
  public User getUserAndFood() {

    // 获取食物相关信息
    List<Food> foodList = foodService.getFoodAll();

    // 创建一个用户对象
    User user = new User();
    user.setUserId("001");
    user.setUserName("小辰哥哥");
    user.setUserAge("18");
    user.setFoodList(foodList);

    return user;
  }

  @Override
  public User getUserAndFoodNew() {
    // 获取食物相关信息
    List<Food> foodList = foodService.getFoodAllNew();

    // 创建一个用户对象
    User user = new User();
    user.setUserId("002");
    user.setUserName("大猪妹妹");
    user.setUserAge("18");
    user.setFoodList(foodList);

    return user;
  }
}

在这里插入图片描述

package com.kd.opt.controller;

import com.kd.opt.entity.User;
import com.kd.opt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

  // 引入用户业务层（依赖注入）
  @Autowired
  private UserService userService;

  @RequestMapping(value = "/getUserAndFood",method = RequestMethod.GET)
  public User getUserAndFood(){
    return userService.getUserAndFood();
  }

  @RequestMapping(value = "/getUserAndFoodNew",method = RequestMethod.GET)
  public User getUserAndFoodNew(){
    return userService.getUserAndFoodNew();
  }

}

package com.kd.opt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
// 引入consumer.xml文件
@ImportResource(locations = "classpath:consumer.xml")
public class BootConsumerApplication {

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

防止踩坑1（启动项目后不报错 ,但是最后一行信息一直是[Dubbo] Current Spring Boot Application is await…）：
在这里插入图片描述
发生的原因可能是pom.xml中缺少Springboot的相关依赖：

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

加入后成功：
在这里插入图片描述
防止踩坑2（没有启动dubbo Simple Monitor监控中心，发生报错）：

2.使用注解API的方式进行整合

Provider.java（生产者）相关配置信息：

package com.kd.opt.config;

import com.alibaba.dubbo.config.*;
import com.kd.opt.service.FoodService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 使用注解API的方式，将每一个组件手动创建到容器中（生产者）
 *
 * @author 小辰哥哥
 */
@Configuration
public class Provider {

  // 依赖注入实现类1
  @Resource(name = "foodServiceImpl")
  private FoodService foodService1;

  // 依赖注入实现类2
  @Resource(name = "foodServiceImpl2")
  private FoodService foodService2;

  /**
   * 对应xml中dubbo:application标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ApplicationConfig applicationConfig(){

    // 创建一个新对象
    ApplicationConfig applicationConfig = new ApplicationConfig();

    // 1:指定当前服务/应用的名字（同样的服务名字相同，不要和别的服务同名）
    applicationConfig.setName("boot-provider");
    return applicationConfig;
  }

  /**
   * 对应xml中dubbo:registry标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public RegistryConfig registryConfig(){

    // 创建一个新对象
    RegistryConfig registryConfig = new RegistryConfig();

    // 2:指定注册中心的位置、启动时检查
    registryConfig.setAddress("127.0.0.1:2181");
    registryConfig.setProtocol("zookeeper");
    registryConfig.setCheck(true);
    return registryConfig;
  }

  /**
   * 对应xml中dubbo:protocol标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ProtocolConfig protocolConfig(){

    // 创建一个新对象
    ProtocolConfig protocolConfig = new ProtocolConfig();

    // 3:指定通信规则（通信协议?通信端口）
    protocolConfig.setPort(20880);
    protocolConfig.setName("dubbo");
    return protocolConfig;
  }

  /**
   * 对应xml中dubbo:service与dubbo:method标签（foodServiceImpl实现类）
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ServiceConfig<FoodService> serviceConfig1(){

    // 创建一个新对象
    ServiceConfig<FoodService> serviceConfig = new ServiceConfig<>();

    // 4:声明需要暴露的服务接口 ref:指向服务的真正的实现对象、超时、重试次数、多版本
    serviceConfig.setInterface(FoodService.class);
    serviceConfig.setRef(foodService1);
    serviceConfig.setTimeout(6000);
    serviceConfig.setRetries(3);
    serviceConfig.setVersion("1.0.0");

    // 配置提供者方法一（foodServiceImpl实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig1 = new MethodConfig();
    methodConfig1.setName("getFoodAll");
    methodConfig1.setTimeout(6000);
    methodConfig1.setRetries(3);

    // 配置提供者方法二（foodServiceImpl实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig2 = new MethodConfig();
    methodConfig2.setName("getFoodAllNew");
    methodConfig2.setTimeout(6000);
    methodConfig2.setRetries(3);

    // 首先创建一个List集合存放多个方法
    List<MethodConfig> methods = new ArrayList<>();
    methods.add(methodConfig1);
    methods.add(methodConfig2);

    // 将methodConfig的设置关联到serviceConfig中
    serviceConfig.setMethods(methods);

    // 暴露及注册服务（必须填写，否则消费者找不到生产者）
    serviceConfig.setApplication(applicationConfig());
    serviceConfig.setRegistry(registryConfig());
    serviceConfig.setProtocol(protocolConfig());
    serviceConfig.export();

    return serviceConfig;
  }

  /**
   * 对应xml中dubbo:service与dubbo:method标签（foodServiceImpl2实现类）
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ServiceConfig<FoodService> serviceConfig2(){

    // 创建一个新对象
    ServiceConfig<FoodService> serviceConfig = new ServiceConfig<>();

    // 5:配置多版本
    serviceConfig.setInterface(FoodService.class);
    serviceConfig.setRef(foodService2);
    serviceConfig.setTimeout(6000);
    serviceConfig.setRetries(3);
    serviceConfig.setVersion("2.0.0");

    // 配置提供者方法一（foodServiceImpl2实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig3 = new MethodConfig();
    methodConfig3.setName("getFoodAll");
    methodConfig3.setTimeout(6000);
    methodConfig3.setRetries(3);

    // 配置提供者方法二（foodServiceImpl2实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig4 = new MethodConfig();
    methodConfig4.setName("getFoodAllNew");
    methodConfig4.setTimeout(6000);
    methodConfig4.setRetries(3);

    // 首先创建一个List集合存放多个方法
    List<MethodConfig> methods = new ArrayList<>();
    methods.add(methodConfig3);
    methods.add(methodConfig4);

    // 将methodConfig的设置关联到serviceConfig中
    serviceConfig.setMethods(methods);

    // 暴露及注册服务（必须填写，否则消费者找不到生产者）
    serviceConfig.setApplication(applicationConfig());
    serviceConfig.setRegistry(registryConfig());
    serviceConfig.setProtocol(protocolConfig());
    serviceConfig.export();

    return serviceConfig;
  }

  /**
   * 对应xml中dubbo:monitor标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public MonitorConfig monitorConfig(){

    // 创建一个新对象
    MonitorConfig monitorConfig = new MonitorConfig();

    // 6:监控中心配置（自动发现）
    monitorConfig.setProtocol("registry");
    return monitorConfig;
  }

  /**
   * 对应xml中dubbo:provider标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ProviderConfig providerConfig(){

    // 创建一个新对象
    ProviderConfig providerConfig = new ProviderConfig();

    // 7:配置当前提供者的统一规则，全部服务超时属性，全部服务重试次数
    providerConfig.setTimeout(6000);
    providerConfig.setRetries(3);

    return providerConfig;
  }
}

Consumer.java（消费者）相关配置信息：

package com.kd.opt.config;

import com.alibaba.dubbo.config.*;
import com.kd.opt.service.FoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * 使用注解API的方式，将每一个组件手动创建到容器中（消费者）
 *
 * @author 小辰哥哥
 */
@Configuration
public class Consumer {

  // 日志打印
  private static final Logger LOGGER = LoggerFactory.getLogger(Consumer.class);

  /**
   * 对应xml中dubbo:application标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ApplicationConfig applicationConfig(){

    // 创建一个新对象
    ApplicationConfig applicationConfig = new ApplicationConfig();

    // 1:指定当前服务/应用的名字（同样的服务名字相同，不要和别的服务同名）
    applicationConfig.setName("boot-consumer");
    return applicationConfig;
  }

  /**
   * 对应xml中dubbo:registry标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public RegistryConfig registryConfig(){

    // 创建一个新对象
    RegistryConfig registryConfig = new RegistryConfig();

    // 2:指定注册中心的位置、启动时检查
    registryConfig.setAddress("127.0.0.1:2181");
    registryConfig.setProtocol("zookeeper");
    registryConfig.setCheck(true);
    return registryConfig;
  }

  /**
   * 对应xml中dubbo:reference与dubbo:method标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ReferenceConfig<FoodService> referenceConfig(){

    // 创建一个新对象
    ReferenceConfig<FoodService> referenceConfig = new ReferenceConfig<>();

    // 3:声明需要调用的远程服务的接口，生成远程服务代理、启动时检查、超时、重试次数、多版本、本地存根
    referenceConfig.setInterface(FoodService.class);
    referenceConfig.setCheck(true);
    referenceConfig.setTimeout(6000);
    referenceConfig.setRetries(3);
    referenceConfig.setVersion("2.0.0");
    referenceConfig.setStub("com.kd.opt.service.impl.FoodServiceImpl3");

    // 配置消费者调用提供者的方法一（foodServiceImpl实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig1 = new MethodConfig();
    methodConfig1.setName("getFoodAll");
    methodConfig1.setTimeout(6000);
    methodConfig1.setRetries(3);

    // 配置消费者调用提供者的方法二（foodServiceImpl实现类）、单个方法超时、单个方法重试次数
    MethodConfig methodConfig2 = new MethodConfig();
    methodConfig2.setName("getFoodAllNew");
    methodConfig2.setTimeout(6000);
    methodConfig2.setRetries(3);

    // 首先创建一个List集合存放多个方法
    List<MethodConfig> methods = new ArrayList<>();
    methods.add(methodConfig1);
    methods.add(methodConfig2);

    // 将methodConfig的设置关联到referenceConfig中
    referenceConfig.setMethods(methods);

    // 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用
    referenceConfig.setApplication(applicationConfig());
    referenceConfig.setRegistry(registryConfig());
    FoodService foodService = referenceConfig.get();

    LOGGER.debug("获取foodService相关数据："+foodService.getFoodAll());

    return referenceConfig;
  }

  /**
   * 对应xml中dubbo:monitor标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public MonitorConfig monitorConfig(){

    // 创建一个新对象
    MonitorConfig monitorConfig = new MonitorConfig();

    // 4:监控中心配置（自动发现）
    monitorConfig.setProtocol("registry");
    return monitorConfig;
  }

  /**
   * 对应xml中dubbo:consumer标签
   *
   * @author 小辰哥哥
   * @return
   */
  @Bean
  public ConsumerConfig consumerConfig(){

    // 创建一个新对象
    ConsumerConfig consumerConfig = new ConsumerConfig();

    // 5:配置当前消费者的统一规则，全部服务启动时检查，全部服务超时属性，全部服务重试次数，全部服务多版本，全部服务本地存根
    consumerConfig.setCheck(true);
    consumerConfig.setTimeout(6000);
    consumerConfig.setRetries(3);
    consumerConfig.setVersion("2.0.0");
    consumerConfig.setStub("com.kd.opt.service.impl.FoodServiceImpl3");

    return consumerConfig;
  }
}

boot-interface-all 项目结构（没变化，参考XML配置的方式整合）：
在这里插入图片描述
boot-provider 项目结构：

代码更新如下：

# 日志级别设置
logging:
  level:
    root: info # 最基础的日志输出级别
    com.kd.opt: debug  # 指定包下的日志输出级别
    org.springframework.web: debug # 指定类下的日志输出级别

# 端口号和上下文路径
server:
  port: 8088
  servlet:
    context-path: /boot-provider

package com.kd.opt.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.kd.opt.entity.Food;
import com.kd.opt.service.FoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * 实现FoodService接口
 *
 * @author 小辰哥哥
 */

// 暴露服务（注意是com.alibaba.dubbo包下面的）
@Service

// 之前的@Service（spring家的）可以用@Component代替
@Component
public class FoodServiceImpl implements FoodService {

  // 打印日志
  private static final Logger LOGGER = LoggerFactory.getLogger(FoodServiceImpl.class);

  @Override
  public List<Food> getFoodAll() {

    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("1","蓝色妖姬"));
    foodList.add(new Food("2","骨肉相连"));
    foodList.add(new Food("3","螺蛳粉"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }

  @Override
  public List<Food> getFoodAllNew() {
    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("7","炸鸡"));
    foodList.add(new Food("8","火锅"));
    foodList.add(new Food("9","过桥米线"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }
}

package com.kd.opt.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.kd.opt.entity.Food;
import com.kd.opt.service.FoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * 实现FoodService接口
 *
 * @author 小辰哥哥
 */

// 暴露服务（注意是com.alibaba.dubbo包下面的）
@Service

// 之前的@Service（spring家的）可以用@Component代替
@Component
public class FoodServiceImpl2 implements FoodService {

  // 打印日志
  private static final Logger LOGGER = LoggerFactory.getLogger(FoodServiceImpl2.class);

  @Override
  public List<Food> getFoodAll() {

    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("4","麻辣烫"));
    foodList.add(new Food("5","土豆粉"));
    foodList.add(new Food("6","冷面"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }

  @Override
  public List<Food> getFoodAllNew() {
    // 创建一个ArrayList集合模拟数据库
    List<Food> foodList = new ArrayList<>();
    foodList.add(new Food("10","黄焖鸡"));
    foodList.add(new Food("11","烤鸭"));
    foodList.add(new Food("12","干豆腐"));


    // 测试Dubbo超时属性（睡眠5秒）
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    LOGGER.debug("调用完成");

    return foodList;
  }
}

package com.kd.opt;

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

@SpringBootApplication

// 指定Dubbo扫描路径
@EnableDubbo(scanBasePackages = "com.kd.opt")
public class BootProviderApplication {

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

}

boot-consumer 项目结构：
在这里插入图片描述
代码更新如下：

# 日志级别设置
logging:
  level:
    root: info # 最基础的日志输出级别
    com.kd.opt: debug  # 指定包下的日志输出级别
    org.springframework.web: debug # 指定类下的日志输出级别

package com.kd.opt.service.impl;

import com.alibaba.dubbo.config.annotation.Reference;
import com.kd.opt.entity.Food;
import com.kd.opt.entity.User;
import com.kd.opt.service.FoodService;
import com.kd.opt.service.UserService;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 实现UserService接口
 *
 * @author 小辰哥哥
 */
// org.springframework.stereotype.Service（Spring家的）
@Service
public class UserServiceImpl implements UserService {

  // 引入食物业务层（依赖注入）
  // 不在使用@Autowired注解
  @Reference
  private FoodService foodService;

  @Override
  public User getUserAndFood() {

    // 获取食物相关信息
    List<Food> foodList = foodService.getFoodAll();

    // 创建一个用户对象
    User user = new User();
    user.setUserId("001");
    user.setUserName("小辰哥哥");
    user.setUserAge("18");
    user.setFoodList(foodList);

    return user;
  }

  @Override
  public User getUserAndFoodNew() {
    // 获取食物相关信息
    List<Food> foodList = foodService.getFoodAllNew();

    // 创建一个用户对象
    User user = new User();
    user.setUserId("002");
    user.setUserName("大猪妹妹");
    user.setUserAge("18");
    user.setFoodList(foodList);

    return user;
  }
}

package com.kd.opt;

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

@SpringBootApplication

// 指定Dubbo扫描路径
@EnableDubbo(scanBasePackages = "com.kd.opt")
public class BootConsumerApplication {

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

}

总结

每天一个提升小技巧！！！

小辰哥哥

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
4
评论
Apache Dubbo 框架的使用（五）

Springboot_Dubbo_Zookeeper整合的三种方式三种方式如下：1：在application.yml中配置属性，@Service【暴露服务】，@Reference【引用服务】，@EnableDubbo【开启基于注解的dubbo功能】（详情请见Apache Dubbo 框架的使用（三、四））2：保留provider.xml、consumer.xml配置文件（需要注释application.yml相关dubbo配置属性），使用@ImportResource导入dubbo的配置文件即可3：
复制链接

扫一扫