dubbo3.0 服务导入导出原理

不管是服务导出还是服务引入,都发生在应用启动过程中,比如:在启动类上加上 @EnableDubbo 时,该注解上有一个 @DubboComponentScan 注解,@DubboComponentScan 注解 Import 了一个 DubboComponentScanRegistrar,DubboComponentScanRegistrar 中会调用 DubboSpringInitializer.initialize(),该方法中会注册一个 DubboDeployApplicationListener,而 DubboDeployApplicationListener 会监听 Spring 容器启动完成事件 ContextRefreshedEvent,一旦接收到这个事件后,就会开始 Dubbo 的启动流程,就会执行 DefaultModuleDeployer 的 start() 进行服务导出与服务引入。

在启动过程中,在做完服务导出与服务引入后,还会做几件非常重要的事情:

1.导出一个应用元数据服务(就是一个 MetadataService 服务,这个服务也会注册到注册中心),或者将应用元数据注册到元数据中心;

2.生成当前应用的实例信息对象 ServiceInstance,比如:应用名、实例 ip、实例 port,并将实例信息注册到注册中心,也就是应用级注册;

服务导出

当在某个接口的实现类上加上 @DubboService 后,就表示定义了一个 Dubbo 服务,应用启动时 Dubbo 只要扫描到了 @DubboService,就会解析对应的类,得到服务相关的配置信息,比如:

1.服务的类型,也就是接口,接口名就是服务名;

2.服务的具体实现类,也就是当前类;

3.服务的 version、timeout 等信息,就是 @DubboService 中所定义的各种配置;

解析完服务的配置信息后,就会把这些配置信息封装成为一个 ServiceConfig 对象,并调用其 export() 进行服务导出,此时一个 ServiceConfig 对象就表示一个Dubbo 服务。

而所谓的服务导出,主要就是完成三件事情:

1.确定服务的最终参数配置;

2.按不同协议启动对应的 Server(服务暴露);

3.将服务注册到注册中心(服务注册);

确定服务参数

一个 Dubbo 服务,除开服务的名字,也就是接口名,还会有很多其他的属性,比如:超时时间、版本号、服务所属应用名、所支持的协议及绑定的端口等众多信息。

但是,通常这些信息并不会全部在 @DubboService 中进行定义,比如:一个 Dubbo 服务肯定是属于某个应用的,而一个应用下可以有多个 Dubbo 服务,所以可以在应用级别定义一些通用的配置,比如协议。

在 application.yml 中定义:

dubbo:
 application:
  name: dubbo-springboot-demo-provider
 protocol:
  name: tri
  port: 20880

表示当前应用下所有的 Dubbo 服务都支持通过 tri 协议进行访问,并且访问端口为 20880,所以在进行某个服务的服务导出时,就需要将应用中的这些配置信息合并到当前服务的配置信息中。

另外,除开可以通过 @DubboService 来配置服务,也可以在配置中心对服务进行配置,比如:在配置中心中配置:

dubbo.service.org.apache.dubbo.samples.api.DemoService.timeout=5000

表示当前服务的超时时间为 5s。

所以,在服务导出时,也需要从配置中心获取当前服务的配置,如果在 @DubboService 中也定义了 timeout,那么就用配置中心的覆盖掉,配置中心的配置优先级更高。

最终确定出服务的各种参数,这块内容和 Dubbo2.7 一致。

服务注册

当确定好了最终的服务配置后,Dubbo 就会根据这些配置信息生成对应的服务 URL,比如:

tri://192.168.65.221:20880/org.apache.dubbo.springboot.demo.DemoService?application=dubbo-springboot-demo-provider&timeout=3000

这个 URL 就表示了一个 Dubbo 服务,服务消费者只要能获得到这个服务 URL,就知道了关于这个 Dubbo 服务的全部信息,包括服务名、支持的协议、ip、port、各种配置。

确定了服务 URL 之后,服务注册要做的事情就是把这个服务 URL 存到注册中心(比如:Zookeeper)中去,说的再简单一点,就是把这个字符串存到 Zookeeper中去,这个步骤其实是非常简单的,实现这个功能的源码在 RegistryProtocol 中的 export() 方法中,最终服务 URL 存在了 Zookeeper 的 /dubbo/ 接口名 /providers 目录下。

但是服务注册并不仅仅就这么简单,既然上面的这个 URL 表示一个服务,并且还包括了服务的一些配置信息,那这些配置信息如果改变了呢?比如:利用 Dubbo管理台中的动态配置功能(注意,并不是配置中心)来修改服务配置,动态配置可以应用运行过程中动态的修改服务的配置,并实时生效。

如果利用动态配置功能修改了服务的参数,那此时就要重新生成服务 URL 并重新注册到注册中心,这样服务消费者就能及时的获取到服务配置信息。

而对于服务提供者而言,在服务注册过程中,还需要能监听到动态配置的变化,一旦发生了变化,就根据最新的配置重新生成服务 URL,并重新注册到中心。

应用级注册

在 Dubbo3.0 之前,Dubbo 是接口级注册,服务注册就是把接口名以及服务配置信息注册到注册中心中,注册中心存储的数据格式大概为:

接口名1:tri://192.168.1.221:20880/接口名1?application=应用名
接口名2:tri://192.168.1.221:20880/接口名2?application=应用名
接口名3:tri://192.168.1.221:20880/接口名3?application=应用名

key 是接口名,value 就是服务 URL,上面的内容就表示现在有一个应用,该应用下有 3 个接口,应用实例部署在 192.168.1.221,此时,如果给该应用增加一个实例,实例 ip 为192.168.1.222,那么新的实例也需要进行服务注册,会向注册中心新增 3 条数据:

接口名1:tri://192.168.1.221:20880/接口名1?application=应用名
接口名2:tri://192.168.1.221:20880/接口名2?application=应用名
接口名3:tri://192.168.1.221:20880/接口名3?application=应用名

接口名1:tri://192.168.1.222:20880/接口名1?application=应用名
接口名2:tri://192.168.1.222:20880/接口名2?application=应用名
接口名3:tri://192.168.1.222:20880/接口名3?application=应用名

可以发现,如果一个应用中有 3 个 Dubbo 服务,那么每增加一个实例,就会向注册中心增加 3 条记录,那如果一个应用中有 10 个 Dubbo 服务,那么每增加一个实例,就会向注册中心增加 10 条记录,注册中心的压力会随着应用实例的增加而剧烈增加。

反过来,如果一个应用有 3 个 Dubbo 服务,5 个实例,那么注册中心就有 15 条记录,此时增加一个 Dubbo 服务,那么注册中心就会新增 5 条记录,注册中心的压力也会剧烈增加。

注册中心的数据越多,数据就变化的越频繁,比如:修改服务的 timeout,那么对于注册中心和应用都需要消耗资源用来处理数据变化。

所以为了降低注册中心的压力,Dubbo3.0 支持了应用级注册,同时也兼容接口级注册,用户可以逐步迁移成应用级注册,而一旦采用应用级注册,最终注册中心的数据存储就变成为:

应用名:192.168.1.221:20880
应用名:192.168.1.222:20880

表示在注册中心中,只记录应用所对应的实例信息(IP + 绑定的端口),这样只有一个应用的实例增加了,那么注册中心的数据才会增加,而不关心一个应用中到底有多少个 Dubbo 服务。

这样带来的好处就是,注册中心存储的数据变少了,注册中心中数据的变化频率变小了,并且使用应用级注册,使得 Dubbo3 能实现与异构微服务体系如:Spring Cloud、Kubernetes Service 等在地址发现层面更容易互通, 为连通 Dubbo 与其他微服务体系提供可行方案。

应用级注册带来了好处,但是对于 Dubbo 来说又出现了一些新的问题,比如:原本,服务消费者可以直接从注册中心就知道某个 Dubbo 服务的所有服务提供者以及相关的协议、ip、port、配置等信息,那现在注册中心上只有 ip、port,那对于服务消费者而言:服务消费者怎么知道现在它要用的某个 Dubbo 服务,也就是某个接口对应的应用是哪个呢?

对于这个问题,在进行服务导出的过程中,会在 Zookeeper 中存一个映射关系,在服务导出的最后一步,在 ServiceConfig 的 exported() 方法中,会保存这个映射关系:接口名:应用名。这个映射关系存在 Zookeeper 的 /dubbo/mapping 目录下,存了这个信息后,消费者就能根据接口名找到所对应的应用名了。

消费者知道了要使用的 Dubbo 服务在哪个应用,那也就能从注册中心中根据应用名查到应用的所有实例信息( ip + port ),也就是可以发送方法调用请求了,但是在真正发送请求之前,还得知道服务的配置信息,对于消费者而言,它得知道当前要调用的这个 Dubbo 服务支持什么协议、timeout 是多少,那服务的配置信息从哪里获取呢?

