Dubbo核心模型之Invoker

已于 2024-05-17 14:15:05 修改
阅读量1.2k 收藏 29
点赞数 22
文章标签： dubbo
于 2024-04-07 18:07:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36851469/article/details/137472815
版权

Dubbo中invoker是provider和consumer实现RPC调用的关键，invoker的构建过程是Dubbo服务的init初始化过程。invoker#invoke的调用是Dubbo服务的call调用过程。因此，这里分析invoker模型，主要是provider和consumer端的初始化过程。

dubbo中常用的Invoker类，如下：

  • AbstractProxyInvoker：本地执行类的Invoker，实际通过Java反射的方式执行原始对象的方法。一般通过接口ProxyFactory的扩展类StubProxyFactoryWrapper、JavassistProxyFactory先后执行完成目标接口的代理。
  • AbstractInvoker：远程通信类的Invoker，实际通过通信协议发起远程调用请求，并接收响应。
  • AbstractClusterInvoker：多个远程通信类的Invoker聚合成的集群Invoker，加入了集群容错和负载均衡策略。cluster集群下的Invoker实现，采用模板方法设计模式，abstract定义方法框架，具体方法实现由子类实现。

Invoker是Dubbo中实体类，rpc的server端服务提供和client端服务调用，都要由invoker实现。因此，其作为一个可执行体，在server端，用于调用provider的本地服务调用；在client端，其内包含远程通信的NettyClient，用于远程调用。provider端和consumer端，在Config配置类中，分别持有ProxyFactory和Protocol实例。

1.ProxyFactory

该接口的作用：利用目标接口以及目标接口的实现类生成Invoker【服务提供端Invoker】；利用Invoker生成其代理对象。

@SPI(value = "javassist", scope = FRAMEWORK)
public interface ProxyFactory {

    @Adaptive({PROXY_KEY})
    <T> T getProxy(Invoker<T> invoker) throws RpcException;

    @Adaptive({PROXY_KEY})
    <T> T getProxy(Invoker<T> invoker, boolean generic) throws RpcException;

    /**
     * create invoker.
     * @param <T>
     * @param proxy 目标接口的具体实现类之ChinaServiceImpl
     * @param type 目标接口之CountryService
     * @param url
     * @return invoker
     */
    @Adaptive({PROXY_KEY})
    <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException;
}

当前接口涉及扩展类如下所示：

stub=org.apache.dubbo.rpc.proxy.wrapper.StubProxyFactoryWrapper
jdk=org.apache.dubbo.rpc.proxy.jdk.JdkProxyFactory
javassist=org.apache.dubbo.rpc.proxy.javassist.JavassistProxyFactory
nativestub=org.apache.dubbo.rpc.stub.StubProxyFactory

其中，StubProxyFactory适用于生成非反射方式的invoker、proxy，主要依赖于Dubbo3 Triple协议。正常调用方向：StubProxyFactoryWrapper -> JavassistProxyFactory。

2.Protocol

@SPI(value = "dubbo", scope = ExtensionScope.FRAMEWORK)
public interface Protocol {

    /**
     * 提供端导出服务方便消费端远程调用：
     * 1. 服务提供端接收到远程访问后需要记录消费端IP地址等信息:RpcContext.getServerAttachment().setRemoteAddress()。
     * 2. 服务导出功能必须是idempotent幂等的，there's no difference between invoking once and invoking twice when export the same URL。
     * 3. Invoker instance is passed in by the framework, protocol needs not to care。
     *
     * @param <T>     Service type
     * @param invoker Service invoker
     * @return exporter reference for exported service, useful for unexport the service later
     * @throws RpcException thrown when error occurs during export the service, for example: port is occupied
     */
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    /**
     * 消费端引用远程服务: 
     * 1. 消费端通过Invoker#invoke调用refer指定的远程服务时，the protocol needs to correspondingly execute `invoke()` method of `Invoker` object。
     * 2. It's protocol's responsibility to implement `Invoker` which's returned from `refer()`. Generally speaking,
     * protocol sends remote request in the `Invoker` implementation. <br>
     * 3. When there's check=false set in URL, the implementation must not throw exception but try to recover when connection fails.
     * @param <T>  Service type
     * @param type Service class
     * @param url  URL address for the remote service
     * @return invoker service's local proxy
     * @throws RpcException when there's any error while connecting to the service provider
     */
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
}

当前接口涉及扩展类如下所示： 

