Dubbo-04 20190317

版权声明：本文为博主原创文章，未经博主允许不得转载,如需转载请在明显处标明出处！ https://blog.csdn.net/qq_36291682/article/details/88600777

SpringBoot使用dubbo
1. idea没问题可以直接创建 如果使用eclipse 需要安装spring插件
1 ）查看eclipse版本 Help->About Eclipse IDE

2 )找插件地址 4.9与eclispe匹配
https://spring.io/tools3/sts/all

3 ）Eclipse安装
Help->Install New SoftWare





**2. 创建SpringBoot项目 provider **
1 )pom文件 需要引入jar包 和之前的userService接口

<?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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.3.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.test</groupId>
	<artifactId>boot-user-service-provider</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>boot-user-service-provider</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-boot.version>2.1.1.RELEASE</spring-boot.version>
		<dubbo.version>2.7.0</dubbo.version>
	</properties>

	<dependencies>
		<dependency>
			<!--common的pom.xml 开头就是这个配置 直接复制过来groupId artifactId version -->
			<groupId>com.test.mall</groupId>
			<artifactId>mall-common</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<!--  springboot-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>
		
		
		<!-- Dubbo Spring Boot Starter -->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>2.7.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo</artifactId>
			<version>${dubbo.version}</version>
		</dependency>

			
		 <!-- Zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
              <version>2.12.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
              <version>2.12.0</version>
        </dependency>

	</dependencies>

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

</project>

2 ) Service

package com.test.mall.service.impl;
import java.util.Arrays;
import java.util.List;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

import com.test.mall.bean.UserAddress;
import com.test.mall.service.UserService;
/**
 * 接口的实现类 负责提供所需数据
 * 
 * @author LM
 *
 */
@Service // 为了暴露服务 这个service不是spring的 是dubbo家的
@Component
public class UserServiceImpl implements UserService {

	public List<UserAddress> getUserAddressList(String userId) {
		UserAddress address1 = new UserAddress(1, "沙河高教園", "1", "李老师", "010-88888888", "Y");
		UserAddress address2 = new UserAddress(2, "沙河", "1", "王老师", "010-66666666", "N");
		return Arrays.asList(address1, address2);
	}
}

3 )配置文件

#名称
dubbo.application.name=user-service-provider
#注册中心
dubbo.registry.address=127.0.0.1:2181
dubbo.registry.protocol=zookeeper
#通信协议
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
#监控中心
dubbo.monitor.protocol=registry
dubbo.scan.base-packages=com.test.mall.service.impl

4 )启动 我用的是dubbo2.7 这个启动类里边不需要开启EnableDubbo注解 在配置文件写dubbo.scan.base-packages=com.test.mall.service.impl

package com.test.mall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//@EnableDubbo
@SpringBootApplication
public class BootUserServiceProviderApplication {
	public static void main(String[] args) {
		SpringApplication.run(BootUserServiceProviderApplication.class, args);
	}

}

5 ） 启动 查看dubbo admin 管理页

2. 创建SpringBoot项目 consumer web项目
1 ）




2 ）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 http://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.1.3.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.test</groupId>
	<artifactId>boot-user-service-consumer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>boot-user-service-consumer</name>
	<description>Demo project for Spring Boot</description>

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

	<dependencies>
		<dependency>
			<!--common的pom.xml 开头就是这个配置 直接复制过来groupId artifactId version -->
			<groupId>com.test.mall</groupId>
			<artifactId>mall-common</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<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>
		</dependency>

		<!-- Dubbo Spring Boot Starter -->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>2.7.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo</artifactId>
			<version>${dubbo.version}</version>
		</dependency>


		<!-- Zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.4.6</version>
		</dependency>

		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>2.12.0</version>
		</dependency>

		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>2.12.0</version>
		</dependency>
	</dependencies>

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

</project>

3 ) 编写service类 和 controller类
controller:

package com.test.mall.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.test.mall.bean.UserAddress;
import com.test.mall.service.OrderService;

@Controller
public class OrderController {

	@Autowired
	OrderService OrderService;

	@ResponseBody
	@RequestMapping("/initOrder")
	public List<UserAddress> initOrder(@RequestParam("uid") String userId) {
		return OrderService.initOrder(userId);
	}
}

service: 使用dubbo的Reference注解

package com.test.mall.service.impl;

import java.util.List;

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

import com.test.mall.bean.UserAddress;
import com.test.mall.service.OrderService;
import com.test.mall.service.UserService;

@Service
public class OrderServiceImpl implements OrderService {

//	@Autowired
	@Reference
	UserService userService;

	public List<UserAddress> initOrder(String userId) {
		// 查询用户收货地址
		List<UserAddress> addList = userService.getUserAddressList(userId);
		for(UserAddress ua:addList) {
			System.out.println(ua.getUserAddress());
		}
		return addList;
	}

}

main:

package com.test.mall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BootUserServiceConsumerApplication {

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

}

4 ） 配置文件

#应用名字
dubbo.application.name=user-service-consumer

#注册中心
dubbo.registry.address=zookeeper://127.0.0.1:2181
#监控中心 去注册中心找
dubbo.monitor.protocol=registry

server.port=8082

5 ）访问页面

3. dubbo属性加载顺序
从上到下 优先级降低

-D 是虚拟机参数 启动项目的时候后边跟的参数

xml就相当于springboot中的application.properties

dubbo.propertie主要配置一些公共配置 如果其他地方不配合的话 他就会起作用

以 timeout 为例（默认超时是1000毫秒），下图显示了配置的查找顺序，其它 retries, loadbalance, actives 等类似：

- 方法级优先，接口级次之，全局配置再次之。!!!
- 如果级别一样，则消费方优先，提供方次之。！
其中，服务提供方配置，通过 URL 经由注册中心传递给消费方。
从上到下 优先级逐渐降低
这里有一个方法级别的配置 方法优先

（建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置）。

4. dubbo 启动检查
http://dubbo.apache.org/zh-cn/docs/user/demos/preflight-check.html
Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题**，默认 check=“true”。**

可以通过 **check="false"** 关闭检查，比如，测试时，有些服务不关心，或者出现了循环依赖，必须有一方先启动。

另外，如果你的 Spring 容器是懒加载的，或者通过 API 编程延迟引用服务，请关闭 check，否则服务临时不可用时，会抛出异常，拿到 null 引用，如果 check="false"，总是会返回引用，当服务恢复时，能自动连上。 

单个设置 关闭某个服务的启动时检查 (没有提供者时报错)：

<dubbo:reference interface="com.foo.BarService" check="false" />

统一设置 关闭所有服务的启动时检查 (没有提供者时报错)：

<dubbo:consumer check="false" />

关闭注册中心启动时检查 (注册订阅失败时报错)：

<dubbo:registry check="false" />

通过 dubbo.properties
dubbo.reference.com.foo.BarService.check=false
dubbo.reference.check=false
dubbo.consumer.check=false
dubbo.registry.check=false
通过 -D 参数
java -Ddubbo.reference.com.foo.BarService.check=false
java -Ddubbo.reference.check=false
java -Ddubbo.consumer.check=false 
java -Ddubbo.registry.check=false

配置的含义
dubbo.reference.check=false，强制改变所有 reference 的 check 值，就算配置中有声明，也会被覆盖。

dubbo.consumer.check=false，是设置 check 的缺省值，如果配置中有显式的声明，如：<dubbo:reference check="true"/>，不会受影响。

dubbo.registry.check=false，前面两个都是指订阅成功，但提供者列表是否为空是否报错，如果注册订阅失败时，也允许启动，需使用此选项，将在后台定时重试。

这些配置参考手册：
http://dubbo.apache.org/zh-cn/docs/user/quick-start.html

知识点：
timeout :
方法调用超时时间(毫秒) 调优的时候使用 默认1000毫秒
retries：
远程服务调用重试次数，不包括第一次调用，不需要重试请设为0 配合timeout使用 也是性能调优的时候使用 如果调用provider1是吧 可能会再去尝试连接provider2 provider3 等 这与loadbalance 负载均衡策略有关系

注意：这个重试次数 要在服务符合幂等性的情况下才能使用多次 幂等性就是你操作1次和操作2次的结果是一样的 比如查询/修改/删除 数据 查询一次 和查询2次 结果都是一样的（当然不能考虑中间有数据新增的情况 没这个必要） 但是修改或者新增就不一样了，你新增第一次更新了某些字段，然后服务端由于某些原因超时了，但是这些新增已经起作用了，客户端傻呀，它不知道你已经新增完成了，它只知道你没有按时返回，他就又去调用你，你又进行新增 这就不对了 ~~ 这就不是幂等了
loadbalance：
负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮询，最少活跃调用
随机就是那个随机 不一定下一个是谁
轮训就是1 2 3 1 2 3 这样
最少活跃调用就是谁被用的少就去用谁

5. dubbo 多版本 灰度发布
当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。

可以按照以下的步骤进行版本迁移：

1 ） 在低压力时间段，先升级一半提供者为新版本
2 ）再将所有消费者升级为新版本
3 ）然后将剩下的一半提供者升级为新版本
老版本服务提供者配置：

<dubbo:service interface="com.foo.BarService" version="1.0.0" />

新版本服务提供者配置：

<dubbo:service interface="com.foo.BarService" version="2.0.0" />

老版本服务消费者配置：

<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0" />

新版本服务消费者配置：

<dubbo:reference id="barService" interface="com.foo.BarService" version="2.0.0" />

如果不需要区分版本，可以按照以下的方式配置 [1]：

<dubbo:reference id="barService" interface="com.foo.BarService" version="*" />

