dubbo实现简析(4)

dubbo协议默认使用Netty作为server实现，凭良心说Netty可能是目前最高效好用的网络开发包之一。当然你也可以设置server参数=mina或者grizzly

 public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {

        URL url = invoker.getUrl();

        

        // export service.

        String key = serviceKey(url);

        DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);

        exporterMap.put(key, exporter);

        ......

          openServer(url);

        

        return exporter;

    }

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);

          }

        }

    }

private ExchangeServer createServer(URL url) {

     ExchangeServer server;

        try {

            server = Exchangers.bind(url, requestHandler);

        } catch (RemotingException e) {

            throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);

        }

     return server;

}

 public Server bind(URL url, ChannelHandler listener) throws RemotingException {

        return new NettyServer(url, listener);

    }

private void startHeatbeatTimer() {

        stopHeartbeatTimer();

        if (heartbeat > 0) {

            heatbeatTimer = scheduled.scheduleWithFixedDelay(

                    new HeartBeatTask( new HeartBeatTask.ChannelProvider() {

                        public Collection<Channel> getChannels() {

                            return Collections.unmodifiableCollection(

                                    HeaderExchangeServer.this.getChannels() );

                        }

                    }, heartbeat, heartbeatTimeout),

                    heartbeat, heartbeat,TimeUnit.MILLISECONDS);

        }

    }

生成ExchangeServer的过程中，如果heartbeat参数>0， 会启动心跳检测看server是否可用，默认是0，也就是说默认不开启心跳检测，这可能是基于server性能的考虑。

NettyServer会在构造函数中调用doOpen()来绑定server地址，以pipeline方式绑定事件监听和处理器。这个就不细说了，都是Netty的典型用法;

protected void doOpen() throws Throwable {

        NettyHelper.setNettyLoggerFactory();

        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);

        

        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);

                return pipeline;

            }

        });

        // bind

        channel = bootstrap.bind(getBindAddress());

    }

server打开，可以监听request了，下面看看consumer发起请求的过程：

    // create rpc invoker.

        DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);

        invokers.add(invoker);

        return invoker;

    }

protected Result doInvoke(final Invocation invocation) throws Throwable {

                 RpcContext.getContext().setFuture(null);

                return (Result) currentClient.request(inv, timeout).get();

}

public ResponseFuture request(Object request, int timeout) throws RemotingException {

     // create request.

        Request req = new Request();

        req.setVersion("2.0.0");

        req.setTwoWay(true);

        req.setData(request);

        DefaultFuture future = new DefaultFuture(channel, req, timeout);

        try{

            channel.send(req);

        }catch (RemotingException e) {

            future.cancel();

            throw e;

        }

        return future;

    }

server收到request后，安排先前绑定的rquesthandler来处理发过来的消息。下面看看handler的几个主要方法connect, disconnect, received, 这个类是dubbo协议处理消息的核心逻辑，其实就是拿到先前export好的Invoker这个代理，然后执行请求的方法。

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);

                //如果是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);

            }

            throw new RemotingException(channel, "Unsupported request: " + message == null ? null : (message.getClass().getName() + ": " + message) + ", channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress());

        }

        @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;

        }

    };

dubbo项目抽象了Netty, mina,grizzly三个网络开发包的功能，使得用户可以自由选择网络开发框架包。这种抽象的手法，值得大家学习。另外，在暴露和引用服务的过程中，也对各种协议和注册中心进行了抽象，这样很方便进行扩展，也给使用者流下了更多可选项。

转载于:https://my.oschina.net/u/603187/blog/552067