之前的服务配置信息是直接从注册中心就可以获取到的,就是服务 URL 后面,但是现在不行了,现在需要从服务提供者的元数据服务获取,前面提到过,在应用启动过程中会进行服务导出和服务引入,然后就会暴露一个应用元数据服务,其实这个应用元数据服务就是一个 Dubbo 服务(Dubbo 框架内置的,自己实现的 ),消费者可以调用这个服务来获取某个应用中所提供的所有 Dubbo 服务以及服务配置信息,这样也就能知道服务的配置信息了。

知道了应用注册的好处,以及相关问题的解决方式,那么来看它到底是如何实现的。

首先,我们可以通过配置 dubbo.application.register-mode 来控制:

1.instance:表示只进行应用级注册;

2.interface:表示只进行接口级注册;

3.all:表示应用级注册和接口级注册都进行,默认;

不管是什么注册,都需要存数据到注册中心,而 Dubbo3 的源码实现中会根据所配置的注册中心生成两个 URL(不是服务 URL,可以理解为注册中心 URL,用来访问注册中心的):

1.service-discovery-registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=dubbospringboot-demoprovider& dubbo=2.0.2&pid=13072&qos.enable=false®istry=zookeeper×tamp=1651755501660

2.registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=dubbo-springboot-demoprovider& dubbo=2.0.2&pid=13072&qos.enable=false®istry=zookeeper×tamp=1651755501660

这两个 URL 只有 schema 不一样,一个是 service-discovery-registry,一个是 registry,而 registry 是 Dubbo3 之前就存在的,也就代表接口级服务注册,而service-discovery-registry 就表示应用级服务注册。

在服务注册相关的源码中,当调用 RegistryProtocol 的 export() 方法处理 registry:// 时,会利用 ZookeeperRegistry 把服务 URL 注册到 Zookeeper 中去,这就是接口级注册。

而类似,当调用 RegistryProtocol 的 export() 方法处理 service-discovery-registry:// 时,会利用 ServiceDiscoveryRegistry 来进行相关逻辑的处理,那是不是就是在这里把应用信息注册到注册中心去呢?并没有这么简单。

1.首先,不可能每导出一个服务就进行一次应用注册,太浪费了,应用注册只要做一次就行了

2.其次,如果一个应用支持了多个端口,那么应用注册时只要挑选其中一个端口作为实例端口就可以了(该端口只要能接收到数据就行)

3.前面提到,应用启动过程中要暴露应用元数据服务,所以在此处也还是要收集当前所暴露的服务配置信息,以提供给应用元数据服务

所以 ServiceDiscoveryRegistry 在注册一个服务 URL 时,并不会往注册中心存数据,而只是把服务 URL 存到到一个 MetadataInfo 对象中,MetadataInfo 对象中就保存了当前应用中所有的 Dubbo 服务信息:服务名、支持的协议、绑定的端口、timeout 等。

前面提到过,在应用启动的最后,才会进行应用级注册,而应用级注册就是当前的应用实例上相关的信息存入注册中心,包括:

1.应用的名字;

2.获取应用元数据的方式;

3.当前实例的 ip 和 port;

4.当前实例支持哪些协议以及对应的 port;

比如:

{
  "name":"dubbo-springboot-demo-provider",
  "id":"192.168.65.221:20882",
  "address":"192.168.65.221",
  "port":20882,
  "sslPort":null,
  "payload":{
    "@class":"org.apache.dubbo.registry.zookeeper.ZookeeperInstance",
    "id":"192.168.65.221:20882",
    "name":"dubbo-springboot-demo-provider",
    "metadata":{
      "dubbo.endpoints":"[{"port":20882,"protocol":"dubbo"},{"port":50051,"protocol":"tri"}]",
      "dubbo.metadata-service.url-params":"{"connections":"1","version":"1.0.0","dubbo":"2.0.2","side":"provider","port":"20882","protocol":"dubbo"}",
      "dubbo.metadata.revision":"65d5c7b814616ab10d32860b54781686",
      "dubbo.metadata.storage-type":"local"
    } 
  },
  "registrationTimeUTC":1654585977352,
  "serviceType":"DYNAMIC",
  "uriSpec":null
}

一个实例上可能支持多个协议以及多个端口,那如何确定实例的 ip 和端口呢?

答案是:获取 MetadataInfo 对象中保存的所有服务 URL,优先取 dubbo 协议对应 ip 和 port,没有 dubbo 协议则所有服务 URL 中的第一个 URL 的 ip 和 port。

另外一个协议一般只会对应一个端口,但是如何就是对应了多个,比如:

dubbo:
  application:
    name: dubbo-springboot-demo-provider
  protocols:
    p1:
      name: dubbo
      port: 20881
    p2:
      name: dubbo
      port: 20882
    p3:
      name: tri
      port: 50051

如果是这样,最终存入 endpoint 中的会保证一个协议只对应一个端口,另外那个将被忽略,最终服务消费者在进行服务引入时将会用到这个 endpoint 信息。

确定好实例信息后之后,就进行最终的应用注册了,就把实例信息存入注册中心的 /services/应用名,目录下:

可以看出 services 节点下存的是应用名,应用名的节点下存的是实例 ip 和实例 port,而 ip 和 port 这个节点中的内容就是实例的一些基本信息。

额外,我们可以配置 dubbo.metadata.storage-type,默认时 local,可以通过配置改为 remote:

dubbo:
	application:
		name: dubbo-springboot-demo-provider
		metadata-type: remote

这个配置其实跟应用元数据服务有关系:

1.如果为 local,那就会启用应用元数据服务,最终服务消费者就会调用元数据服务获取到应用元数据信息;

2.如果为 remote,那就不会暴露应用元数据服务,那么服务消费者从元数据中心获取应用元数据;

在 Dubbo2.7 中就有了元数据中心,它其实就是用来减轻注册中心的压力的,Dubbo 会把服务信息完整的存一份到元数据中心,元数据中心也可以用 Zookeeper来实现,在暴露完元数据服务之后,在注册实例信息到注册中心之前,就会把 MetadataInfo 存入元数据中心,比如:

节点内容为:

{
    "app":"dubbo-springboot-demo-provider",
    "revision":"64e68950e300068e6b5f8632d9fd141d",
    "services":{
        "org.apache.dubbo.springboot.demo.HelloService:tri":{
            "name":"org.apache.dubbo.springboot.demo.HelloService",
            "protocol":"tri",
            "path":"org.apache.dubbo.springboot.demo.HelloService",
            "params":{
                "side":"provider",
                "release":"",
                "methods":"sayHello",
                "deprecated":"false",
                "dubbo":"2.0.2",
                "interface":"org.apache.dubbo.springboot.demo.HelloService",
                "service-name-mapping":"true",
                "generic":"false",
                "metadata-type":"remote",
                "application":"dubbo-springboot-demo-provider",
                "background":"false",
                "dynamic":"true",
                "anyhost":"true"
            }
        },
        "org.apache.dubbo.springboot.demo.DemoService:tri":{
            "name":"org.apache.dubbo.springboot.demo.DemoService",
            "protocol":"tri",
            "path":"org.apache.dubbo.springboot.demo.DemoService",
            "params":{
                "side":"provider",
                "release":"",
                "methods":"sayHelloStream,sayHello,sayHelloServerStream",
                "deprecated":"false",
                "dubbo":"2.0.2",
                "interface":"org.apache.dubbo.springboot.demo.DemoService",
                "service-name-mapping":"true",
                "generic":"false",
                "metadata-type":"remote",
                "application":"dubbo-springboot-demo-provider",
                "background":"false",
                "dynamic":"true",
                "anyhost":"true"
            }
        }
    }
}

这里面就记录了当前实例上提供了哪些服务以及对应的协议,注意并没有保存对应的端口…,所以后面服务消费者得利用实例信息中的 endpoint,因为endpoint 中记录了协议对应的端口…

其实元数据中心和元数据服务提供的功能是一样的,都可以用来获取某个实例的 MetadataInfo,上面中的 UUID 表示实例编号,只不过元数据中心是集中式的,元数据服务式分散在各个提供者实例中的,如果整个微服务集群压力不大,那么效果差不多,如果微服务集群压力大,那么元数据中心的压力就大,此时单个元数据服务就更适合,所以默认也是采用的元数据服务。

至此,应用级服务注册的原理就分析完了,总结一下:

1.在导出某个 Dubbo 服务 URL 时,会把服务 URL 存入 MetadataInfo 中;

2.导出完某个 Dubbo 服务后,就会把服务接口名:应用名存入元数据中心(可以用 Zookeeper 实现);

3.导出所有服务后,完成服务引入后;

4.判断要不要启动元数据服务,如果要就进行导出,固定使用 Dubbo 协议;

5.将 MetadataInfo 存入元数据中心;

6.确定当前实例信息(应用名、ip、port、endpoint);

7.将实例信息存入注册中心,完成应用注册;