6. dubbo 本地存根
http://dubbo.apache.org/zh-cn/docs/user/demos/local-stub.html
远程服务后，客户端通常只剩下接口，而实现全在服务器端，但提供方有些时候想在客户端也执行部分逻辑，比如：做 ThreadLocal 缓存，提前验证参数，调用失败后伪造容错数据等等，此时就需要在 API 中带上 Stub，客户端生成 Proxy 实例，会把 Proxy 通过构造函数传给 Stub [1]，然后把 Stub 暴露给用户，Stub 可以决定要不要去调 Proxy。

在 spring 配置文件中按以下方式配置：

<dubbo:service interface="com.foo.BarService" stub="true" />

或

<dubbo:service interface="com.foo.BarService" stub="com.foo.BarServiceStub" />

//提供 Stub 的实现 [2]：

package com.foo;
public class BarServiceStub implements BarService { 
    private final BarService barService;
    
    // 构造函数传入真正的远程代理对象
    public (BarService barService) {
        this.barService = barService;
    }
 
    public String sayHello(String name) {
        // 此代码在客户端执行, 你可以在客户端做ThreadLocal本地缓存，或预先验证参数是否合法，等等
        try {
            return barService.sayHello(name);
        } catch (Exception e) {
            // 你可以容错，可以做任何AOP拦截事项
            return "容错数据";
        }
    }
} 

**6. dubbo 与SpringBoot **
一些属性比如timeout retries 之类的 直接在Service/Refrence 注解里边配置属性就行了

@Service(timeout=3000 ,retries= 10) // 为了暴露服务 这个service不是spring的 是dubbo家的
	@Component
	public class UserServiceImpl implements UserService {
	
		public List<UserAddress> getUserAddressList(String userId) {
			UserAddress address1 = new UserAddress(1, "沙河高教園", "1", "李老师", "010-88888888", "Y");
			UserAddress address2 = new UserAddress(2, "沙河", "1", "王老师", "010-66666666", "N");
			return Arrays.asList(address1, address2);
		}
	}

注解没办法作用到method上 ：
方法级别配置1：
保留buddo的配置文件 然后导入配置 也就不用注解什么的了

@ImportResource("classpath:provider.xml")
@SpringBootApplication
public class BootUserServiceProviderApplication {

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

}

方法级别配置2：

使用注解API方式 自定义confuguration 每一个标签都有对应的config

package com.test.mall.config;

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

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.MethodConfig;
import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.test.mall.service.UserService;

@Configuration
public class MyDubboConfig {

	//dubbo.application.name=user-service-provider
	@Bean 
	public ApplicationConfig applicationConfig() {
		ApplicationConfig applicationConfig = new ApplicationConfig();
		applicationConfig.setName("boot-user-service-provider");
		return applicationConfig;
	}
	
	//<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
	//dubbo.registry.address=127.0.0.1:2181  	dubbo.registry.protocol=zookeeper
	@Bean
	public RegistryConfig registryConfig() {
		RegistryConfig registryConfig = new RegistryConfig();
		registryConfig.setProtocol("zookeeper");
		registryConfig.setAddress("127.0.0.1:2181");
		return registryConfig;
	}
	
	//<dubbo:protocol name="dubbo" port="20882"></dubbo:protocol>
	//dubbo.protocol.name=dubbo   	dubbo.protocol.port=20880
	@Bean
	public ProtocolConfig protocolConfig() {
		ProtocolConfig protocolConfig = new ProtocolConfig();
		protocolConfig.setName("dubbo");
		protocolConfig.setPort(20882);
		return protocolConfig;
	}
	
	/**
	 *<dubbo:service interface="com.test.mall.service.UserService" 
		ref="userServiceImpl01" timeout="1000" version="1.0.0">
		<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
	</dubbo:service>
	
	   @Service注解
	 */
	@Bean
	public ServiceConfig<UserService> userServiceConfig(UserService userService){
		ServiceConfig<UserService> serviceConfig = new ServiceConfig<>();
//		serviceConfig.setInterface("com.test.mall.service.UserService");
		serviceConfig.setInterface(UserService.class);
		serviceConfig.setRef(userService);
		serviceConfig.setVersion("1.0.0");
		
		//配置每一个method的信息  
		MethodConfig methodConfig = new MethodConfig();
		methodConfig.setName("getUserAddressList");
		methodConfig.setTimeout(1000);
		
		//将method的设置关联到service配置中
		List<MethodConfig> methods = new ArrayList<>();
		methods.add(methodConfig);
		serviceConfig.setMethods(methods);
		
		//ProviderConfig
		//MonitorConfig
		
		return serviceConfig;
	}
}

@EnableDubbo(scanBasePackages = "com.test.mall")
public class BootUserServiceProviderApplication {
	public static void main(String[] args) {
		SpringApplication.run(BootUserServiceProviderApplication.class, args);
	}
}