Dubbo的实现原理即网络通信原理

Dubbo是一款高性能 Java RPC框架 。

实现了服务注册和发现 ，容错负载均衡，扩展性，基于接口的远程调用

1.Dubbo整合Spring的主要配置项

provider配置

   <!--1. 应用配置，定义服务提供者-->
    <dubbo:application name="spring-provider36"/>

    <!--2. 将服务接口的实现类对象，放入Spring中-->
    <bean id="demoService"  class="com.cskaoyan.service.DemoServiceImpl"/>

    <!--3. 服务配置，定义对外暴露的服务对象-->
    <dubbo:service interface="com.cskaoyan.api.DemoService" ref="demoService"/>

    <!--4. 协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受 -->
    <dubbo:protocol  name="dubbo" port="20880"/>

    <!--5. 注册中心-->
    <dubbo:registry address="zookeeper://localhost:2181"/>

consumer配置

    <!--1. 应用配置，定义服务消费者的名字-->
    <dubbo:application name="spring-consumer36"/>

    <!--2.引用服务配置，用于创建一个远程服务代理，一个引用可以指向多个注册中心-->
    <dubbo:reference id="demoService"  interface="com.cskaoyan.api.DemoService"/>

    <!--3. 注册中心-->
    <dubbo:registry address="zookeeper://localhost:2181"/>

2.Dubbo整合SpringBoot的配置项

服务提供者的实现和yml文件的配置

// 服务接口实现类，同时注意这里的@Service注解是Dubbo的Service注解
@Service
public class DemoServiceImpl implements DemoService {
@Override
public String sayHello(String name) {
return "0hello, " + name;
}
}

# yml配置
dubbo:
application:
name: boot-provider #配置服务提供者名称
protocol:
name: dubbo #配置服务暴露协议
port: 20880 #配置服务暴露端口号
registry:
address: zookeeper://localhost:2181 #配置服务注册中心
scan:
base-packages: com.dubbo.service # 配置Dubbo注解扫描路径

服务消费者的实现，以及配置
@Component
public class ThirdService {
// 这里通过Dubbo的@Reference注解，引用远程服务
@Reference(interfaceClass = DemoService.class, loadbalance =
"consistenthash", check = false)
DemoService demoService;
public String sayHello(Person person) {
return demoService.sayHello(person);
}
}

yml

dubbo:
application:
name: boot-consumer # 配置服务消费者名字
registry:
address: zookeeper://localhost:2181 # 配置服务注册中心

3.Dubbo的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）服务消费方得到最终结果。

4.RPC过程

1.在服务提供者进程被启动时，创建一个spring容器，容器中有两个对象，一个是服务接口实现类对象，另一个是对外暴露功能的服务对象（对上面bean容器中的接口实现类对象持有引用）；
2.在服务消费者进程被启动时，创建一个spring容器，容器中只有一个对象，服务的引用对象（Dubbo动态生成的代理对象）；
在这个代理对象中，并没有真正实现被调用的方法，主要用来和服务提供者建立网络连接，将发送调用的请求按照Dubbo协议（Dubbo协议作为建立在TCP之上的一种应用层协议），封装序列化并发送。provider接收到请求，反序列化得到得到请求数据，这里provider维护了一个map<String,服务对象>，通过请求中的全限定类名来唯一指定对应的服务对象，找到服务对象通过服务对象去调用真正实现了接口功能的实现类对象的方法，执行方法之后将方法调用的结果进行序列化通过网络连接最终返回给consumer。
原理大概是这样，具体dubbo的底层通信框架并不是socket，是Netty，抽象 mina 和 netty 为统一接口，以 Message 为中心
代理类主要做的事情（伪代码）

// DemoService 服务引用对象所属的代理类
/*
        当我们在该代理对象上调动方法, 说明我们想要调用
        实现了该接口的服务
 */
class DemoServiceInvoker implements DemoService {

    // 服务暴露协议
    String protocol;
    // 服务提供者 进程所在的主机ip
    String targetIp;
    int  port;

    /*
         当在代理对象上调用这个方法的时候，就说明，我们想要
         调用的是实现DemoService接口的服务的，sayHello方法
     */
    public String sayHello(String name) throws IOException {

        // 1. 建立Socket连接
        Socket socket = new Socket(targetIp, port);

        // 2. 发送调用的请求
        OutputStream out = socket.getOutputStream();
        // 按照dubbo协议的规定，封装请求数据，并发送
        //  1. 调用的是实现了哪个接口的服务
        //  2. 要调用服务中的哪个方法
        //  3. 方法运行所需要的实际参数
        //  4. 方法返回值类型
        //  ......
        //out.write();

        InputStream in = socket.getInputStream();
        //in.read()
        return null;
    }
}

5.Dubbo框架分了哪些层

服务接口层(Service)：该层是与实际业务逻辑相关的，根据服务提供方和服务消费方的业务设计对应的接口和实现
配置层(Config)：对外配置接口，以 ServiceConfig 和 ReferenceConfig 为中心
服务代理层(Proxy)：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton
服务注册层(Registry)：封装服务地址的注册与发现，以服务 URL 为中心
集群层(Cluster)：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心
监控层(Monitor)：RPC 调用次数和调用时间监控
远程调用层(Protocol)：封将 RPC 调用，以 Invocation 和 Result 为中心，扩展接口为 Protocol、Invoker、Exporter
信息交换层(Exchange)：封装请求响应模式，同步转异步，以 Request 和 Response 为中心
网络传输层(Transport)：抽象 mina 和 netty 为统一接口，以 Message 为中心