dubbo暴露服务的过程解析（从proxy层到exchange、transport层）

最新推荐文章于 2024-06-28 09:00:00 发布

zhifeng687

最新推荐文章于 2024-06-28 09:00:00 发布

阅读量875

点赞数 1

分类专栏： dubbo & spring cloud

dubbo & spring cloud 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

一概述

上个章节已经描述了dubbo发布一个服务，但具体是如何发布服务只是粗略的描述了下，这里将深入描述服务发布时怎么样开启socket监听，即启动netty服务。

二开启netty服务

上一节发布服务的重点入口代码如下

[java] view plain copy
//通过proxyFactory对象生成接口实现类代理对象Invoker  
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));  
//将Invoker对象封装到protocol协议对象中，同时开启socket服务监听端口，这里socket通信是使用netty框架来处理的  
Exporter<?> exporter = protocol.export(invoker);  

先看第一行代码，这里proxyFactory对象为JavassistProxyFactory的实例对象，进入到getInvoker方法。第一个参数是接口的实现对象，第二个参数是即将发布的接口Class,第三个参数是发布协议的URL。查看方法

[java] view plain copy
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);  
        }  
    };  
}  

细看方法内代码，新建了一个抽象类AbstractProxyInvoker，并实现了抽象方法doInvoke。doInvoke中通过反射机制执行要调用的方法。有点基础的一看就知道是getInvoker方法其实反馈的是接口实现类对象的代理对象。
再细看Exporter<?> exporter = protocol.export(invoker);代码。这里protocol默认当做是DubboProtocol类。

[java] view plain copy
/** 
     * 
     * @param invoker 服务的执行体 
     * @param <T> 
     * @return 
     * @throws RpcException 
     */  
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {  
        URL url = invoker.getUrl();  
          
        // export service.  
        String key = serviceKey(url);//根据URL生成一个唯一key值  
        DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);  
        exporterMap.put(key, exporter);//通过map保存当前发布的invoker对象，key为拼装的唯一字符串  
          
        //export an stub service for dispaching event  
        Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY,Constants.DEFAULT_STUB_EVENT);  
        Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);  
        if (isStubSupportEvent && !isCallbackservice){  
            String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);  
            if (stubServiceMethods == null || stubServiceMethods.length() == 0 ){  
                if (logger.isWarnEnabled()){  
                    logger.warn(new IllegalStateException("consumer [" +url.getParameter(Constants.INTERFACE_KEY) +  
                            "], has set stubproxy support event ,but no stub methods founded."));  
                }  
            } else {  
                stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);  
            }  
        }  
  
        openServer(url);//开启netty服务  
  
        // modified by lishen  
        optimizeSerialization(url);  
  
        return exporter;  
    }  

这个方法将传入的Invoker对象封装到DubboExporter对象中，并生成了唯一的key值。同时将key与DubboExporter对象关联保存进入exporterMap中，它是一个支持高并发的ConcurrentHashMap类。当客户端做远程请求服务时，就是根据key值从这个MAP中取出的真正接口实现对象来响应客户端的请求。在后面的代码分析中会体现出来。我们跟进到openServer(url);代码中

[java] view plain copy
/** 
    * 开启netty服务器监听，并保存netty服务对象到map中 
    * @param url 
    */  
   private void openServer(URL url) {  
       // find server.  
       String key = url.getAddress();  
       //client 也可以暴露一个只有server可以调用的服务。  
       boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);  
       if (isServer) {  
        ExchangeServer server = serverMap.get(key);  
        if (server == null) {  
            serverMap.put(key, createServer(url));  
        } else {  
            //server支持reset,配合override功能使用  
            server.reset(url);  
        }  
       }  
   }  

首先判断serverMap中是否已经包含了当前服务的ExchangeServer对象，如果没有调用createServer(url)创建一个并保存到serverMap中。继续跟进到createServer中，在这里调用了Exchangers类的静态方法bind创建了一个ExchangeServer对象，并返回出去了。注意bind方法的两个参数，第一个是URL很熟悉对吧！就不细说了，关键是第二个参数requestHandler，它是ExchangeHandlerAdapter类。它重写了很多父接口中的方法。里面重写了一个received方法，这个就是netty框架在接收到客户端请求以后响应处理的入口。具体处理细节在后面分析。这里继续往下看是怎么启动netty服务的。