filter=org.apache.dubbo.rpc.cluster.filter.ProtocolFilterWrapper
listener=org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=org.apache.dubbo.rpc.support.MockProtocol
serializationwrapper=org.apache.dubbo.rpc.protocol.ProtocolSerializationWrapper
 
dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol
injvm=org.apache.dubbo.rpc.protocol.injvm.InjvmProtocol
rest=org.apache.dubbo.rpc.protocol.rest.RestProtocol
grpc=org.apache.dubbo.rpc.protocol.grpc.GrpcProtocol
tri=org.apache.dubbo.rpc.protocol.tri.TripleProtocol
registry=org.apache.dubbo.registry.integration.InterfaceCompatibleRegistryProtocol
service-discovery-registry=org.apache.dubbo.registry.integration.RegistryProtocol
qos=org.apache.dubbo.qos.protocol.QosProtocolWrapper

 ProtocolSerializationWrapper->ProtocolFilterWrapper->ProtocolListenerWrapper->QosProtocolWrapper->RegistryProtocol

3.消费端Invoker

Consumer端之Invoker用于执行远程调用（所以consumer端invoker带有通信能力，内部传入NettyClient）。

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {
    private T createProxy(Map<String, String> referenceParameters) {
        ...
        createInvokerForRemote();
        ...
        return (T) proxyFactory.getProxy(invoker, ProtocolUtils.isGeneric(generic));
    }
}
  1. 制造一个远程reference，创造一个远程reference Invoker。
  2. 基于 Invoker 生成目标接口的代理。

3.1. reference & reference Invoker

由RegistryProtocol生成最初Invoker之MigrationInvoker，并通过RegistryProtocolListener控制Invoker的状态和行为。直观点其实就是属性invoker、serviceDiscoveryInvoker的赋值操作。

public class MigrationInvoker<T> implements MigrationClusterInvoker<T> {

    private URL url;
    private URL consumerUrl;
    private Cluster cluster;
    private Registry registry;
    private Class<T> type;
    private RegistryProtocol registryProtocol;
    private MigrationRuleListener migrationRuleListener;

    private volatile ClusterInvoker<T> invoker;
    private volatile ClusterInvoker<T> serviceDiscoveryInvoker;
    private volatile ClusterInvoker<T> currentAvailableInvoker;
}

此时MigrationInvoker内部相关属性如下所示：

RegistryProtocolListener内部通过MigrationRuleHandler基于MigrationRule规则Migrate改变Invoker的状态和行为。

public class MigrationRuleHandler<T> {
    // MigrationInvoker
    private MigrationClusterInvoker<T> migrationInvoker;
    private URL consumerURL;
    public MigrationRuleHandler(MigrationClusterInvoker<T> invoker, URL url) {
        this.migrationInvoker = invoker;
        this.consumerURL = url;
    }
    public synchronized void doMigrate(MigrationRule rule) {
        ....
        if (refreshInvoker(step, threshold, rule)) {
            setMigrationRule(rule);
        }
    }
    
    private boolean refreshInvoker(MigrationStep step, Float threshold, MigrationRule newRule) {
        MigrationStep originStep = currentStep;
        if ((currentStep == null || currentStep != step) || !currentThreshold.equals(threshold)) {
            boolean success = true;
            switch (step) {
                case APPLICATION_FIRST://默认执行策略
                    migrationInvoker.migrateToApplicationFirstInvoker(newRule);
                    break;
                case FORCE_APPLICATION:
                    success = migrationInvoker.migrateToForceApplicationInvoker(newRule);
                    break;
                case FORCE_INTERFACE:
                default:
                    success = migrationInvoker.migrateToForceInterfaceInvoker(newRule);
            }
            ...
            return success;
        }
        return true;
    }
}
public class MigrationInvoker<T> implements MigrationClusterInvoker<T> {
    private RegistryProtocol registryProtocol;
    private volatile ClusterInvoker<T> invoker;
    private volatile ClusterInvoker<T> serviceDiscoveryInvoker;

    public void migrateToApplicationFirstInvoker(MigrationRule newRule) {
        CountDownLatch latch = new CountDownLatch(0);
        //初始化参数invoker
        refreshInterfaceInvoker(latch);
        //初始化参数serviceDiscoveryInvoker
        efreshServiceDiscoveryInvoker(latch);
        calcPreferredInvoker(newRule);
    }  
     
