Dubbo基础知识

集群架构演变：
ORM 一个应用发布在一个服务器上
MVC 将应用切割成几个互不相干的小应用，每个小应用独立发布在同一服务器上
RPC [ Remote Procedure Call]是指远程过程调用，A服务器调用B服务器上应用提供的方法
SOA 在分布式应用架构的基础上增加了一个调度、治理中心基于访问压力实时管理集群容量、提高集群的利用率

Dubbo三大核心能力：面向接口代理的高性能RPC调用，智能容错和负载均衡，服务自动注册和发现

RPC工作原理：略
RPC调用的两种方式：同步/异步
dubbo设计架构：略

环境搭建：
一：Zookeeper注册中心
1、下载zookeeper
网址 https://archive.apache.org/dist/zookeeper/
2、解压zookeeper
解压运行zkServer.cmd ，初次运行会报错，没有zoo.cfg配置文件
3、修改zoo.cfg配置文件
将conf下的zoo_sample.cfg复制一份改名为zoo.cfg即可。
注意几个重要位置：
dataDir=../data   临时数据存储的目录（可写相对路径）
clientPort=2181   zookeeper的端口号
修改完成后再次启动zookeeper
4、使用zkCli.cmd测试
ls /：列出zookeeper根下保存的所有节点
create –e /test 123：创建一个test节点，值为123
get /test：获取/test节点的值

二：dubbo-admin 管理控制台(不装也不影响)
一个spring boot application，能够连接到zookeeper,让用户更好的可视化管理监控众多的dubbo服务
1、下载https://github.com/apache/incubator-dubbo-ops 
2、修改dubbo-admin配置
修改 src\main\resources\application.properties 指定zookeeper地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
3、打包dubbo-admin
mvn clean package -Dmaven.test.skip=true 
4、运行dubbo-admin
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
5、访问：localhost：7001  root/root

三：创建提供者
1.pom.xml
<!-- 引入dubbo -->
<!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.6.2</version>
</dependency>
<!-- 注册中心使用的是zookeeper，引入操作zookeeper的客户端 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>2.12.0</version>
</dependency>

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

<!--2、指定注册中心的位置 -->
<dubbo:registry protocol="zookeeper" address="localhost:2181"></dubbo:registry>

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

<!-- 4、暴露服务 ref：指向服务的真正的实现对象 -->
<dubbo:service interface="com.atguigu.gmall.service.UserService" 
ref="userServiceImpl01" timeout="1000" version="1.0.0">
<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
</dubbo:service>
<!-- 服务的实现 -->
<bean id="userServiceImpl01" class="com.atguigu.gmall.service.impl.UserServiceImpl"></bean>

<!--统一设置服务提供方的规则-->
<dubbo:provider timeout="1000"></dubbo:provider>

<!-- 连接监控中心，从注册中心发现监控中心地址-->
<dubbo:monitor protocol="registry"></dubbo:monitor>

四：创建消费者
<!--订阅服务-->
<dubbo:reference interface="com.atguigu.gmall.service.UserService" 
	id="userService" timeout="5000" retries="3" version="*">
	<!-- <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method> -->
</dubbo:reference>

provider.xml文件
1.指定provider服务名
2.指定register注册中心地址，这里是zookeeper
3.暴露服务(注册服务到注册中心)
4.指定通讯协议和端口
5.连接监控中心

consumer.xml文件
1.指定consumer服务名
2.指定register注册中心地址，这里是zookeeper
3.订阅服务(订阅注册中心服务)
4.连接监控中心

五：dubbo-monitor 监控中心
主要用来统计服务的调用次数和调用时间，服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心，监控中心则使用数据绘制图表来显示 
配置dubbo.properties
打包：incubator-dubbo-ops-master\dubbo-monitor-simple>mvn package
启动：dubbo-monitor-simple-2.0.0\assembly.bin  双击start.bat启动
访问：localhost:8080

六：与springboot整合
pom.xml引入spring-boot-starter以及dubbo和curator的依赖
<dependency>
    <groupId>com.alibaba.boot</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>0.2.0</version>
