dubbo服务调用过程

我会带着你远行 2023-10-09 12:12 56阅读 0赞

## 1. 调用图解 ##

下图为dubbo官方的一张调用图

![format_png][]

> 1） 从client到server经历了编码，序列化，反序列化，解码 的正常网络调用流程, 在nettyServer中处理
> 
> 2）client采用代理的机制
> 
> 3）server处理请求的方式通常为分发请求到线程池，同步阻塞或异步非阻塞返回结果

## 2. 对应到dubbo的内部的类 ##

代理：   InvokerInvocationHandler

代理工厂： JavassistProxyFactory

public class JavassistProxyFactory extends AbstractProxyFactory {
        public JavassistProxyFactory() {
        }
    
        public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
            return Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
        }
    
        public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
            final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf(36) < 0 ? proxy.getClass() : type);
            return new AbstractProxyInvoker<T>(proxy, type, url) {
                protected Object doInvoke(T proxy, String methodName, Class<?>[] parameterTypes, Object[] arguments) throws Throwable {
                    return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
                }
            };
        }
    }

被代理的对象：MockClusterInvoker

>     private final Directory<T> directory;
>     private final Invoker<T> invoker;

参数： RpcInvocation

>     private static final long serialVersionUID = -4355285085441097045L;
>     private String methodName;
>     private Class<?>[] parameterTypes;
>     private Object[] arguments;
>     private Map<String, String> attachments;
>     private transient Invoker<?> invoker;
>     private transient Class<?> returnType;
>     private transient InvokeMode invokeMode;

类调用路径

>  
> 
>     proxy0#sayHello(String)
>       —> InvokerInvocationHandler#invoke(Object, Method, Object[])
>         —> MockClusterInvoker#invoke(Invocation)
>           —> AbstractClusterInvoker#invoke(Invocation)
>             —> FailoverClusterInvoker#doInvoke(Invocation, List<Invoker<T>>, LoadBalance)
>               —> Filter#invoke(Invoker, Invocation)  // 包含多个 Filter 调用
>                 —> ListenerInvokerWrapper#invoke(Invocation) 
>                   —> AbstractInvoker#invoke(Invocation) 
>                     —> DubboInvoker#doInvoke(Invocation)
>                       —> ReferenceCountExchangeClient#request(Object, int)
>                         —> HeaderExchangeClient#request(Object, int)
>                           —> HeaderExchangeChannel#request(Object, int)
>                             —> AbstractPeer#send(Object)
>                               —> AbstractClient#send(Object, boolean)
>                                 —> NettyChannel#send(Object, boolean)
>                                   —> NioClientSocketChannel#write(Object)
> 
>

## 3 编解码过程  ##

在 Netty 中，出站数据在发出之前还需要进行编码操作，接下来我们来分析一下请求数据的编码逻辑。

首先Dubbo数据包结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70][]

默认编码方式为hessian2,对应类为Hessian2Serialization

>     String codecName = url.getParameter("codec", "telnet");
> 
> // 默认为dubbo
> 
>     dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboCountCodec
> 
> // 借助DubboCodec实现

public final class DubboCountCodec implements Codec2 {
        private DubboCodec codec = new DubboCodec();
    
