Dubbo

1、Dubbo基础知识

1、什么是分布式系统？

分布式系统是若干个独立计算机的集合，这些计算机对于用户来说就像单个相关系统。分布式系统是建立在网络之上的软件系统。

2、分布式的发展演练

3、RPC

简单的理解就是，RPC是指远程过程调用，也就是说两台服务器A,B,一个应用部署在A服务器上，想要调用B服务器上应用提供的函数或方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。

RPC两个核心模块：通讯，序列化

2、Dubbo

Dubbo是一款高性能、轻量级的开源RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

基本概念：

服务提供者（Provider）:暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

注册中心（Registry）:注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

监控中心（Monitor):服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

下面罗列一些Dubbo常用的，也就是说每个项目的Dubbo的Xml文件中基本都会出现的标签，并以表格的形式列举标签中常见的可用属性：

<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface="com.test.UserServiceBo" ref="userService" version="1.0.0" timeout="3000"/>

<!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
<dubbo:reference id="userService" interface="com.test.UserServiceBo" version="1.0.0" timeout="3000"/>

<!-- 用dubbo协议在20880端口暴露服务 -->
<dubbo:protocol name="dubbo" port="20880" />

<!-- 使用zookeeper注册中心暴露服务地址 -->
<dubbo:registry address="zookeeper://127.0.0.1:2181" />

Dubbo配置的覆盖规则：

方法配置级别优于接口级别
Consumer端配置优于Provider配置优于全局配置
最后是Dubbo Hard Code的配置值

2.1、使用dubbo+zookeeper整合springboot创建提供者、消费者案列:

提供者：

首先导入相关的依赖jar包

<dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
        <!--<dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</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>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.14</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-log4j12</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

这里有个版本配合，dubbo的版本在25之间使用zkClient的jar包，2.5之后使用curator依赖包。

然后在properties中配置

#要注册的服务名
dubbo.application.name=provider-server
#注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#扫描包下要被注册的服务
dubbo.scan.base-packages=com.hao.service

编写实现类

@Service  //注意：这里使用的是dubbo下的service注解
@Component  //让其被扫描到，放到IOC容器中去
public class BuyTicketImpl implements BuyTicket {
    @Override
    public String buyTicket() {
      return "快点买票啊，不然就回不去了";
    }
}

这样就可以在监控中心可以看到该提供者了

消费者：

首先跟提供者一样导入一样的jar包，跟上面一样

其次就在配置文件中配置消费者信息

#消费者名字
dubbo.application.name=consumer-server
#注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

然后就是使用了，首先先创建一个跟提供者一样包路径的接口，再生成相应的实现类

@Controller
@Service  //注意：这里使用的是springmvc中的service注解
public class UserService {
    @Reference
    BuyTicket buyTicket;
    @RequestMapping("/dd")
    @ResponseBody
    public String buyTicket(){
        String s = buyTicket.buyTicket();
        return s;
    }
}

这样消费者就可以通过dubbo+zookeeper拿到不同服务器上的服务了。这个是基于springboot做的。

下面是基于spring项目搭建的

提供者：

  <dependencies>
        <!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.4</version>
            <scope>compile</scope>
        </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>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.14</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-log4j12</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

<?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:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
		 http://code.alibabatech.com/schema/dubbo
		 http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <dubbo:application name="DubboDemo-Provider"/>
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <dubbo:protocol name="dubbo" port="20880"/>
    <bean id="UserServiceImpl" class="com.hao.service.UserServiceImpl"/>

    <dubbo:service interface="com.hao.service.UserService" ref="UserServiceImpl"/>

</beans>

//提供者启动类
public class test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo-provider.xml"); //通过读取配置文件获取容器
        context.start(); 
        System.out.println("提供者服务已注册成功");
        try {
            System.in.read();  //让该程序一直执行下去，不会停止
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在启动的时候可能会报日志冲突的问题：需要自己在resource文件夹下添加log4j.properties文件

###set log levels###
log4j.rootLogger=info, stdout
###output to the console###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%d{dd/MM/yy HH:mm:ss:SSS z}] %t %5p %c{2}: %m%n

消费者：

消费者这里也要创建一个和提供者一样的接口。

public interface UserService {
    String say();
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       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">

    <dubbo:application name="dubboDemo-consumer"/>

    <!-- 使用预发 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <dubbo:reference interface="com.hao.service.UserService" id="user"/>

</beans>

public class test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo-consumer.xml"); //也是通过读取配置文件获取容器，再通过容器获取指定的接口实现类
        context.start();
        UserService user = context.getBean("user", UserService.class);
        System.out.println("执行前");
        String say = user.say();
        System.out.println(say);  //这里注意：消费者只能获取到提供者接口实现类中return的值，方法具体中具体的实现获取不了。
        System.out.println("执行后");
        try {
            System.in.read();  //让程序一直运行下去。
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

zookeeper宕机与dubbo直连

现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务。

原因：

监控中心宕机后不影响使用，只是丢失部分采样数据。
数据库宕机后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务。
注册中心对等集群，任意一台宕机后，将自动切换到另一台。
注册中心全部宕机后，服务提供者和服务消费者仍能通过本地缓存通讯。
服务提供者无状态，任意一台宕机后，不影响使用。
服务提供者全部宕机后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复。

集群下dubbo负载均衡配置

在集群负载均衡是，dubbo提供了多种均衡策略，默认为random随机调用。

负载均衡策略：Random(随机）、RoundRobin（循环）、LeastActive（最少调用）、ConsistentHash（一致性）

服务降级

当服务器压力剧增的情况下，根据实际业务员情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

其中：

mock=force:return+null表示消费方对该服务的方法调用都直接返回null值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
mock=fail：return+null表示消费方对该服务的方法调用在失败后，再返回null值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

集群容错模式

Failover Cluster：失败自动切换，当出现失败时，重试其它服务器。

Failfast Cluster:快速失败，只发起一次调用，失败立即报错。

Failback Cluster：失败自动恢复，后代记录失败请求，定时重发。

Forking Cluster：并行调用多个服务器，只要一个成功即返回。

Broadcast Cluster：广播调用所有提供者，逐个调用，任意一台报错则报错。

3、Dubbo原理

RPC原理

一次完整的RPC调用流程（同步调用，异步另说）如下：
1）服务消费方（client）调用以本地调用方式调用服务；
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
3）client stub找到服务地址，并将消息发送到服务端；
4）server stub收到消息后进行解码；
5）server stub根据解码结果调用本地的服务；
6）本地服务执行并将结果返回给server stub；
7）server stub将返回结果打包成消息并发送至消费方；
8）client stub接收到消息，并进行解码；
9）服务消费方得到最终结果。
RPC框架的目标就是要2~8这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

Netty通信原理

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。

Selector 一般称为选择器，也可以翻译为多路复用器，Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）

Netty基本原理

Dubbo原理（框架设计）

config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient,ExchangeServer
transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool

dubbo原理（启动解析、加载配置信息）

dubbo原理（服务暴露）

dubbo原理（服务引用）

dubbo原理（服务调用）