服务暴露

服务暴露就是根据不同的协议启动不同的 Server,比如:dubbo 和 tri 协议启动的都是 Netty,像 Dubbo2.7 中的 http 协议启动的就是 Tomcat,这块在服务调用的时候再来分析。

服务引入

@DubboReference
private DemoService demoService;

需要利用 @DubboReference 注解来引入某一个 Dubbo 服务,应用在启动过程中,进行完服务导出之后,就会进行服务引入,属性的类型就是一个 Dubbo 服务接口,而服务引入最终要做到的就是给这个属性赋值一个接口代理对象。

在 Dubbo2.7 中,只有接口级服务注册,服务消费者会利用接口名从注册中心找到该服务接口所有的服务 URL,服务消费者会根据每个服务 URL 的 protocol、ip、port 生成对应的 Invoker 对象,比如生成 TripleInvoker、DubboInvoker 等,调用这些 Invoker 的 invoke() 方法就会发送数据到对应的 ip、port,生成好所有的 Invoker 对象之后,就会把这些 Invoker 对象进行封装并生成一个服务接口的代理对象,代理对象调用某个方法时,会把所调用的方法信息生成一个 Invocation 对象,并最终通过某一个 Invoker 的 invoke() 方法把 Invocation 对象发送出去,所以代理对象中的 Invoker 对象是关键,服务引入最核心的就是要生成这些 Invoker 对象。

Invoker 是非常核心的一个概念,也有非常多种类,比如:

1.TripleInvoker:表示利用 tri 协议把 Invocation 对象发送出去;

2.DubboInvoker:表示利用 dubbo 协议把 Invocation 对象发送出去;

3.ClusterInvoker:有负载均衡功能;

4.MigrationInvoker:迁移功能,Dubbo3.0 新增的

像 TripleInvoker 和 DubboInvoker 对应的就是具体服务提供者,包含了服务提供者的 ip 地址和端口,并且会负责跟对应的 ip 和 port 建立 Socket 连接,后续就可以基于这个 Socket 连接并按协议格式发送 Invocation 对象。

比如现在引入了 DemoService 这个服务,那如果该服务支持:

1.一个 tri 协议,绑定的端口为 20881;

2.一个 tri 协议,绑定的端口为 20882;

3.一个 dubbo 协议,绑定的端口为 20883;

那么在服务消费端这边,就会生成两个 TripleInvoker 和一个 DubboInvoker,代理对象执行方法时就会进行负载均衡选择其中一个 Invoker 进行调用。

接口级服务引入

在服务导出时,Dubbo3.0 默认情况下即会进行接口级注册,也会进行应用级注册,目的就是为了兼容服务消费者应用,用的还是 Dubbo2.7,用 Dubbo2.7 就只能老老实实的进行接口级服务引入。

接口级服务引入核心就是要找到当前所引入的服务有哪些服务 URL,然后根据每个服务 URL 生成对应的 Invoker,流程为:

1.首先,根据当前引入的服务接口生成一个 RegistryDirectory 对象,表示动态服务目录,用来查询并缓存服务提供者信息;

2.RegistryDirectory 对象会根据服务接口名去注册中心,比如:Zookeeper 中的 /dubbo/服务接口名/providers/ 节点下查找所有的服务 URL;

3.根据每个服务 URL 生成对应的 Invoker 对象,并把 Invoker 对象存在 RegistryDirectory 对象的 invokers 属性中;

4.RegistryDirectory 对象也会监听 /dubbo/服务接口名/providers/ 节点的数据变化,一旦发生了变化就要进行相应的改变;

5.最后将 RegistryDirectory 对象生成一个 ClusterInvoker 对象,到时候调用 ClusterInvoker 对象的 invoke() 方法就会进行负载均衡选出某一个 Invoker 进行调用;

应用级服务引入

在 Dubbo 中,应用级服务引入,并不是指引入某个应用,这里和 SpringCloud 是有区别的,在 SpringCloud 中,服务消费者只要从注册中心找到要调用的应用的所有实例地址就可以了,但是在 Dubbo 中找到应用的实例地址还远远不够,因为在 Dubbo 中是直接使用的接口,所以在 Dubbo 中就算是应用级服务引入,最终还是得找到服务接口有哪些服务提供者。

所以,对于服务消费者而言,不管是使用接口级服务引入,还是应用级服务引入,最终的结果应该得是一样的,也就是某个服务接口的提供者 Invoker 是一样的,不可能使用应用级服务引入得到的 Invoker 多一个或少一个,但是!!!,目前会有情况不一致,就是一个协议有多个端口时,比如在服务提供者应用这边支持:

dubbo:
  application:
    name: dubbo-springboot-demo-provider
  protocols:
    p1:
      name: dubbo
      port: 20881
    p2:
      name: tri
      port: 20882
    p3:
      name: tri
      port: 50051

那么在消费端进行服务引入时,比如:引入 DemoService 时,接口级服务引入会生成 3 个 Invoker(2个 TripleInvoker,1个DubboInvoker),而应用级服务引入只会生成 2 个 Invoker(1个TripleInvoker,1个DubboInvoker),原因就是在进行应用级注册时是按照一个协议对应一个port存的。

那既然接口级服务引入和应用级服务引入最终的结果差不多,可能就不理解了,那应用级服务引入有什么好处呢?要知道应用级服务引入和应用级服务注册是对应,服务提供者应用如果只做应用级注册,那么对应的服务消费者就只能进行应用级服务引入,好处就是前面所说的,减轻了注册中心的压力等,那么带来的影响就是服务消费者端寻找服务 URL 的逻辑更复杂了。

只要找到了当前引入服务对应的服务 URL,然后生成对应的 Invoker,并最终生成一个 ClusterInvoker。

在进行应用级服务引入时:

1.首先,根据当前引入的服务接口生成一个 ServiceDiscoveryRegistryDirectory 对象,表示动态服务目录,用来查询并缓存服务提供者信息;

2.根据接口名去获取 /dubbo/mapping/服务接口名节点的内容,拿到的就是该接口所对应的应用名;

3.有了应用名之后,再去获取 /services/应用名节点下的实例信息;

4.依次遍历每个实例,每个实例都有一个编号 revision

5.根据 metadata-type 进行判断如果是 local:则调用实例上的元数据服务获取应用元数据(MetadataInfo);如果是 remote:则根据应用名从元数据中心获取应用元数据(MetadataInfo);

6.获取到应用元数据之后就进行缓存,key 为 revision,MetadataInfo 对象为 value

7.这里为什么要去每个实例上获取应用的元数据信息呢?因为有可能不一样,虽然是同一个应用,但是在运行不同的实例的时候,可以指定不同的参数,比如不同的协议,不同的端口,虽然在生产上基本不会这么做,但是 Dubbo 还是支持了这种情况

8.根据从所有实例上获取到的 MetadataInfo 以及 endpoint 信息,就能知道所有实例上所有的服务 URL(注意:一个接口+一个协议+一个实例 : 对应一个服务URL)

9.拿到了这些服务 URL 之后,就根据当前引入服务的信息进行过滤,会根据引入服务的接口名+协议名,消费者可以在 @DubboReference 中指定协议,表示只使用这个协议调用当前服务,如果没有指定协议,那么就会去获取 tri、dubbo、rest 这三个协议对应的服务 URL(Dubbo3.0 默认只支持这三个协议)

10.这样,经过过滤之后,就得到了当前所引入的服务对应的服务 URL 了

11.根据每个服务 URL 生成对应的 Invoker 对象,并把 Invoker 对象存在 ServiceDiscoveryRegistryDirectory 对象的 invokers 属性中

12.最后将 ServiceDiscoveryRegistryDirectory 对象生成一个 ClusterInvoker 对象,到时候调用 ClusterInvoker 对象的 invoke() 方法就会进行负载均衡选出某一个 Invoker 进行调用

MigrationInvoker 的生成

上面分析了接口级服务引入和应用级服务引入,最终都是得到某个服务对应的服务提供者 Invoker,那最终进行服务调用时,到底该怎么选择呢?

所以在 Dubbo3.0 中,可以配置:

# dubbo.application.service-discovery.migration 仅支持通过 -D 以及 全局配置中心 两种方式进行配置。

dubbo.application.service-discovery.migration=APPLICATION_FIRST

 # 可选值
 # FORCE_INTERFACE,强制使用接口级服务引入
 # FORCE_APPLICATION,强制使用应用级服务引入
 # APPLICATION_FIRST,智能选择是接口级还是应用级,默认就是这个

对于前两种强制的方式,没什么特殊,就是上面走上面分析的两个过程,没有额外的逻辑,那对于 APPLICATION_FIRST 就需要有额外的逻辑了,也就是 Dubbo 要判断,当前所引入的这个服务,应该走接口级还是应用级,这该如何判断呢?