    protected void refreshServiceDiscoveryInvoker(CountDownLatch latch) {
        serviceDiscoveryInvoker = registryProtocol.getServiceDiscoveryInvoker(cluster, registry, type, url);
    }

    protected void refreshInterfaceInvoker(CountDownLatch latch) {
        invoker = registryProtocol.getInvoker(cluster, registry, type, url);
    } 
}

截止当前才真正开始初始化MigrationInvoker内部相关属性invoker、serviceDiscoveryInvoker。

3.2.MigrationInvoker之属性invoker

public class RegistryProtocol implements Protocol{
    protected <T> ClusterInvoker<T> doCreateInvoker(DynamicDirectory<T> directory, Cluster cluster, Registry registry, Class<T> type) {
        ...
        //directory类型：RegistryDirectory
        if (directory.isShouldRegister()) {
            // 1.通过zkClient注册当前消费端服务
            directory.setRegisteredConsumerUrl(urlToRegistry);
            registry.register(directory.getRegisteredConsumerUrl());
        }
        directory.buildRouterChain(urlToRegistry);
        //2.当前消费端监听的节点
        directory.subscribe(toSubscribeUrl(urlToRegistry));
        //3.利用MockClusterWrapper创建Invoker
        return (ClusterInvoker<T>) cluster.join(directory, true);
    }
}

zk注册当前消费端服务：创建如下节点 

/dubbo/common.service.CountryService/consumers/consumer%3A%2F%2F192.168.80.36%2Fcommon.service.CountryService%3Fapplication%3Ddubbo-consumer%26background%3Dfalse%26category%3Dconsumers%26check%3Dfalse%26dubbo%3D2.0.2%26interface%3Dcommon.service.CountryService%26lazy%3Dtrue%26methods%3DgetCountry%26pid%3D65342%26qos.enable%3Dfalse%26register-mode%3Dinstance%26release%3D3.0.7%26revision%3D2.0%26side%3Dconsumer%26sticky%3Dfalse%26timestamp%3D1712909849973%26version%3D2.0

 在zk端创建以下节点，并添加相关zk监听器 ：

/dubbo/common.service.CountryService/providers
/dubbo/common.service.CountryService/configurators
/dubbo/common.service.CountryService/routers

最终返回的Invoker：MockClusterInvoker -> AbstractCluster静态内部类AbstractClusterInvoker。当前在内部类AbstractClusterInvoker构造方法内部会初始化过滤器filter类型的ClusterInvoker。

3.2.MigrationInvoker之属性serviceDiscoveryInvoker

public class RegistryProtocol implements Protocol{
    protected <T> ClusterInvoker<T> doCreateInvoker(DynamicDirectory<T> directory, Cluster cluster, Registry registry, Class<T> type) {
        ...
        // directory:ServiceDiscoveryRegistryDirectory
        if (directory.isShouldRegister()) {
            // 1.zkClient注册当前消费端服务已经完成，此处不会重复执行
            directory.setRegisteredConsumerUrl(urlToRegistry);
            registry.register(directory.getRegisteredConsumerUrl());
        }
        directory.buildRouterChain(urlToRegistry);
        //2.获取服务提供端对应的IP信息，提供消费端远程调用提供端接口
        directory.subscribe(toSubscribeUrl(urlToRegistry));
        //3.利用MockClusterWrapper创建Invoker
        return (ClusterInvoker<T>) cluster.join(directory, true);
    }
}

获取服务提供端地址信息后还涉及具有远程通信功能的DubboInvoker初始化。

