dubbo远程调用如何传递request中的数据 dubbo远程调用实现

转载

AIGC创想家 2024-04-30 23:38:20

文章标签 分布式架构dubbo源码 dubbo源码学习 dubbo远程调用流程分析初始化 apache 文章分类 运维

Dubbo是一个RPC开源框架，自定义Dubbo协议实现远程调用。

一、Dubbo 官方架构图

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_分布式架构dubbo源码

官方给的架构图主要分为了4个版块: 注册中心Registry、监视器Monitor、服务提供者Provider、服务消费者Consumer。

二、功能解析

服务注册与发现、集群容错、远程调用、负载均衡、高度可扩展、运行期流量调度、可视化的服务治理与运维等功能。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_02

三、从消费方解析Dubbo 源码是如何实现调用

首先我们先看一下Consumer的main方法:

1. 初始化xml配置。

2. 启动Spring 容器。

3. 获取Bean对象，即远程服务对象，其实是一个代理的对象。

4. 执行服务的目标方法。

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.dubbo.demo.consumer;

import org.apache.dubbo.demo.DemoService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Consumer {

    /**
     * To get ipv6 address to work, add
     * System.setProperty("java.net.preferIPv6Addresses", "true");
     * before running your application.
     */
    public static void main(String[] args) {
        // 加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});
        // 启动Spring 容器, 如果调用getBean()方法，Spring 容器会默认启动
        context.start();
        // 获取代理对象
        DemoService demoService = (DemoService) context.getBean("demoService"); // get remote service proxy
        // 获取接口的代理对象
        while (true) {
            try {
                Thread.sleep(1000);
                // 执行代理对象里的方法
                String hello = demoService.sayHello("world"); // call remote method
                System.out.println(hello); // get result
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }
    }
}

为了方便理解，我们可以把消费者远程调用其他服务的过程拆分成以下几个步骤:
1. 准备工作。在Spring 容器启动的时候就开始准备，初始化服务、服务需要的registry、Bean、从注册中心拉取服务地址列表等。
2. 服务发现与导入, 服务生产者把服务推送到zookeeper registry，服务消费者订阅注册中心zookeeper, 从zookeeper 注册中心拉取缓存到本地。
3. 服务调用, consumer 调用远程服务, 包含服务容错机制、负载均衡策略等。

实际上，dubbo源码的执行流程比上面描述的要复杂很多，在这里我主要是为了去理解远程调用的执行流程和设计思想，先把它概括成三个步骤: 准备、服务导入和服务发现、服务调用。

DubboNamespaceHandler

DubboNamespaceHandler是Dubbo定义的一个基于Spring 初始化容器的入口类，我们可以在dubbo-config-spring 的module里的spring.handlers文件里找到配置的该类。

http\://dubbo.apache.org/schema/dubbo=org.apache.dubbo.config.spring.schema.DubboNamespaceHandler
http\://code.alibabatech.com/schema/dubbo=org.apache.dubbo.config.spring.schema.DubboNamespaceHandler

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_03

该类用继承了Spring 的NamespaceHandlerSupport类，重写了init()方法和parse方法,这样dubbo才能实现解析自己的xml配置文件。

Consumer 初始化

1. 初始化 consumer 配置文件，加载并解析dubbo-demo-consumer.xml配置。

首先我们可以找到加载xml配置文件的类DubboNamespaceHandler，在此类下的init()方法下打一个断点，如下图:

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_初始化_04

在此行停顿，我们可以发现用到了一个ReferenceBean的类，它其实是META-INF.spring目录下dubbo-demo-consumer.xml文件里配置的 reference:

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_dubbo源码学习_05

同时在main()方法的 context.start()方法处打一个断点:

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_初始化_06

可以发现加载配置的代码是在.start()方法之前执行的，简单的说是通过new ClassPathXmlApplicationContext()方法初始化配置文件。

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});

2. 初始化referenceBean流程解析

referenceBean 是远程调用服务关键的类，实现了FatoryBean 等Spring 相关的接口，用来读取并初始化<dubbo:reference >标签里配置的interface等属性，referenceBean 里的执行流程可以概况为如下:

DubboNamespaceHandler:
ReferenceBean
. getObject() # 实现org.springframework.beans.factory.FactoryBean 接口里的getObject() 方法
get():
# 在init()方法里初始化consumer
init()

最终是在init()方法里初始化整个consumer的服务。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_dubbo源码学习_07