事实上,在进行某个服务的服务引入时,会统一利用 InterfaceCompatibleRegistryProtocol 的 refer 来生成一个 MigrationInvoker 对象,在 MigrationInvoker 中有三个属性:

private volatile ClusterInvoker<T> invoker; // 用来记录接口级ClusterInvoker
private volatile ClusterInvoker<T> serviceDiscoveryInvoker; // 用来记录应用级的ClusterInvoker

private volatile ClusterInvoker<T> currentAvailableInvoker; // 用来记录当前使用的ClusterInvoker,要么是接口级,要么应用级

一开始构造出来的 MigrationInvoker 对象中三个属性都为空,接下来会利用 MigrationRuleListener 来处理 MigrationInvoker 对象,也就是给这三个属性赋值。

在 MigrationRuleListener 的构造方法中,会从配置中心读取 DUBBO_SERVICEDISCOVERY_MIGRATION 组下面的"当前应用名+.migration"的配置项,配置项为 yml 格式,对应的对象为 MigrationRule,也就是可以配置具体的迁移规则,比如:某个接口或某个应用的 MigrationStep(FORCE_INTERFACE、APPLICATION_FIRST、FORCE_APPLICATION),还可以配置 threshold,表示一个阈值,比如:配置为 2,表示应用级 Invoker 数量是接口级 Invoker 数量的两倍时才使用应用级 Invoker,不然就使用接口级数量,可以参考:https://cn.dubbo.apache.org/zh/docs/advanced/migration-invoker/

如果没有配置迁移规则,则会看当前应用中是否配置了 migration.step,如果没有,那就从全局配置中心读取 dubbo.application.service-discovery.migration 来获取 MigrationStep,如果也没有配置,那 MigrationStep 默认为 APPLICATION_FIRST

如果没有配置迁移规则,则会看当前应用中是否配置了 migration.threshold,如果没有配,则 threshold 默认为 -1。

在应用中可以这么配置:

dubbo:
	application:
		name: dubbo-springboot-demo-consumer
		parameters:
			migration.step: FORCE_APPLICATION
			migration.threshold: 2

确定了 step 和 threshold 之后,就要真正开始给 MigrationInvoker 对象中的三个属性赋值了,先根据 step 调用不同的方法

switch (step) {
 case APPLICATION_FIRST:
 // 先进行接口级服务引入得到对应的ClusterInvoker,并赋值给invoker属性
 // 再进行应用级服务引入得到对应的ClusterInvoker,并赋值给serviceDiscoveryInvoker属性
// 再根据两者的数量判断到底用哪个,并且把确定的ClusterInvoker赋值给currentAvailableInvoker属性

 migrationInvoker.migrateToApplicationFirstInvoker(newRule);
 break;
 case FORCE_APPLICATION:
// 只进行应用级服务引入得到对应的ClusterInvoker,并赋值给serviceDiscoveryInvoker和currentAvailableInvoker属性

 success = migrationInvoker.migrateToForceApplicationInvoker(newRule);
 break;
 case FORCE_INTERFACE:
 default:
// 只进行接口级服务引入得到对应的ClusterInvoker,并赋值给invoker和currentAvailableInvoker属性

 success = migrationInvoker.migrateToForceInterfaceInvoker(newRule);
 }

这里只需要分析当 step 为 APPLICATION_FIRST 时,是如何确定最终要使用的 ClusterInvoker 的。

得到了接口级 ClusterInvoker 和应用级 ClusterInvoker 之后,就会利用 DefaultMigrationAddressComparator 来进行判断:

1.如果应用级 ClusterInvoker 中没有具体的 Invoker,那就表示只能用接口级 Invoker

2.如果接口级 ClusterInvoker 中没有具体的 Invoker,那就表示只能用应用级 Invoker

3.如果应用级 ClusterInvoker 和接口级 ClusterInvoker 中都有具体的 Invoker,则获取对应的 Invoker 个数

4.如果在迁移规则和应用参数中都没有配置 threshold,那就读取全局配置中心的 dubbo.application.migration.threshold 参数,如果也没有配置,则threshold 默认为 0(不是-1了)

5.用应用级 Invoker 数量 / 接口级 Invoker 数量,得到的结果如果大于等于 threshold,那就用应用级 ClusterInvoker,否则用接口级 ClusterInvoker

threshold 默认为 0,那就表示在既有应用级 Invoker 又有接口级 Invoker 的情况下,就一定会用应用级 Invoker,两个正数相除,结果肯定为正数,当然你自己可以控制 threshold,如果既有既有应用级 Invoker 又有接口级 Invoker 的情况下,你想在应用级 Invoker 的个数大于接口级 Invoker 的个数时采用应用级Invoker,那就可以把 threshold 设置为 1,表示个数相等,或者个数相除之后的结果大于 1 时用应用级 Invoker,否者用接口级 Invoker

这样 MigrationInvoker 对象中的三个数据就能确定好值了,和在最终的接口代理对象执行某个方法时,就会调用 MigrationInvoker 对象的 invoke,在这个invoke 方法中会直接执行 currentAvailableInvoker 对应的 invoker 的 invoker 方法,从而进入到了接口级 ClusterInvoker 或应用级 ClusterInvoker 中,从而进行负载均衡,选择出具体的 DubboInvoer 或 TripleInvoker,完成真正的服务调用。

服务调用底层原理

在 Dubbo2.7 中,默认的是 Dubbo 协议,因为 Dubbo 协议相比较于 Http1.1 而言,Dubbo 协议性能上是要更好的。

但是 Dubbo 协议自己的缺点就是不通用,假如现在通过 Dubbo 协议提供了一个服务,那如果想要调用该服务就必须要求服务消费者也要支持 Dubbo 协议,比如想通过浏览器直接调用 Dubbo 服务是不行的,想通过 Nginx 调 Dubbo 服务也是不行得。

而随着企业的发展,往往可能会出现公司内部使用多种技术栈,可能这个部门使用 Dubbo,另外一个部门使用 Spring Cloud,另外一个部门使用 gRPC,那此时部门之间要想相互调用服务就比较复杂了,所以需要一个通用的、性能也好的协议,这就是 Triple 协议。

Triple 协议是基于 Http2 协议的,也就是在使用 Triple 协议发送数据时,会按 HTTP2 协议的格式来发送数据,而 HTTP2 协议相比较于 HTTP1 协议而言,HTTP2是 HTTP1 的升级版,完全兼容 HTTP1,而且 HTTP2 协议从设计层面就解决了 HTTP1 性能低的问题。

另外,Google 公司开发的 gRPC,也基于的 HTTP2,目前 gRPC 是云原生事实上协议标准,包括 k8s/etcd 等都支持 gRPC 协议。

所以 Dubbo3.0 为了能够更方便的和 k8s 进行通信,在实现 Triple 的时候也兼容了 gRPC,也就是可以用 gPRC 的客户端调用 Dubbo3.0 所提供的 triple 服务,也可以用 triple 服务调用 gRPC 的服务。

Triple 的底层原理分析

就是因为 HTTP2 中的数据帧机制,Triple 协议才能支持 UNARY、SERVER_STREAM、BI_STREAM 三种模式。

1.UNARY:就是最普通的,服务端只有在接收到完请求包括的所有的 HEADERS 帧和 DATA 帧之后(通过调用 onCompleted() 发送最后一个 DATA 帧),才会处理数据,客户端也只有接收完响应包括的所有的 HEADERS 帧和 DATA 帧之后,才会处理响应结果。

2.SERVER_STREAM:服务端流,特殊的地方在于,服务端在接收完请求包括的所有的 DATA 帧之后,才会处理数据,不过在处理数据的过程中,可以多次发送响应 DATA 帧(第一个 DATA 帧发送之前会发送一个 HEADERS 帧),客户端每接收到一个响应 DATA 帧就可以直接处理该响应 DATA 帧,这个模式下,客户端只能发一次数据,但能多次处理响应 DATA 帧。

3.BI_STREAM:双端流,或者客户端流,特殊的地方在于,客户端可以控制发送多个请求 DATA 帧(第一个 DATA 帧发送之前会发送一个 HEADERS 帧),服务端会不断的接收到请求 DATA 帧并进行处理,并且及时的把处理结果作为响应 DATA 帧发送给客户端(第一个 DATA 帧发送之前会发送一个 HEADERS 帧),而客户端每接收到一个响应结果 DATA 帧也会直接处理,这种模式下,客户端和服务端都在不断的接收和发送 DATA 帧并进行处理,注意请求 HEADER 帧和响应 HEADERS 帧都只发了一个。

Triple 请求调用和响应处理

创建一个 Stream 的前提是先得有一个 Socket 连接,所以我们得先知道 Socket 连接是在哪创建的。