</dependency>

application.properties中配置：
提供者配置：
1.指定provider服务名
2.指定register注册中心地址，这里是zookeeper
(X)3.暴露服务(注册服务到注册中心)
4.指定通讯协议和端口
5.连接监控中心

消费者配置：
1.指定consumer服务名
2.指定register注册中心地址，这里是zookeeper
(X)3.订阅服务(订阅注册中心服务)
4.连接监控中心

启动dubbo注解@EnableDubbo
暴露服务@Service (com.alibaba.dubbo.config.annotation.Service)
订阅服务@Reference

七：常用配置
1.配置优先级：JVM 启动 -D 参数优先,XML 次之,Properties 最后
2.启动时检查：默认check="true"，启动时检查依赖的服务是否可用，可以通过 check=“false” 关闭检查，比如，测试时，有些服务不关心，或者出现了循环依赖，必须有一方先启动
3.超时时间、重试次数
//全局配置
<dubbo:provider timeout="5000" />
//指定接口或特定方法配置
<dubbo:reference interface="com.atguigu.gmall.service.UserService" 
	id="userService" timeout="5000" retries="3" version="*">
	<!-- <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method> -->
</dubbo:reference>
4.配置的覆盖:
1）、精确优先 (方法级优先，接口级次之，全局配置再次之)
2）、消费方优先，提供方次之
<!-- timeout="0" 默认是1000ms-->
<!-- retries="":重试次数，不包含第一次调用，0代表不重试-->
<!-- 幂等（设置重试次数）【查询、删除、修改】、非幂等（不能设置重试次数）【新增】 -->
5.多版本：实现新旧版本平缓过渡，实现灰度发布
1)服务提供者：
<dubbo:service interface="com.atguigu.gmall.service.UserService" 
ref="userServiceImpl01" timeout="1000" version="1.0.0">
<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
</dubbo:service>
<!-- 服务的实现01 -->
<bean id="userServiceImpl01" class="com.atguigu.gmall.service.impl.UserServiceImpl01"></bean>
<dubbo:service interface="com.atguigu.gmall.service.UserService" 
ref="userServiceImpl01" timeout="1000" version="2.0.0">
<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
</dubbo:service>
<!-- 服务的实现02 -->
<bean id="userServiceImpl02" class="com.atguigu.gmall.service.impl.UserServiceImpl02"></bean>
2)服务消费者：
<!--version属性指定引用的版本号，可以是具体版本号，可以指定为*代表随机版本号-->
<dubbo:reference interface="com.atguigu.gmall.service.UserService" 
	id="userService" timeout="5000" retries="3" version="*">
</dubbo:reference>

6.本地存根：对服务的调用过程进行优化或者容错的处理
服务端处理：
//在消费方部署一个实现了目标接口的伪服务,在调用服务时，先走UserServiceStub,作用类似于spring aop
//Proxy 通过构造函数传给Stub，Stub 执行部分逻辑处理，决定要不要去调Proxy
@Reference(stub = "com.atguigu.gmall.service.UserServiceStub")
private UserService userService;

dubbo-interface开发服务对应的本地存根：
public class UserServiceStub implements UserService {

    private final UserService userService;

	//构造函数传入真正的远程代理对象
    public UserServiceStub(UserService userService) {
        this.userService = userService;
    }

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
        if (StringUtils.isEmpty(userId)) return Arrays.asList(new UserAddress(null, "用户空", "null", "null", "null", "Y"));
        List<UserAddress> userAddressList = userService.getUserAddressList("1");
        return userAddressList;
    }
}

八：高可用
1.zookeeper宕机与dubbo直连
现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务(本地缓存),没有注册中心，可以使用直连方式使用dubbo
健壮性：
1)监控中心monitor宕掉不影响使用，只是丢失部分采样数据
2)数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
3)注册中心对等集群，任意一台宕掉后，将自动切换到另一台
4)注册中心全部宕掉后，服务提供者和服务消费者仍能通过<本地缓存>通讯
5)服务提供者无状态，任意一台宕掉后，不影响使用
6)服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