[java] view plain copy
private ExchangeServer createServer(URL url) {  
      //默认开启server关闭时发送readonly事件  
      url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());  
      //默认开启heartbeat，最近心跳机制，根据代码应该是设置心跳时间吧  
      url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));  
      String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);  
  
      if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))  
          throw new RpcException("Unsupported server type: " + str + ", url: " + url);  
  
      url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);  
      ExchangeServer server;  
      try {  
          server = Exchangers.bind(url, requestHandler);  
      } catch (RemotingException e) {  
          throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);  
      }  
      str = url.getParameter(Constants.CLIENT_KEY);  
      if (str != null && str.length() > 0) {  
          Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();  
          if (!supportedTypes.contains(str)) {  
              throw new RpcException("Unsupported client type: " + str);  
          }  
      }  
      return server;  
  }  

以下是Exchangers类的静态方法bind的所有处理，getExchanger方法最终返回了HeaderExchanger对象。

[java] view plain copy
public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {  
       if (url == null) {  
           throw new IllegalArgumentException("url == null");  
       }  
       if (handler == null) {  
           throw new IllegalArgumentException("handler == null");  
       }  
       url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");  
       return getExchanger(url).bind(url, handler);  
   }  
  
public static Exchanger getExchanger(URL url) {  
       String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);  
       return getExchanger(type);  
   }  
  
   public static Exchanger getExchanger(String type) {  
       return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);  
   }  

HeaderExchanger类中的bind方法代码如下，细读感觉有点复杂哦！不是太好理解。这不就是装饰器模式么！说实话刚开始看的时候确实很懵逼！感觉乱糟糟的，方法调用就这么跳来跳去，头都晕乎了。将dubbo协议的handler对象最终包装成了DecodeHandler对象，并传入到了Transporters类的bind方法中。

[java] view plain copy
public class HeaderExchanger implements Exchanger {     
  
    public static final String NAME = "header";  
    public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {  
        return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))));  
    }  
  
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {  
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));//装饰器模式处理  
    }  
  
}  

继续跟进Transporters类的bind方法如下。总体思路就是获取Transporter接口的具体实现类，然后调用该实现的bind方法。它有MinaTransporter，NettyTransporter,GrizzlyTransporter三种实现类，这里我就默认使用实现类NettyTransporter了。

[java] view plain copy
public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {  
        if (url == null) {  
            throw new IllegalArgumentException("url == null");  
        }  
        if (handlers == null || handlers.length == 0) {  
            throw new IllegalArgumentException("handlers == null");  
        }  
        ChannelHandler handler;  
        if (handlers.length == 1) {  
            handler = handlers[0];  
        } else {  
            handler = new ChannelHandlerDispatcher(handlers);  
        }  
        return getTransporter().bind(url, handler);  
    }  
      
    public static Transporter getTransporter() {  
        return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();  
    }  

NettyTransporter类的源码如下。关注下bind方法，新建了一个NettyServer对象。是不是感觉离netty越来越近了。

[java] view plain copy
public class NettyTransporter implements Transporter {  
  
    public static final String NAME = "netty";  
      
    public Server bind(URL url, ChannelHandler listener) throws RemotingException {  
        return new NettyServer(url, listener);  
    }  
  
    public Client connect(URL url, ChannelHandler listener) throws RemotingException {  
        return new NettyClient(url, listener);  
    }  
  
}  

在NettyServer类中重点关注两个方法doOpen(它重写了抽象类父类的AbstractServer中的doOpen抽象方法)和它的构造函数。