3. ReferenceConfig类里的init()方法解析

init()方法里包含很多初始化的过程，给后面要用到的变量进行赋值。例如初始化要调用的接口名，接口方法、初始化zookeeper注册中心连接、监视器等

先重点看一下此方法里初始化的一个重要的Map, 里面包含了远程接口的各种信息，如应用名称、dubbo版本、方法名称、自己配置的代理模式(Jdk动态代理)等，此map会作为创建Proxy的参数列表。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_dubbo远程调用流程分析_08

根据map创建代理对象

ref = createProxy(map);

Dubbo的SPI核心实现在ExtensionLoader和ExtensionDirector。

private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

点击进入到Protocol接口，可以查看@SPI("dubbo"),选择到的使用的协议是dubbo协议。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_分布式架构dubbo源码_09

继续进入到createProxy()方法里面, 可以找到 return (T) proxyFactory.getProxy(invoker) 方法处，如果了解动态代理模式，就能很容易理解此方法的作用是通过代理工厂生成代理对象，最终将代理对象返回。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_dubbo远程调用流程分析_10

3. 深入研究创建代理对象的机制。

由上述2可以发现，获取到最终的接口对象是通过动态代理创建的，而dubbo 默认使用的代理工厂的方式是 JavassistProxyFactory

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_11

我们也可以通过Jdk动态代理工厂来生成代理对象，在consumer的 dubbo:reference 标签里添加proxy属性为 "jdk"

<dubbo:reference id="demoService" check="false" interface="org.apache.dubbo.demo.DemoService" proxy="jdk" />

配置好后，dubbo就会使用JdkProxyFactory来创建代理对象。

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.dubbo.rpc.proxy.jdk;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.rpc.Invoker;
import org.apache.dubbo.rpc.proxy.AbstractProxyFactory;
import org.apache.dubbo.rpc.proxy.AbstractProxyInvoker;
import org.apache.dubbo.rpc.proxy.InvokerInvocationHandler;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * JavaassistRpcProxyFactory
 */
public class JdkProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    // 使用jdk动态d代理
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvokerInvocationHandler(invoker));
    }

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                Method method = proxy.getClass().getMethod(methodName, parameterTypes);
                return method.invoke(proxy, arguments);
            }
        };
    }
}

服务发现与导入

Directory

在AbstractClusterInvoker抽象类里维护了一个 directory目录，该目录用来维护了从zookeeper注册中心里的目录节点数据，因为本身zookeeper是一个文件系统。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_初始化_12

Dubbo通过容错机制，再调用失败时会重新从zookeeper里拉取所有的目录节点。在FailoverClusterInvoker类的 doInvoke() 方法有个list()方法:

if (i > 0) {
                checkWhetherDestroyed();
                copyinvokers = list(invocation);
                // check again
                checkInvokers(copyinvokers, invocation);
            }

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_13

上面的服务发现与导入是为了下面的服务调用做准备工作。

服务调用

dubbo远程调用的结构图:

Mock为服务容错，Cluster为集群容错。

# 最外层为MockClusterInvoker
MockClusterInvoker
   # 集群容错策略: 默认为FailOverCluterInvoker
   FailOverClusterInvoker
           # 负载均衡策略
       LoadBalance
           # 服务列表
           List<T> invokers

最终是通过invoker.invoke(invocation)执行远程调用，底层是通过Netty的NIO将方法对象和Url发送到服务提供者，由服务提供者去处理方法url和方法对象。

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_14

服务容错机制

在MockClusterInvoker下一层的FailOverClusterInvoker类里能找到服务容错的方法，如果没有配置重试次数，默认为2次，因此总共会发3次请求，如下:

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_dubbo远程调用流程分析_15

继续往下看，可以发现，在此处有个for 循环，因为FailOverClusterInvoker的策略是失败重试，直到有个成功就返回！

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_apache_16

服务容错FailOverClusterInvoker的效果演示:

dubbo远程调用如何传递request中的数据 dubbo远程调用实现_分布式架构dubbo源码_17

负载均衡机制

在每次调用前，会使用负载均衡策略去选择一个节点进行调用，dubbo默认地负载均衡策略是随机。

Invoker<T> invoker = select(loadbalance, invocation, copyinvokers, invoked);

同样地dubbo也可以通过配置更改负载均衡策略！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：maven设置多个远程服务器 maven怎么配置远程仓库

下一篇：数据挖掘机器学习深度学习关系大模型数据挖掘和机器算法

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