2.负载均衡
Random LoadBalance（默认）
<随机>访问服务。可按权重设置随机概率

RoundRobin LoadBalance
<轮循>访问服务。
存在慢的提供者累积请求的问题

LeastActive LoadBalance
最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大

ConsistentHash LoadBalance
一致性 Hash，相同参数的请求总是发到同一提供者。
当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key="hash.arguments" value="0,1" />
缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key="hash.nodes" value="320" />

3.服务降级
解决高并发的三把利器：降级、限流、缓存
什么是服务降级？
当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务有策略的降低服务级别，以释放服务器资源，保证核心任务的正常运行

服务降级与Mock机制：
Dubbo的服务降级采用的是mock机制。其具有两种降级处理方式：
mock=force:return+null 降级处理，消费方对该服务的方法调用都直接返回 null 值，不发起远程调用
mock=fail:return+null 降级处理，消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常

dubb-adming管理界面手动配置：
第1种：管理后台点击屏蔽，即屏蔽对远程的调用，直接返回空
第2种：管理后台点击容错，即服务出现报错的情况下返回空，不报异常

3.1xml配置：
1)mocknull：在远程调用异常时，服务端直接返回null或一个固定的字符串
<dubbo:reference id="xxxService" interface="com.x..service.xxxxService" check="false" mock="return null" />
2)mockclass：在远程调用异常时，服务端根据自定义mock业务处理类进行返回
<dubbo:reference id="xxxService" interface="com.x..service.xxxxService" check="false" mock="true" />
接口服务xxxxService的目录下创建相应的mock业务处理类，同时实现业务接口xxxxService()，接口名要注意命名规范：接口名+Mock

3.2注解配置：
1)mocknull：在远程调用异常时，服务端直接返回null或一个固定的字符串
@Reference(mock="return null") @Reference(mock="return 简单值")
也支持 @Reference(mock="force:return null")
2)mockclass ：在远程调用异常时，服务端根据自定义mock业务处理类进行返回
//①.在接口的相同包中创建一个名为InterfaceName+Mock的类，该类必须实现该Interface，设置@Reference(mock = "true")
@Reference(mock = "true")
private HelloDubboService helloDubboService;

public class HelloDubboServiceMock implements HelloDubboService {
	@Override
	function xxx
}

//②.Consumer端自定义Mock类，名字随意，设置全限定名@Reference(mock = "com....xxxMock")
@Reference(
mock = "包路径.SayHelloServiceMock")
IHelloService helloService;

public class xxxMock implements IHelloService {
    @Override
    public String sayHello() {
        return "服务端发生异常，被降级了";
    }
}

3.3java代码动态向注册中心写入服务降级处理方式
RegistryFactory registryFactory = 
    ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=consumer_app&mock=force:return+null"));

4.服务容错与Hystrix
Dubbo 提供了多种容错方案，缺省默认为 failover 
Failover Cluster
失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。

Failfast Cluster
快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster
失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster
失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster
并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster
广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置
按照以下示例在服务提供方和消费方配置集群模式
<dubbo:service cluster="failsafe" />
、<dubbo:reference cluster="failsafe" />

Dubbo服务容错（整合hystrix）：
1）、在pom文件中导入依赖（服务提供者和服务消费者都需要导入）
<dependency>
	<groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>1.4.4.RELEASE</version>
</dependency>
2）、在主程序启动类上添加@EnableHystrix注解开启服务容错（服务提供者和服务消费者都需要添加）
@EnableHystrix  //开启服务容错
public class SpringbootdubboserviceproviderApplication {
3）、在服务提供者实现类中方法上添加@HystrixCommand注解
@HystrixCommand
@Override
public List<User> getList() {
4）、在服务消费者调用服务提供者的方法上添加@HystrixCommand注解并指定fallbackMethod，指定熔断后回调实现
@HystrixCommand(fallbackMethod = "test")
@ResponseBody
@RequestMapping("/users")
public List<User> getUsers(){

public List<User> test(){
        return null;
    }