在服务提供者进行服务导出时,会按照协议以及对应的端口启动 Server,比如:Triple 协议就会启动 Netty 并绑定指定的端口,等待 Socket 连接,在进行服务消费者进行服务引入的过程中,会生成 TripleInvoker 对象,在构造 TripleInvoker 对象的构造方法中,会利用 ConnectionManager 创建一个 Connection 对象,而Connection 对象中包含了一个 Bootstrap 对象(Netty 中用来建立 Socket 连接的),不过以上都只是创建对象,并不会真正和服务去建立 Socket 连接,所以在生成 TripleInvoker 对象过程中不会真正去创建 Socket 连接,那什么时候创建的呢?

当我们在服务消费端执行以下代码时:demoService.sayHello("habit")

demoService 是一个代理对象,在执行方法的过程中,最终会调用 TripleInvoker 的 doInvoke() 方法,在 doInvoke() 方法中,会利用 Connection 对象来判断Socket 连接是否可用,如果不可用并且没有初始化,那就会创建 Socket 连接。

一个 Connection 对象就表示一个 Socket 连接,在 TripleInvoker 对象中也只有一个 Connection 对象,也就是一个 TripleInvoker 对象只对应一个 Socket 连接,这个和 DubboInvoker 不太一样,一个 DubboInvoker 中可以有多个 ExchangeClient,每个 ExchangeClient 都会与服务端创建一个 Socket 连接,所以一个DubboInvoker 可以对应多个 Socket 连接,当然多个 Socket 连接的目的就是提高并发,不过在 TripleInvoker 对象中就不需要这么来设计了,因为可以 Stream机制来提高并发。

以上,我们知道了,当我们利用服务接口的代理对象执行方法时就会创建一个 Socket 连接,就算这个代理对象再次执行方法时也不会再次创建 Socket 连接了,值得注意的是,有可能两个服务接口对应的是一个 Socket 连接,举个例子。

比如服务提供者应用 A,提供了 DemoService 和 HelloService 两个服务,服务消费者应用 B 引入了这两个服务,那么在服务消费者这端,这个两个接口对应的代理对象对应的 TripleInvoker 是不同的两个,但是这两个 TripleInvoker 会公用一个 Socket 连接,因为 ConnectionManager 在创建 Connection 对象时会根据服务 URL 的 address 进行缓存,后续这两个代理对象在执行方法时使用的就是同一个 Socket 连接,但是是不同的 Stream。

Socket 连接创建好之后,就需要发送 Invocation 对象给服务提供者了,因为是基于的 HTTP2,所以要先创建一个 Stream,然后再通过 Stream 来发送数据。

TripleInvoker 中用的是 Netty,所以最终会利用 Netty 来创建 Stream,对应的对象为 Http2StreamChannel,消费端的 TripleInvoker 最终会利用Http2StreamChannel 来发送和接收数据帧,数据帧对应的对象为 Http2Frame,它又分为 Http2DataFrame、Http2HeadersFrame 等具体类型。

正常情况下,会每生成一个数据帧就会通过 Http2StreamChannel 发送出去,但是在 Triple 中有一个小小的优化,会有一个批量发送的思想,当要发送一个数据帧时,会先把数据帧放入一个 WriteQueue 中,然后会从线程池中拿到一个线程调用 WriteQueue 的 flush 方法,该方法的实现为:

private void flush() {
        try {
            QueuedCommand cmd;
            int i = 0;
            boolean flushedOnce = false;
            // 只要队列中有元素就取出来,没有则退出while
            while ((cmd = queue.poll()) != null) {
                // 把数据帧添加到Http2StreamChannel中,添加并不会立马发送,调用了flush才发送
                cmd.run(channel);
                i++;

                // DEQUE_CHUNK_SIZE=128
                // 连续从队列中取到了128个数据帧就flush一次
                if (i == DEQUE_CHUNK_SIZE) {
                    i = 0;
                    channel.flush();
                    flushedOnce = true;
                }
            }

            // i != 0 表示从队列中取到了数据但是没满128个
            // 如果i=0,flushedOnce=false也flush一次
            if (i != 0 || !flushedOnce) {
                channel.flush();
            }
        } finally {
            scheduled.set(false);

            // 如果队列中又有数据了,则继续会递归调用flush
            if (!queue.isEmpty()) {
                scheduleFlush();
            }
        }
    }

总体思想是,只要向 WriteQueue 中添加一个数据帧之后,那就会尝试开启一个线程,要不要开启线程要看 CAS,比如现在有 10 个线程同时向 WriteQueue 中添加了一个数据帧,那么这 10 个线程中的某一个会 CAS 成功,其他会 CAS 失败,那么此时 CAS 成功的线程会负责从线程池中获取另外一个线程执行上面的 flush 方法,从而获取 WriteQueue 中的数据帧然后发送出去。

有了底层这套设计之后,对于 TripleInvoker 而 ,它只需要把要发送的数据封装为数据帧,然后添加到 WriteQueue 中就可以了。

在 TripleInvoker 的 doInvoke() 源码中,在创建完成 Socket 连接后,就会:

1.基于 Socket 连接先构造一个 ClientCall 对象

2.根据当前调用的方法信息构造一个 RequestMetadata 对象,这个对象表示,当前调用的是哪个接口的哪个方法,并且记录了所配置的序列化方式,压缩方式,超时时间等

3.紧接着构造一个 ClientCall.Listener,这个 Listener 是用来处理响应结果的,针对不同的流式调用类型,会构造出不同的 ClientCall.Listener:UNARY:会构造出一个 UnaryClientCallListener,内部包含了一个 DeadlineFuture,DeadlineFuture 是用来控制 timeout 的SERVER_STREAM:会构造出一个 ObserverToClientCallListenerAdapter,内部包含了调用方法时传入进来的 StreamObserver 对象,最终就是由这个StreamObserver 对象来处理响应结果的BI_STREAM:和 SERVER_STREAM 一样,也会构造出来一个 ObserverToClientCallListenerAdapter

4.紧着着,就会调用 ClientCall 对象的 start 方法创建一个 Stream,并且返回一个 StreamObserver 对象

5.得到了 StreamObserver 对象后,会根据不同的流式调用类型来使用这个 StreamObserver 对象UNARY:直接调用 StreamObserver 对象的 onNext() 方法来发送方法参数,然后调用 onCompleted 方法,然后返回一个 new AsyncRpcResult(future, invocation),future 就是 DeadlineFuture,后续会通过 DeadlineFuture 同步等待响应结果的到来,并最终把获取到的响应结果返回给业务方法。SERVER_STREAM:直接调用 StreamObserver 对象的 onNext() 方法来发送方法参数,然后调用 onCompleted 方法,然后返回一个 new AsyncRpcResult(CompletableFuture.completedFuture(new AppResponse()), invocation),后续不会同步了,并且返回 null 给业务方法。BI_STREAM:直接返回 new AsyncRpcResult( CompletableFuture.completedFuture(new AppResponse(requestObserver)), invocation),也不同同步等待响应结果了,而是直接把 requestObserver 对象返回给了业务方法。所以我们可以发现,不管是哪种流式调用类型,都会先创建一个 Stream,得到对应的一个 StreamObserver 对象,然后调用 StreamObserver 对象的onNext 方法来发送数据,比如发送服务接口方法的入参值,比如一个 User 对象:在发送 User 对象之前,会先发送请求头,请求头中包含了当前调用的是哪个接口、哪个方法、版本号、序列化方式、压缩方式等信息,注意请求头中会包含一些 gRPC 相关的 key,主要就是为了兼容 gRPC然后就是发送请求体然后再对 User 对象进行序列化,得到字节数组然后再压缩字节数组然后把压缩之后的字节数组以及是否压缩标记生成一个 DataQueueCommand 对象,并且把这个对象添加到 writeQueue 中去,然后执行scheduleFlush(),该方法就会开启一个线程从 writeQueue 中获取数据进行发送,发送时就会触发 DataQueueCommand 对象的 doSend 方法进行发送,该方法中会构造一个 DefaultHttp2DataFrame 对象,该对象中由两个属性 endStream,表示是不是 Stream 中的最后一帧,另外一个属性为content,表示帧携带的核心数据,该数据格式为:第一个字节记录请求体是否被压缩紧着的四个字节记录字节数组的长度后面就真正的字节数据以上是 TripleInvoker 发送数据的流程,接下来就是 TripleInvoker 接收响应数据的流程,ClientCall.Listener 就是用来监听是否接收到的响应数据的,不同的流式调用方式会对应不同的 ClientCall.Listener:UNARY:UnaryClientCallListener,内部包含了一个 DeadlineFuture,DeadlineFuture 是用来控制 timeout 的SERVER_STREAM:ObserverToClientCallListenerAdapter,内部包含了调用方法时传入进来的 StreamObserver 对象,最终就是由这个StreamObserver 对象来处理响应结果的BI_STREAM:和 SERVER_STREAM 一样,也会构造出来一个 ObserverToClientCallListenerAdapter那现在要了解的就是,如何知道某个 Stream 中有响应数据,然后触发调用 ClientCall.Listener 对象的相应的方法。要监听某个 Stream 中是否有响应数据,这个肯定是 Netty 来做的,实际上,在之前创建 Stream 时,会向 Http2StreamChannel 绑定一个TripleHttp2ClientResponseHandler,很明显这个 Handler 就是用来处理接收到的响应数据的。在 TripleHttp2ClientResponseHandler 的 channelRead0 方法中,每接收一个响应数据就会判断是 Http2HeadersFrame 还是 Http2DataFrame,然后调用 ClientTransportListener 中对应的 onHeader 方法和 onData 方法:onHeader 方法通过处理响应头,会生成一个 TriDecoder,它是用来解压并处理响应体的onData 方法会利用 TriDecoder 的 deframe() 方法来处理响应体另外如果服务提供者那边调用了 onCompleted 方法,会向客户端响应一个请求头,endStream 为 true,表示响应结束,也会触发执行 onHeader 方法,从而会调用 TriDecoder 的 close() 方法.TriDecoder 的 deframe() 方法在处理响应体数据时,会分为两个步骤:先解析前 5 个字节,先解析第 1 个字节确定该响应体是否压缩了,再解析后续 4 个字节确定响应体内容的字节长度然后再取出该长度的字节作为响应体数据,如果压缩了,那就进行解压,然后把解压之后的字节数组传递给 ClientStreamListenerImpl 的onMessage() 方法,该方法就会按对应的序列化方式进行反序列化,得到最终的对象,然后再调用到最终的 UnaryClientCallListener 或者ObserverToClientCallListenerAdapter 的 onMessage() 方法。TriDecoder 的 close() 方法最终也会调用到 UnaryClientCallListener 或者 ObserverToClientCallListenerAdapter 的 close() 方法。UnaryClientCallListener,构造它时传递了一个 DeadlineFuture 对象:onMessage() 接收到响应结果对象后,会把结果对象赋值给 appResponse 属性onClose() 会取出 appResponse 属性记录的结果对象构造出来一个 AppResponse 对象,然后调用 DeadlineFuture 的 received 方法,从而将方法调用线程接阻塞,并得到响应结果对象。ObserverToClientCallListenerAdapter,构造它时传递了一个 StreamObserver 对象:onMessage() 接收到响应结果对象后,会调用 StreamObserver 对象的 onNext(),并把结果对象传给 onNext() 方法,从触发了程序员的 onNext() 方法逻辑。onClose() 就会调用 StreamObserver 对象的 onCompleted(),或者调用 onError() 方法