[java] view plain copy
public NettyServer(URL url, ChannelHandler handler) throws RemotingException{  
        super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));  
    }  
  
    @Override  
    protected void doOpen() throws Throwable {  
        NettyHelper.setNettyLoggerFactory();  
        //启动一个netty服务对象，netty的固定写法不理解可以查查netty资料  
        ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));  
        ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));  
        ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));  
        bootstrap = new ServerBootstrap(channelFactory);  
  
        //这里有点难理解，新建了一个NettyHandler对象，传入了一个this。这个this不就是NettyServer对象么？有点奇怪哈，注意当前类的构造函数调用了super方法，  
        // 将dubbo协议的专用handler对象赋值给了当前类的父类AbstractPeer的handler属性，不太理解为何要这么写。但最终将NettyServer这个对象设置为netty的处理器了  
        final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);  
        channels = nettyHandler.getChannels();  
        // https://issues.jboss.org/browse/NETTY-365  
        // https://issues.jboss.org/browse/NETTY-379  
        // final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));  
        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
            public ChannelPipeline getPipeline() {  
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);  
                ChannelPipeline pipeline = Channels.pipeline();  
                /*int idleTimeout = getIdleTimeout(); 
                if (idleTimeout > 10000) { 
                    pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0)); 
                }*/  
                pipeline.addLast("decoder", adapter.getDecoder());  
                pipeline.addLast("encoder", adapter.getEncoder());  
                pipeline.addLast("handler", nettyHandler);//设置netty接受客户端请求后的处理器  
                return pipeline;  
            }  
        });  
        // bind  
        channel = bootstrap.bind(getBindAddress());  
    }  

看到这里是不是在想是什么时候调用doOpen方法开始启动netty服务的呢。我们查看构造函数跟进super方法的处理。查看父类AbstractServer中的构造函数，细看里面执行了doOpen方法，根据抽象模版方法模式，其实调用的是子类的doOpen方法。到此已经将netty服务开启啦！

[java] view plain copy
public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {  
        super(url, handler);  
        localAddress = getUrl().toInetSocketAddress();  
        String host = url.getParameter(Constants.ANYHOST_KEY, false)   
                        || NetUtils.isInvalidLocalHost(getUrl().getHost())   
                        ? NetUtils.ANYHOST : getUrl().getHost();  
        bindAddress = new InetSocketAddress(host, getUrl().getPort());  
        this.accepts = url.getParameter(Constants.ACCEPTS_KEY, Constants.DEFAULT_ACCEPTS);  
        this.idleTimeout = url.getParameter(Constants.IDLE_TIMEOUT_KEY, Constants.DEFAULT_IDLE_TIMEOUT);  
        try {  
            doOpen();  
            if (logger.isInfoEnabled()) {  
                logger.info("Start " + getClass().getSimpleName() + " bind " + getBindAddress() + ", export " + getLocalAddress());  
            }  
        } catch (Throwable t) {  
            throw new RemotingException(url.toInetSocketAddress(), null, "Failed to bind " + getClass().getSimpleName()   
                                        + " on " + getLocalAddress() + ", cause: " + t.getMessage(), t);  
        }  
  
        executor = (ExecutorService) ExtensionLoader.getExtensionLoader(DataStore.class)  
                .getDefaultExtension().get(Constants.EXECUTOR_SERVICE_COMPONENT_KEY, Integer.toString(url.getPort()));  
    }  

三响应请求

前面段落已经讲解过设置netty响应客户端的处理器是在NettyServer类的doOpen方法中设置的，如代码：

[java] view plain copy
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);  

查看NettyHandler类它继承了netty框架的SimpleChannelHandler类，重写了messageReceived方法。这里messageReceived方法就是接收到客户端请求后参数后处理请求入口处。代码如下：

[java] view plain copy
@Override  
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {  
        NettyChannel channel = NettyChannel.getOrAddChannel(ctx.getChannel(), url, handler);  
        try {  
            handler.received(channel, e.getMessage());  
        } finally {  
            NettyChannel.removeChannelIfDisconnected(ctx.getChannel());  
        }  
    }  

执行了handler的received方法，这里执行的received方法其实就是DubboProtocol类中创建的requestHandler对象，它针对dubbo协议的处理器都封装在了DubboProtocol类中。是不是感觉很乱received方法的最终执行怎么跑到这里面去了。
因为在启动netty服务的时候，就将requestHandler对象经过层层包装传递给了NettyServer，再通过NettyServer类的构造函数将它保存到了NettyServer类的终极父类AbstractPeer的handler属性上，AbstractPeer类又实现了ChannelHandler接口，重写了received方法。
所以当netty框架接收到请求时执行messageReceived方法里面的handler.received(channel, e.getMessage()); ，其实执行的是AbstractPeer类的received方法，received然后里面又执行了handler.received(ch, msg); 这里的handler就是DubboProtocol类中创建的requestHandler对象。
感觉特别绕对不对，刚开始也是整理好了几遍才搞清楚里面的流程。