public class ServiceDiscoveryRegistry{
    protected void subscribeURLs(URL url, NotifyListener listener, Set<String> serviceNames) {
        serviceNames = toTreeSet(serviceNames);
        String serviceNamesKey = toStringKeys(serviceNames);
        String protocolServiceKey = url.getProtocolServiceKey();
        Lock appSubscriptionLock = getAppSubscription(serviceNamesKey);
        appSubscriptionLock.lock();
        ServiceInstancesChangedListener serviceInstancesChangedListener = serviceListeners.get(serviceNamesKey);
        if (serviceInstancesChangedListener == null) {
            serviceInstancesChangedListener = serviceDiscovery.createListener(serviceNames);
            serviceInstancesChangedListener.setUrl(url);
            for (String serviceName : serviceNames) {
                // 获取到 服务提供端服务 所有地址列表
                List<ServiceInstance> serviceInstances = serviceDiscovery.getInstances(serviceName);
                if (CollectionUtils.isNotEmpty(serviceInstances)) {
                    serviceInstancesChangedListener.onEvent(new ServiceInstancesChangedEvent(serviceName, serviceInstances));
                }
            }
            serviceListeners.put(serviceNamesKey, serviceInstancesChangedListener);
        }

        if (!serviceInstancesChangedListener.isDestroyed()) {
            serviceInstancesChangedListener.setUrl(url);
            listener.addServiceListener(serviceInstancesChangedListener);
            // 基于提供端服务列表生成与之对应的DubboInvoker
            serviceInstancesChangedListener.addListenerAndNotify(protocolServiceKey, listener);
            serviceDiscovery.addServiceInstancesChangedListener(serviceInstancesChangedListener);
        } else {
            logger.info(String.format("Listener of %s has been destroyed by another thread.", serviceNamesKey));
            serviceListeners.remove(serviceNamesKey);
        }
    }
}

返回的serviceDiscoveryInvoker属性：MockClusterInvoker -> AbstractCluster静态内部类AbstractClusterInvoker。此时AbstractClusterInvoker内部由ServiceDiscoveryRegistryDirectory加载的过滤器filter类型的ClusterInvoker区别于MigrationInvoker属性invoker。

3六Dubbo核心技术归纳--3Dubbo中Invoker的作用及转换