Triple 请求处理和响应结果发送

其实这部分内容和发送请求和处理响应是非常类似的,无非就是把视角从消费端切换到服务端,前面分析的是消费端发送和接收数据,现在要分析的是服务端接收和发送数据。

消费端在创建一个 Stream 后,会生成一个对应的 StreamObserver 对象用来发送数据和一个 ClientCall.Listener 用来接收响应数据,对于服务端其实也一样,在接收到消费端创建 Stream 的命令后,也需要生成一个对应的 StreamObserver 对象用来响应数据以及一个 ServerCall.Listener 用来接收请求数据。

在服务导出时,TripleProtocol 的 export 方法中会开启一个 ServerBootstrap,并绑定指定的端口,并且最重要的是,Netty 会负责接收创建 Stream 的信息,一旦就收到这个信号,就会生成一个 ChannelPipeline,并给 ChannelPipeline 绑定一个 TripleHttp2FrameServerHandler,而这个TripleHttp2FrameServerHandler 就可以用来处理 Http2HeadersFrame 和 Http2DataFrame。

比如在接收到请求头后,会构造一个 ServerStream 对象,该对象有一个 ServerTransportObserver 对象,ServerTransportObserver 对象就会真正来处理请求头和请求体:

1.onHeader() 方法,用来处理请求头比如从请求头中得到当前请求调用的是哪个服务接口,哪个方法构造一个 TriDecoder 对象,TriDecoder 对象用来处理请求体构造一个 ReflectionServerCall 对象并调用它的 doStartCall() 方法,从而生成不同的 ServerCall.ListenerUNARY:UnaryServerCallListenerSERVER_STREAM:ServerStreamServerCallListenerBI_STREAM:BiStreamServerCallListener并且在构造这些 ServerCall.Listener 时会把 ReflectionServerCall 对象传入进去,ReflectionServerCall 对象可以用来向客户端发送数据

2.onData() 方法,用来处理请求体,调用 TriDecoder 对象的 deframe 方法来处理请求体,如果是 endStream,那还会调用 TriDecoder 对象的 close 方法

TriDecoder:

deframe():这个方法的作用和客户端时一样的,都是先解析请求体的前 5 个字节,然后解压请全体,然后反序列化得到请求参数对象,然后调用不同的ServerCall.Listener 中的 onMessage()

close():当客户端调用 onCompleted 方法时,就表示发送数据完毕,此时会发送一个 DefaultHttp2DataFrame 并且 endStream 为 true,从而会触发服务端TriDecoder 对象的 close() 方法,从而调用不同的 ServerCall.Listener 中的 onComplete()

UnaryServerCallListener:

1.在接收到请求头时,会构造 UnaryServerCallListener 对象,没什么特殊的

2.然后接收到请求体时,请求体中的数据就是调用接口方法的入参值,比如 User 对象,那么就会调用 UnaryServerCallListener 的 onMessage() 方法,在这个方法中会把 User 对象设置到 invocation 对象中

3.当消费端调用 onCompleted() 方法,表示请求体数据发送完毕,从而触发 UnaryServerCallListener 的 onComplete() 方法,在该方法中会调用 invoke() 方法,从而执行服务方法,并得到结果,得到结果后,会调用 UnaryServerCallListener 的 onReturn() 方法,把结果通过 responseObserver 发送给消费端,并调用 responseObserver 的 onCompleted() 方法,表示响应数据发送完毕,responseObserver 是 ReflectionServerCall 对象的一个 StreamObserver 适配对象(ServerCallToObserverAdapter)。

再来看 ServerStreamServerCallListener:

1.在接收到请求头时,会构造 ServerStreamServerCallListener 对象,没什么特殊的

2.然后接收到请求体时,请求体中的数据就是调用接口方法的入参值,比如 User 对象,那么就会调用 ServerStreamServerCallListener 的 onMessage() 方法,在这个方法中会把 User 对象以及 responseObserver 对象设置到 invocation 对象中,这是和 UnaryServerCallListener 不同的地方,UnaryServerCallListener 只会把 User 对象设置给 invocation,而 ServerStreamServerCallListener 还会把 responseObserver 对象设置进去,因为服务 端流需要这个 responseObserver 对象,服务方法拿到这个对象后就可以自己来控制如何发送响应体,并什么时候调用 onCompleted() 方法来表示响应体发送完毕。

3.当消费端调用 onCompleted() 方法,表示请求体数据发送完毕,从而触发 ServerStreamServerCallListener 的 onComplete() 方法,在该方法中会调用invoke() 方法,从而执行服务方法,从而会通过 responseObserver 对象来发送数据

4.方法执行完后,仍然会调用 ServerStreamServerCallListener的onReturn() 方法,但是个空方法

再来看最后一个 BiStreamServerCallListener:

1.在接收到请求头时,会构造 BiStreamServerCallListener 对象,这里比较特殊,会把 responseObserver 设置给 invocation 并执行 invoke() 方法,从而执行服务方法,并执行 onReturn() 方法,onReturn() 方法中会把服务方法的执行结果,也是一个 StreamObserver 对象,赋值给 BiStreamServerCallListener 对象的requestObserver 属性。

2.这样,在接收到请求头时,服务方法就会执行了,并且得到了一个 requestObserver,它是程序员定义的,是用来处理请求体的,另外的 responseObserver是用来发送响应体的。

3.紧接着就会收到请求体,从而触发 onMessage() 方法,该方法中会调用 requestObserver 的 onNext() 方法,这样就可以做到,服务端能实时的接收到消费端每次所发送过来的数据,并且进行处理,处理过程中,如果需要响应就可以利用 responseObserver 进行响应

4.一旦消费端那边调用了 onCompleted() 方法,那么就会触发 BiStreamServerCallListener 的 onComplete 方法,该方法中也就是调用 requestObserver 的onCompleted(),主要就触发程序员自己写的 StreamObserver 对象中的 onCompleted(),并没有针对底层的 Stream 做什么事情。

总结

不管是 Unary,还是 ServerStream,还是 BiStream,底层客户端和服务端之前都只有一个 Stream,它们三者的区别在于:

1.Unary:通过流,将方法入参值作为请求体发送出去,而且只发送一次,服务端这边接收到请求体之后,会执行服务方法,得到结果,把结果返回给客户端,也只响应一次。

