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：使用注解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);
}
}
总结
每天一个提升小技巧！！！