接着继续看duobbo协议类DubboProtocol中的requestHandler是怎么处理请求的。我们重点看它重写的方法received入口，调用了reply方法，首先将参数message参数转换成了Invocation对象，Invocation封装了客户端的请求信息。
1.根据客户端的请求信息找打响应客户端的Invoker对象
2.检测客户端请求的方法，服务端是否存在
3.执行invoker对象的invoke方法，执行完成返回数据给客户端

[java] view plain copy
//netty响应客户端请求处理对象  
   private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {  
         
       public Object reply(ExchangeChannel channel, Object message) throws RemotingException {  
           if (message instanceof Invocation) {  
               Invocation inv = (Invocation) message;  
               Invoker<?> invoker = getInvoker(channel, inv);//根据客户端请求信息组装key值从exporterMap取出真正的接口实现类对象  
               //如果是callback 需要处理高版本调用低版本的问题  
               if (Boolean.TRUE.toString().equals(inv.getAttachments().get(IS_CALLBACK_SERVICE_INVOKE))){  
                   String methodsStr = invoker.getUrl().getParameters().get("methods");  
                   boolean hasMethod = false;  
                   if (methodsStr == null || methodsStr.indexOf(",") == -1){  
                       hasMethod = inv.getMethodName().equals(methodsStr);  
                   } else {  
                       //循环验证客户端请求的方法，服务端是否存在对应的实现  
                       String[] methods = methodsStr.split(",");  
                       for (String method : methods){  
                           if (inv.getMethodName().equals(method)){  
                               hasMethod = true;  
                               break;  
                           }  
                       }  
                   }  
                   //不存在请求方法实现，返回空或抛出异常  
                   if (!hasMethod){  
                       logger.warn(new IllegalStateException("The methodName "+inv.getMethodName()+" not found in callback service interface ,invoke will be ignored. please update the api interface. url is:" + invoker.getUrl()) +" ,invocation is :"+inv );  
                       return null;  
                   }  
               }  
               RpcContext.getContext().setRemoteAddress(channel.getRemoteAddress());  
               return invoker.invoke(inv);//执行invoer响应客户端请求  
           }  
           throw new RemotingException(channel, "Unsupported request: " + message == null ? null : (message.getClass().getName() + ": " + message) + ", channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress());  
       }  
  
       /** 
        * netty接受客户端请求参数入口 
        * @param channel 
        * @param message 
        * @throws RemotingException 
        */  
       @Override  
       public void received(Channel channel, Object message) throws RemotingException {  
           if (message instanceof Invocation) {  
               reply((ExchangeChannel) channel, message);//执行服务端处理并返回响应消息  
           } else {  
               super.received(channel, message);  
           }  
       }  
  
       @Override  
       public void connected(Channel channel) throws RemotingException {  
           invoke(channel, Constants.ON_CONNECT_KEY);  
       }  
  
       @Override  
       public void disconnected(Channel channel) throws RemotingException {  
           if(logger.isInfoEnabled()){  
               logger.info("disconected from "+ channel.getRemoteAddress() + ",url:" + channel.getUrl());  
           }  
           invoke(channel, Constants.ON_DISCONNECT_KEY);  
       }  
         
       private void invoke(Channel channel, String methodKey) {  
           Invocation invocation = createInvocation(channel, channel.getUrl(), methodKey);  
           if (invocation != null) {  
               try {  
                   received(channel, invocation);  
               } catch (Throwable t) {  
                   logger.warn("Failed to invoke event method " + invocation.getMethodName() + "(), cause: " + t.getMessage(), t);  
               }  
           }  
       }  
         
       private Invocation createInvocation(Channel channel, URL url, String methodKey) {  
           String method = url.getParameter(methodKey);  
           if (method == null || method.length() == 0) {  
               return null;  
           }  
           RpcInvocation invocation = new RpcInvocation(method, new Class<?>[0], new Object[0]);  
           invocation.setAttachment(Constants.PATH_KEY, url.getPath());  
           invocation.setAttachment(Constants.GROUP_KEY, url.getParameter(Constants.GROUP_KEY));  
           invocation.setAttachment(Constants.INTERFACE_KEY, url.getParameter(Constants.INTERFACE_KEY));  
           invocation.setAttachment(Constants.VERSION_KEY, url.getParameter(Constants.VERSION_KEY));  
           if (url.getParameter(Constants.STUB_EVENT_KEY, false)){  
               invocation.setAttachment(Constants.STUB_EVENT_KEY, Boolean.TRUE.toString());  
           }  
           return invocation;  
       }  
   };  

是不是在想invoker对象是个什么东西，它就是我们通过以下代码导出的接口实现对象的代理对象
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
前面说了proxyFactory我们默认就当做是JdkProxyFactory类，getInvoker方法的实现如下，它重写了doInvoke方法，通过反射机制执行了接口实现类的， getInvoker方法反馈的是AbstractProxyInvoker对象。

[java] view plain copy
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {  
        return new AbstractProxyInvoker<T>(proxy, type, url) {  
            //重写了AbstractProxyInvoker类的抽象doInvoke方法  
            @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);  
            }  
        };  
    }  