2.ServerStream:通过流,将方法入参值作为请求体发送出去,而且只发送一次,服务端这边接收到请求体之后,会执行服务方法,并且会把当前流对应的StreamObserver 对象也传给服务方法,由服务方法自己控制如何响应,响应几次,响应什么数据,什么时候响应结束,都由服务方法自己控制。

3.BiStream,通过流,客户端和服务端,都可以发送和响应多次。

相关推荐

京东云推出全新JoyCode智能编码工具,让AI Coding从代码生成走向成果交付

全新JoyCode结合项目背景与任务目标,通过Agent Loop持续规划、执行、验证与迭代,并支持多智能体并行协作、模型灵活配置及工具与流程复用,贯通从需求分析到开发验证的任务链路,推动AI Coding从代码生成走向可运行软件与可用工具的成果交付。模型使用的关键,不只是选择更强的能力,而是让投入与任务需要相匹配。作为面向严肃开发场景的企业级编码产品,京东云JoyCode所拓展的,不只是代码生成的能力,更是将专业经验与日常灵感付诸实现的路径,让技术承接实现过程中的繁复,让人更专注于问题、判断与创造。

京东科技开发者 67

GPT-6凌晨上线智能UI:智能UI时代的技术架构重构与应对之道

从命令行到图形界面,计算机行业用了三十年证明了同一件事:人类需要视觉的、空间的、可重复的交互表面,纯文字从来只是过渡形态。智能界面的出现,意味着AI行业第一次大规模承认了这个规律——对话是创造的接口,界面是使用的归宿。生成的界面如何稳定下来?个人的数据与身份如何安全地沉淀?Agent的行动能力如何可信地放大?谁能把这三个问题答好,谁就站在了Personal Agent图形界面时刻的浪潮之巅。

京东科技开发者 230

AI 会写代码之后,交付为什么还没变快?

AI 写代码,只是这场变革的起点,而不是终点。真正决定一个组织能否吃到 AI 红利的,不是"能不能用 AI 写出代码",而是敢不敢用 AI 重新设计交付流程、重新划分角色分工、重新组织团队结构。研发视角能把工具和个人推到极致,却会在组织的边界前止步;只有站上组织视角,把AI × 工具一路推进到AI × 组织,那些被 AI 照出来的摩擦,才会真正被抹平。国际技术部 Multi AI Native 想做的,正是这件事——让 Agent 成为你可靠的数字战友,让每一次迭代交付都快一个量级;

京东科技开发者 319

OxygenData-Vibe搭建:用 AI Coding重新定义数据看板搭建

长期以来,数据看板开发主要有两种方式:一种是使用标准化 BI 工具,交付快、成本低,但图表样式、交互体验和功能扩展都受限于 BI 本身的能力;另一种是自研定制开发,能够充分满足复杂和个性化需求,但需要投入大量研发资源,交付周期也更长。比如一个通过 BI 只需要 1 天就能搭建出来的看板,如果采用自研方式,可能需要投入 30 PD 的研发人力。既然 BI 交付这么快,为什么不把所有看板需求都交给 BI?原因在于,业务某些场景需要的不只是把数据展示出来。

京东科技开发者 382

当我谈数据库高可用时我谈些什么

大家都经常听到说数据库的双1,那双1指的是什么呢?参数=1(最安全)≠1(更快但可能丢)每次提交都把 redo 刷盘0/2:攒着刷,崩溃丢最近 1 秒每次提交都把 binlog 刷盘0/N:攒着刷,崩溃丢最近若干条"双 1"(都设为 1)= 单机不丢已提交事务的前提。生产核心库必须双 1;代价是每次提交两次 fsync。小结:单机层用 WAL 提速、用 2PC 保证 redo/binlog 一致、用崩溃恢复裁决半成品事务、用双 1 兜底持久性。

京东科技开发者 324

ScoAI:面向供应链的运筹原生决策智能

ScoAI 关注的并非 AI 能否进入供应链,而是 AI 参与供应链决策之后,哪些内容适合通过数据学习,哪些关系必须显式计算,以及哪些结果需要依据执行记录进行验证。其基本分工是:供应链业务定义问题、资源与行动后果,运筹学表达目标、约束和协同关系,AI 提供可复用的估计与判断。真正用于改进后续决策的,不仅是模型生成的初始结果,还包括实际采取的行动及其产生的业务反馈。

京东科技开发者 408

拆解海博 AI-Native 落地保障:海博团队 AI 知识库能力建设

绕了一大圈,回头看,我们其实一直在解开头那三个结:AI 读不懂系统、影响面靠人脑记、测试预期没处查。做到这里,本质上是把"AI 用不好"这个问题,从"是不是该换个更强的模型"重新定义成了"怎么把上下文经营好"。顺着这个思路,我们攒下了这么几样东西:•。

京东科技开发者 565

从零构建一个生产级记忆型 AI Agent —— AgentScope 项目全景技术与学习指南

domain 层端口接口(domain)职责适配器实现(infra)对话流水账读写经验记忆检索/落库请求级幂等四态会话元数据 CRUD会话级 Skill 选择态Skill 元数据HITL 权限网关(domain 内含逻辑,见第四篇)StreamSink技术中立的流式下沉(client 层桥接)以幂等端口为例,头部注释明确写道:实现 domain 端口,持有实体不出 infra 边界,对外只暴露嵌套视图GateResult。

京东科技开发者 617

数据涅槃:Agentic 重塑搜推数据生产体系

当前大模型已经能够理解需求、生成代码和解释错误,但数据生产的难点并不只是“写出一段 SQL”。一个需求还要经过数据源确认、口径澄清、加工编排、资源规划、任务提交、调度运行、结果交付和故障处置。任何一步缺少都可能让“看起来正确”的任务变成生产事故。

京东科技开发者 387

81.8 秒的视频,我们改了 15 个版本:一次纯 Codex 驱动的 AI-native 视频实践

81.8 秒、15 个版本,这些数字真正想说明什么?视频制作正在从一组专业软件里的复杂操作,变成一场围绕目标、参考和反馈展开的持续对话。AI 已经可以接住从脚本到交付的大量工作。你可以把精力留给更重要的部分:理解观众、选择故事、判断好坏。过去停在 PPT 和脑海里的想法,现在有机会被快速做成一支能看、能改、也愿意转发的视频。如果明天就要介绍你手头的项目,你最想先把哪一步交给 AI?

京东科技开发者 471

Codex 驱动的移动端AI全栈开发:从 Relay 原型图到可交付链路

AI 编程工具降低了跨端开发门槛,但“让 AI 写页面”并不等于“完成移动端交付”。PC 运营端页面通常以功能闭环为中心,设计约束较弱,研发可以基于组件库快速搭建;移动端 C 端页面直接面对用户,Relay 原型图和 UI 设计稿不仅是视觉参考,更是交互、信息层级、状态反馈和业务信任感的综合契约。

京东科技开发者 597

Claude Code vs Codex 记忆体系深度对比

Claude Code —— 分层自动记忆系统四层分层架构(CLAUDE.md / Auto Memory / Session Memory / AutoDream)构成自优化闭环,系统主动捕获、分类、去冗并跨会话接力经验。走的是自动化优先路线——让机器替人记忆、替人整理,以少量可控性的不确定换取强大的经验积累能力。Codex —— 声明式契约系统两层扁平架构(AGENTS.md 静态声明层 + 会话上下文层),记忆完全由人显式订立、显式修改,系统只读契约、绝不擅自变更。走的是可控性优先。

京东科技开发者 631

上游给空、下游拿到 -1,我把故障一直追到了 commons-beanutils 的构造函数

这篇手记是一份事后复盘,写在我们已经把修复推上线、把测试用例跑绿、把约束文档沉淀进团队库之后。非研发同事,可以直接从第八章开始看,前七章都是讲排障和代码分析。故障本身不复杂,修复也不复杂,但这次排查真正让我想写下来的,不是技术本身——而是从问题提报到解决全程AI的作用:问题定位:业务方反馈了一个异常单号说「下发失败」,一线运维同事直接在日志系统捞到相关的系统日志,用IDE打开下游代码库,把异常信息给到JoyCode——AI 直接指向了问题是serialType值非法,系统只接受0和1,而当前上游给的是-1。

京东科技开发者 720

SKill测评:谁才是真正的Skill之王?

巧合的是,阿里近期开源了一款名为 Skill-Up 的测评工具——它专门面向 Agent Skill 开发者,支持在 Claude Code、Codex、Qoder CLI 等真实 Agent Engine 环境中验证 Skill 的功能正确性,并可将失败用例转化为精准的修复指引,同时支持本地与 CI 环境的持续回归。2026年,Skill 的热度不减,已成为 AI 辅助编程领域的标配。在日常研发中,无论是沉淀个人经验,还是将团队的优秀范本标准化,将知识“蒸馏”为 Skill 已是大家的常规操作。

京东科技开发者 641