        public DubboCountCodec() {
        }

Netty的编解码配置

>     NettyCodecAdapter adapter = new NettyCodecAdapter(NettyServer.this.getCodec(), NettyServer.this.getUrl(), NettyServer.this);
>     ch.pipeline().addLast("decoder", adapter.getDecoder()).addLast("encoder", adapter.getEncoder()).addLast("server-idle-handler", new IdleStateHandler(0L, 0L, (long)idleTimeout, TimeUnit.MILLISECONDS)).addLast("handler", nettyServerHandler);

protected void doOpen() throws Throwable {
            this.bootstrap = new ServerBootstrap();
            this.bossGroup = new NioEventLoopGroup(1, new DefaultThreadFactory("NettyServerBoss", true));
            this.workerGroup = new NioEventLoopGroup(this.getUrl().getPositiveParameter("iothreads", Constants.DEFAULT_IO_THREADS), new DefaultThreadFactory("NettyServerWorker", true));
            final NettyServerHandler nettyServerHandler = new NettyServerHandler(this.getUrl(), this);
            this.channels = nettyServerHandler.getChannels();
            ((ServerBootstrap)this.bootstrap.group(this.bossGroup, this.workerGroup).channel(NioServerSocketChannel.class)).childOption(ChannelOption.TCP_NODELAY, Boolean.TRUE).childOption(ChannelOption.SO_REUSEADDR, Boolean.TRUE).childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT).childHandler(new ChannelInitializer<NioSocketChannel>() {
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    int idleTimeout = UrlUtils.getIdleTimeout(NettyServer.this.getUrl());
                    NettyCodecAdapter adapter = new NettyCodecAdapter(NettyServer.this.getCodec(), NettyServer.this.getUrl(), NettyServer.this);
                    ch.pipeline().addLast("decoder", adapter.getDecoder()).addLast("encoder", adapter.getEncoder()).addLast("server-idle-handler", new IdleStateHandler(0L, 0L, (long)idleTimeout, TimeUnit.MILLISECONDS)).addLast("handler", nettyServerHandler);
                }
            });
            ChannelFuture channelFuture = this.bootstrap.bind(this.getBindAddress());
            channelFuture.syncUninterruptibly();
            this.channel = channelFuture.channel();
        }

## 4.   消费者启动流程 ##

消费者调用的流程图如下：

## ![format_png 1][] ##

>  1） 配置信息读取
> 
> 2） 消费者信息组装
> 
> 3） 构建默认集群容错，路由链，负载均衡，注册中心
> 
> 4） 消费者信息注册到注册中心，紧接着订阅 providers、configurators、routers 等节点下的数据。
> 
> 5） netty客户端启动
> 
> 6） 与服务端通信

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
            RegistryDirectory<T> directory = new RegistryDirectory(type, url);
            directory.setRegistry(registry);
            directory.setProtocol(this.protocol);
            Map<String, String> parameters = new HashMap(directory.getUrl().getParameters());
            URL subscribeUrl = new URL("consumer", (String)parameters.remove("register.ip"), 0, type.getName(), parameters);
            if (!"*".equals(url.getServiceInterface()) && url.getParameter("register", true)) {
                directory.setRegisteredConsumerUrl(this.getRegisteredConsumerUrl(subscribeUrl, url));
                registry.register(directory.getRegisteredConsumerUrl());
            }
            // 构建路由链
            directory.buildRouterChain(subscribeUrl);
            directory.subscribe(subscribeUrl.addParameter("category", "providers,configurators,routers"));
            Invoker invoker = cluster.join(directory);
            // 消费者信息注册到注册中心
            ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
            return invoker;
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 1][]

![20190929173634523.png][]

public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
            return new HeaderExchangeClient(Transporters.connect(url, new ChannelHandler[]{new DecodeHandler(new HeaderExchangeHandler(handler))}), true);
        }

![20190929173725895.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 3][]

>  // 编解码
> 
>     NettyCodecAdapter adapter = new NettyCodecAdapter(NettyClient.this.getCodec(), NettyClient.this.getUrl(), NettyClient.this);
> 
> // Socket连接
> 
>     Socks5ProxyHandler socks5ProxyHandler = new Socks5ProxyHandler(new InetSocketAddress(socksProxyHost, socksProxyPort));

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1YmJvLmFwYWNoZS5vcmcvZG9jcy96aC1jbi9zb3VyY2VfY29kZV9ndWlkZS9zb3VyY2VzL2ltYWdlcy9zZW5kLXJlcXVlc3QtcHJvY2Vzcy5qcGc?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190925193719422.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA=,size_16,color_FFFFFF,t_70
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1YmJvLmFwYWNoZS5vcmcvZG9jcy96aC1jbi9zb3VyY2VfY29kZV9ndWlkZS9zb3VyY2VzL2ltYWdlcy9jbHVzdGVyLmpwZw?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190929173620961.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA=,size_16,color_FFFFFF,t_70
[20190929173634523.png]: https://img-blog.csdnimg.cn/20190929173634523.png
[20190929173725895.png]: https://img-blog.csdnimg.cn/20190929173725895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190929173825977.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190929173904561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2Mjc4NDA=,size_16,color_FFFFFF,t_70