细读AbstractProxyInvoker类代码就发现invoke方法中new了一个RpcResult对象，同时执行了doInvoke方法，因为当前类的doInvoke方法是抽象的，所以最终执行了外面重写的doInvoke方法。好了执行doInvoke方法以后服务端就响应了接口的调用，将执行的结果封装到了RpcResult中，经过序列化将对象传输到客户端服务器，客户端只需要接收数据再反序列化就可以拿到数据了。到此响应客户端的请求已经走完。

[java] view plain copy
public abstract class AbstractProxyInvoker<T> implements Invoker<T> {  
      
    private final T proxy;  
      
    private final Class<T> type;  
      
    private final URL url;  
  
    public AbstractProxyInvoker(T proxy, Class<T> type, URL url){  
        if (proxy == null) {  
            throw new IllegalArgumentException("proxy == null");  
        }  
        if (type == null) {  
            throw new IllegalArgumentException("interface == null");  
        }  
        if (! type.isInstance(proxy)) {  
            throw new IllegalArgumentException(proxy.getClass().getName() + " not implement interface " + type);  
        }  
        this.proxy = proxy;  
        this.type = type;  
        this.url = url;  
    }  
  
    public Class<T> getInterface() {  
        return type;  
    }  
  
    public URL getUrl() {  
        return url;  
    }  
  
    public boolean isAvailable() {  
        return true;  
    }  
  
    public void destroy() {  
    }  
  
    public Result invoke(Invocation invocation) throws RpcException {  
        try {  
            //执行doInvoke方法，当前类的doInvoke方法是抽象的，是不是突然明白了，执行的不就是外面重写的doInvoke方法么  
            return new RpcResult(doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments()));  
        } catch (InvocationTargetException e) {  
            return new RpcResult(e.getTargetException());  
        } catch (Throwable e) {  
            throw new RpcException("Failed to invoke remote proxy method " + invocation.getMethodName() + " to " + getUrl() + ", cause: " + e.getMessage(), e);  
        }  
    }  
      
    protected abstract Object doInvoke(T proxy, String methodName, Class<?>[] parameterTypes, Object[] arguments) throws Throwable;  
  
    @Override  
    public String toString() {  
        return getInterface() + " -> " + getUrl()==null?" ":getUrl().toString();  
    }  
  
      
}  

四总结

如果跟着文章分析代码，您已经知道dubbo框架是你怎么发布一个服务，又是怎么启动底层的netty框架了,然后怎么根据客户端请求传过来的参数定位到对应的服务实现类并执行对应的方法。看似很简单，但是涉及的知识面还是比较广的。比如装饰模式，工厂模式，抽象模版方法模式，netty框架的了解等。下个章节来看看客户端是怎么做来做请求的

转载自：dubbo服务端之netty

zhifeng687

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
dubbo暴露服务的过程解析（从proxy层到exchange、transport层）

一概述上个章节已经描述了dubbo发布一个服务，但具体是如何发布服务只是粗略的描述了下，这里将深入描述服务发布时怎么样开启socket监听，即启动netty服务。二开启netty服务上一节发布服务的重点入口代码如下[java] view plain copy//通过proxyFactory对象生成接口实现类代理对象Invoker Invoker&lt;?&gt; invoker = ...
复制链接

扫一扫