让AI真正参与工作!JoyDesk已上线京东云

JoyDesk提供覆盖AI资产管理、权限控制、安全策略、审批审计、运营监控等企业级治理能力,支持按组织、角色和项目进行精细化权限管理,并支持私有化部署,确保企业数据边界清晰、AI行为全程可追溯、安全策略灵活可配置,满足金融、政企等行业对数据安全和合规治理的要求,让AI真正成为企业可信赖的生产力。JoyDesk支持MCP协议、标准API、技能等多种开放接入方式,可快速连接企业现有业务系统,将业务能力封装为AI可调用的技能和专家,让AI能够理解业务流程、调用业务系统、完成业务任务,而无需改变企业原有IT架构。

京东科技开发者 675

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手【最终版】

这个项目展示了AI Agent 在垂直内容创作领域端到端自动化:从内容理解到播客输出,全流程 AI 驱动多模态融合:文字、图片、音频、视频统一处理专业级音频质量:音色设计 + 智能混音,输出广播级品质低门槛使用:可视化配置 + 自然语言交互,无需技术背景。

京东科技开发者 564

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(高级篇)

这是一个 AI 驱动的播客创作助手,专注于从文字/视频/音频内容识别到播客制作的全流程。你可以用自然语言与它对话,也可以上传视频和音频,它会理解意图、调用相应的语音合成工具,把他们变成真实的播客音频。

京东科技开发者 728

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(进阶篇)

这是一个AI 驱动的音频内容创作助手。你可以用自然语言与它对话,它会理解意图、调用相应的语音合成工具,把文字变成真实的播客音频,并保存在本地。关于项目的详细介绍见第一篇文章:第一个 AI Agent 项目:从零搭建 AI 音频创作助手(入门篇)这篇文章更多介绍进阶篇添加的功能。

京东科技开发者 553

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(入门篇)

这个项目让我第一次把前端、后端、AI Agent 三块内容独立串联起来。技术选型上每一块都是当下主流的方案,实际跑通整条链路之后对"全栈"有了更具体的感受。框架版本要锁定:LangChain 这类快速迭代的框架,版本差异带来的问题远比你想象的多先跑通链路,再追求完美:新手阶段能把用户输入 → AI 处理 → 结果展示这条链跑通,比深入某个技术点更有价值多看官方文档:相比博客和教程,官方文档更新及时,特别是 LangGraph 这种新框架后续计划继续迭代,欢迎交流!

京东科技开发者 611

ICLR 2026 | 面向序列决策的贝叶斯集成方法

在这篇工作中,我们关注的是。

京东科技开发者 296

ICML 2026|NaviAgent:面向 Oxygen 智能体的可扩展工具编排

大型语言模型(LLM)越来越多地作为函数调用代理,调用外部工具来处理超出其静态知识范围的任务。然而,它们通常一次只调用一个工具,缺乏对任务结构的全局视图。由于工具之间往往相互依赖,这会导致错误累积和可扩展性差,尤其是在扩展到数百或数千个工具时。为了解决这些局限性,我们提出了NaviAgent,一种显式的双层架构,它通过基于图的工具关系建模将任务规划与工具执行解耦。在规划层,基于 LLM 的代理决定是直接响应、澄清意图,还是检索并执行一个独立于工具间复杂性的工具链。

京东科技开发者 389

实测 9 款 AI 架构图工具:从 Mermaid 美化到 GPT-Image2,一份选型清单

支持 5 类图(架构图、工作流图、时序图、数据流图、生命周期/状态机图),主题 4 种(Classic、Signal Flow、Blueprint、Editorial)+ 3 种色彩模式(Dark / Light / System Auto),输出格式含 HTML、PNG、SVG、WebM、Share Card PNG、JSON IR。它把提示词图库、图像生成案例、参考图编辑流程和命令行工具整合在一起,让 AI Agent 能直接调用 GPT Image 2 模型完成文生图、图生图、参考图编辑等任务。

京东科技开发者 909

别再守着 Claude Code 了——学会指挥它自主干活

回到开头那句:别再一句一句地喂它、然后守着屏幕。真正的用法是——把一件事想清楚、划好边界、给它一个能自我验证的目标,然后交出去。你会发现,省下来的时间不是一点半点。把重复的判断和执行还给机器,把真正需要你的判断留给自己。

京东科技开发者 587

CVPR 2026|Oxygen XR 团队在原生鱼眼高斯泼溅技术上带来新突破

京东零售技术团队联合清华大学提出DirectFisheye-GS框架,创新性地将鱼眼相机模型原生嵌入3D高斯泼溅管线,通过跨视角联合优化策略直接处理鱼眼图像,避免了传统去畸变预处理导致的信息损失。该方案在多个公开数据集上达到SOTA性能,有效解决了单视角优化引起的几何畸变和视角不一致问题,同时保持与现有3DGS工具链的兼容性。技术已应用于电商3D重建和4D体积视频等场景,显著提升了沉浸式体验。相关论文被CVPR 2026接收,为宽视场场景重建提供了高效解决方案。

京东科技开发者 355

拆解海博 AI-Native 落地保障:Harness、双 Loop、知识库与技能自主迭代实践

海博研发RoadMap 的落地,彻底终结了 AI 编程“对话式玄学”的旧模式,真正落地了AI Native 研发工程化。它证明 AI 规模化赋能研发的核心,不在于堆砌大模型能力,而在于用工程思维重构 AI 的工作范式:用结构化流程替代随机对话,用固化规则约束模型行为,用持续沉淀实现能力复利,用分层架构支撑规模化落地。

京东科技开发者 638

让 AI 快速「读懂」你的代码仓:Joy-Code-Graph 云端图谱服务的三次进化

代码知识图谱不是要取代 AI 的智能,而是要补齐它对代码全局关系的认知盲区。当 AI 能一眼看清「谁调用了谁、改动会波及哪里」,它写出的代码才真正靠谱;当这份认知安全地留在自己手里、随时被 Joygen 调用、并且永久沉淀在代码仓里——AI 编程的体验,才算真正上了一个台阶。这,就是我们做 Joy-Code-Graph 云端服务的初衷。能力共享,数据自主;一次建图,长期受用。

京东科技开发者 752

【Coding生态】从代码托管到 AI 能力底座:与Coding一起共建 AI 研发生态

前两种框架能够很好地支撑对话式能力和预设流程式能力。它们适合基于提示词或预设工作流完成研发问答、知识查询、流程编排等任务。但在更复杂的研发场景中,仅仅“回答问题”还不够。当用户业务逻辑复杂时,一旦场景进入真实落地阶段,例如下载代码、修改文件、执行命令、安装依赖、运行测试、读取完整代码文件,或者与自有系统联动、将结果渲染到 Coding 页面、推送到京 ME,AI 应用需要的不只是知识能力,还需要真实的代码库操作能力和独立可执行环境。

京东科技开发者 768

GPT-5.6、ChatGPT Work 与 Codex 更新食用指南

三档模型当前都提供 1,050,000 tokens 上下文、922,000 tokens 最大输入和 128,000 tokens 最大输出,接受文本与图像输入、输出文本,并支持 web search、file search、Computer Use、MCP、Tool Search、Skills、Apply Patch 等工具。Work 可以读取你提供的文件,通过插件连接 Slack、Google Drive、SharePoint、邮箱、日历、CRM 或项目系统,调用获批工具,并在执行中展示进度。

京东科技开发者 873

把业务流程沉淀成高质量 Skill 的实践路径

使用Record & Replay创建的Skill,尽管创建流程简单,但它的本质实际是让 AI 去操作页面,这不但有可能影响我们对电脑的操作,还有可能无法稳定复现。创建Skill时,可以使用 Codex 的 Record & Replay 插件,把一次手工操作录下来,再让 AI 生成可复用流程。刚开始切换时,很容易遇到接口报错,可以让Codex排查原因进行优化,直到可以稳定执行;补充相应业务背景,说明这件事为什么要做,谁会用,输入从哪来,输出给谁看。电脑休眠、关机、软件没开时,本地任务可能无法执行。

京东科技开发者 836

政企前台AI-Agent的架构实践:打造可复用的 AI 服务平台-【灯塔计划】

不止是爆火的龙虾,还是各种Skills,MCP、Agent,脱离的具体的场景谈方案,最后只会是一场空。这一套可复用的 AI 服务平台,截止目前,通过前后端对接规范文档,多项能力已快速接入到各个场域的不同端平台,大幅降低研发成本, 并且各业务线新场景的接入从原来的 “开发驱动” 转为 “配置驱动”,接入周期从天维度缩短至小时级。

京东科技开发者 864
上一篇: 计算机网络协议介绍
下一篇: 【稳定性】浅谈团队如何做好系统稳定性
京东云开发者
京东云开发者 企业官方账号 企业官方账号
博客等级 码龄8年 1万+粉丝 2141原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值