阿......嚏
关注
Dubbo服务端服务发布（一）Invoker创建
dbqb007的专栏
07-16 773
在Dubbo的服务发布过程中，Invoker链的构造是一个重要的步骤，Invoker代表的是一个可以调用的服务的接口。它的定义如下： public interface Invoker<T> extends Node { /** * get service interface. * * @return service interface. ...
一文深入理解Dubbo核心模型Invoker
Java_supermanNO1的博客
02-15 1649
本文转载自：一文深入理解Dubbo核心模型Invoker 一、Dubbo中Invoker介绍 为什么说Invoker是Dubbo核心模型呢？ Invoker是Dubbo中的实体域，也就是真实存在的。其他模型都向它靠拢或转换成它，它也就代表一个可执行体，可向它发起invoke调用。在服务提供方，Invoker用于调用服务提供类。在服务消费方，Invoker用于执行远程调用。 二、服务提供方的Inv...
dubbo中invoke多种调用入参方式
【欢迎关注公众号：冬瓜白】
05-31 3990
在日常的Java开发工作中,我们经常需要调用Dubbo接口. Dubbo提供了通过invoke调用的方式,接下来由浅入深讲解不同的入参该如何传递. 首先使用telnet方式连接,连接成功之后,才可以使用invoke调用方法. ls命令可以检验是否存在提供者以及方法. ...
Dubbo源码深度解析(七)
最新发布
weixin_41338970的博客
08-21 692
核心就是ReferenceAnnotationBeanPostProcessor类，最终会生成一个对应的ReferenceBean对象，并放入Spring容器，当然最终给属性进行依赖注入的并非ReferenceBean对象，而是它的 ref属性，如果该属性为空，就需要调用Protocol#refer()方法(Dubbo的SPI机制找到Protocol接口的实现类，调用实现类的ref()方法)创建Invoker，最终生成代理对象还没讲到，这篇博客会讲到。到这里为止，生成Invoker对象的逻辑讲完了。
Dubbo Invoker
学无止境
11-30 4593
Dubbo官网对Invoker进行了说明： Invoker 是实体域，它是 Dubbo 的核心模型，其它模型都向它靠扰，或转换成它，它代表一个可执行体，可向它发起 invoke 调用，它有可能是一个本地的实现，也可能是一个远程的实现，也可能一个集群实现。 在服务提供方，Invoker 用于调用服务提供类。在服务消费方，Invoker 用于执行远程调用。Invoker 是由 Protocol ...
dubbo的invoke（dubbo通过invoke命令调用dubbo接口）
shuang1562的专栏
10-23 2万+
官网：http://dubbo.apache.org/zh-cn/ 使用telnet命令进入控制台 命令：telnet ip 端口 这个端口和ip，可以去dubbo管理控制台中搜索服务名，然后找到提供者的机器ip 使用invoke命令注入 如果注入的是json 那就直接传入json串就ok了，如果是基础数据类型，也可以分别对应参数直接传 invoke XxxService.xxxMethod...
Dubbo 之 Invoker
【欢迎关注公众号：冬瓜白】
11-30 1550
相关博客： Spring 自定义 XML 配置扩展 Dubbo的SPI机制（二）（Dubbo优化后的SPI实现） Dubbo 的 SPI 机制（三）（Extension 扩展点补充） Dubbo 之服务发布和注册（一） Dubbo 之服务发布和注册（二）（补充）   在 Dubbo 官方文档中有这么一段介绍： 在 Dubbo 的核心领域模型中： Protocol 是服务域，它是...
dubbo源码分析学习---dubbo 重要内容Invoker 和服务注册过程
qq_36697880的博客
11-05 650
这篇文章主要续接上一篇文章的基础上做的分析学习。前面没有分析 Invoker，我们来简单看看 Invoker 到底是一个啥东西。 一、Invoker 是什么 从前面的分析来看，服务的发布分三个阶段： 第一个阶段会创造一个 invoker 第二个阶段会把经历过一系列处理的 invoker（各种包装），在 DubboProtocol 中保存到 exporterMap 中 第三个阶段把 dubbo 协议的 url 地址注册到注册中心上 Invoker 是 Dubbo 领域模型中非常重要的...
Dubbo源码解析（三）执行器 Invoker
wuhulala的休息室
05-17 1万+
Invoker 在dubbo中，万物皆是Invoker，即便是Exporter也是由Invoker进化而成的 那么Invoker到底是什么鬼 在 Dubbo 的核心领域模型中： Protocol 是服务域，它是 Invoker 暴露和引用的主功能入口，它负责 Invoker 的生命周期管理。 Invoker 是实体域，它是 Dubbo 的核心模型，其它模型都向它靠扰，或转换...
自定实现Dubbo Invoker
04-27
自己仿dubbo Invoker实现，思想跟dubbo实现一致。。。。。。。。。。。
Dubbo原理和机制详解(非常全面)
热门推荐
mikechen的互联网架构
10-24 3万+
最全图文详解Dubbo的原理机制，彻底搞懂吃透Dubbo核心功能、Dubbo核心组件、Dubbo的架构设计、Dubbo调用流程等重要核心知识点，可以让我们更好地掌握和使用 Dubbo。。
深入剖析Dubbo：服务注册与消费的核心Invoker机制
Invoker在Dubbo的领域模型中扮演着至关重要的角色，类似于ExtensionLoader，理解Invoker的工作原理对于掌握Dubbo源码至关重要。Invoker负责封装服务的逻辑，它是服务提供者与消费者之间通信的桥梁，承载着服务的调用...
Dubbo invoke命令使用
大灰狼的专栏
10-15 8955
首先使用telnet命令进入控制台命令：telnet ip 端口 例如你的如果dubbo.protocol.port=29952 那么就是 telnet localhost 2995 然后使用invoke命令注入： 如果注入的是json 那就直接传入json串就ok了，如果是基础数据类型，也可以分别对应参数直接传 invoke XxxService.xxxMethod({“prop”: “value”}, 1, “1”) 如果注入的参数是对象(com.yunji.bigdata.po...
Dubbo使用invoke指令来调用dubbo接口
蹊源的奇思妙想的博客
08-26 2万+
最近被分配了一个任务，是通过`dubbo`的方式对外提供服务，`dubbo`没有我们一般的web项目中的`Controller`层，所以没有办法通过`http`的方式进行调用调试。作为萌新的我，确实有点一筹莫展，直到被老司机提醒使用`dubbo` `invoke`的方式进行接口测试，我才有方向。
Dubbo invoke命令，使用invoke来调用dubbo接口
flyq_coffee
09-22 2986
问题描述 1、对外提供Dubbo接口后，项目中没有Controller层，发现没法直接对dubbo接口进行调试 2、对外提供Dubbo接口后，由于没有打印返回日志，其他项目调用时甩锅：没有返回数据 这是则需要使用【dubbo invoke】的方式对dubbo接口进行测试 使用dubbo invoke调用接口服务 1、telnet ip 端口 telnet ip dubbo端口 2、查看可用的dubbo接口 ls： 显示服务列表。 ls -l ：显示服务详细信息列表。 ls XxxService ：显示服
dubbo核心之服务端的Invoker（四）
醒不来的梦的博客
03-21 645
一、Invoker Invoker是一个代理，与dubbo中的SPI一样重要，在ServiceConfig中在调用export方法时会将一个invoker对象传递进去，分析下这个 private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) { //省略。。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值