Dubbo 浅读

最近公司一直在用阿里的开源框架Dubbo，正好上一篇文章也是讲到了RPC的概念，Dubbo听过的兄弟都知道在业界好评还是很高的，不光是设计优雅，文档也很齐全，这次就简单的分享下LZ的解读成果，当然本文章只是浅层次的，着重分析的是Dubbo核心层如何去高效的执行调用远程RPC服务的。

这里要简单跟兄弟们区分下概念，最常见最具代表性也是比较简单的HTTP协议(短连接)与Socket编程(长连接)的区别，这里不再多讲前者，这次主要最涉及到后者。

知识点储备前提：

 JAVA 动态代理(网上很多，这里推荐比较全面的文章:http://www.cnblogs.com/flyoung2008/archive/2013/08/11/3251148.html)

JAVA NIO(http://www.cnblogs.com/flyoung2008/p/3251826.html)

这里LZ依然推荐的是带着问题去学习，依旧是Scrum三要素：服务端怎么暴露服务，怎么引用服务，两者怎么实现通讯。

1：服务端怎么暴露服务

ServiceConfig类里export方法有一段

        if (delay != null && delay > 0) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(delay);
                    } catch (Throwable e) {
                    }
                    doExport();
                }
            });
            thread.setDaemon(true);
            thread.setName("DelayExportServiceThread");
            thread.start();
        } else {
            doExport();
        }

看上面代码，如果没有设置延迟暴露服务，直接运行doExport();

一路跟踪代码，校验HOST，类型转换等跳过，最终看到下面代码。

Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

Exporter<?> exporter = protocol.export(invoker);
exporters.add(exporter);

光看着几行依旧不太明了，首先关注Invoker类，最终又会看到URL类。

关注下URL类会看到一些连接需要的字段信息，大概猜测即为连接所用的信息实体类。

继续往下看proxyFactory.getInvoker(ref, (Class) interfaceClass, url);

    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        // TODO Wrapper类不能正确处理带$的类名
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName, 
                                      Class<?>[] parameterTypes, 
                                      Object[] arguments) throws Throwable {
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

可以看到此方法根据参数，返回一个Invoker实体。再看protocol.export(invoker)；

往下追会看到如下：

　　　　　try {
            server = Exchangers.bind(url, requestHandler);
        } catch (RemotingException e) {
            throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
        }

再往下追,看到

return getTransporter().bind(url, handler);

发现Transporter有三个实现类：GrizzlyTransporter，MinaTransporter，NettyTransporter 。

看到这些名字也许脑海里会有点概念，哦~这里就开始用Grizzly，Mina，Netty这里开源框架去实现通讯啦~

但是还是不是很彻底，没关系，接着第二个问题

2：怎么引用服务?

ReferenceConfig类init();方法里有段

ref = createProxy(map);我们从这可以看得出有Proxy字样，这就可以确定我们的方向没有走错，继续往下看。

我们又可以看到下面代码：

if (urls.size() == 1) {
    invoker = refprotocol.refer(interfaceClass, urls.get(0));
} else {
    List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
    URL registryURL = null;
    for (URL url : urls) {
        invokers.add(refprotocol.refer(interfaceClass, url));
        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
            registryURL = url; // 用了最后一个registry url
        }
    }
    if (registryURL != null) { // 有 注册中心协议的URL
        // 对有注册中心的Cluster 只用 AvailableCluster
        URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME); 
        invoker = cluster.join(new StaticDirectory(u, invokers));
    }  else { // 不是 注册中心的URL
        invoker = cluster.join(new StaticDirectory(invokers));
    }
}

这里的代码回顾之前的暴露服务时的Invoker有没有熟悉?是的，这里就是根据URL来得到Invoker实体，

最后有个 getProxy(invoker, interfaces);

    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

看到这里就看熟悉了啦~再看InvokerInvocationHandler类，实现InvocationHandler接口，

if (method.getDeclaringClass() == Object.class) {
    return method.invoke(invoker, args);
}

其实最终还是认出了它的本质。

那么问题来了......

3：两者怎么实现通讯

回到刚刚暴露服务那里，Transporter有三个实现类：GrizzlyTransporter，MinaTransporter，NettyTransporter 。

我们以NettyTransporter为例：

    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()里：

channel = bootstrap.bind(getBindAddress());

这个channel也就是Netty里的channel，终于交给Netty啦。

我们再跟踪NettyClient的时候貌似不是简单的连接，往后跟踪发现

cexecutor.execute(new ChannelEventRunnable(channel, handler ,ChannelState.CONNECTED));

这一段就可以看到利用ExecutorService去分发连接。

那么可能看到以上分析还是有点晕乎乎，没有连续感有木有？

是的，其实光分析以上的也不会有太直观的感受，LZ根据这些原理写了个最直观最简单的Demo:

 这是简化过的核心代理层：

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by luyichen718 on 14-12-31.
 */
public class RpcDemo {

    /**
     * 暴露服务
     *
     * @param service 服务实现
     * @param port    服务端口
     * @throws Exception
     */
    public static void export(final Object service, int port) throws Exception {
        try {
            ServerSocket server = new ServerSocket(port);
            //该处采用不间断阻塞式监听端口
            //TODO:此处可以用NIO来优化实现
            while (true){
                final Socket socket = server.accept();
                try {
                    try {
                        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                        try {
                            //也可以加服务注册方式管理服务
                            String methodName = input.readUTF();
                            Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                            Object[] arguments = (Object[]) input.readObject();
                            ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
                            //TODO:前后可以做监控
                            try {
                                Method method = service.getClass().getMethod(methodName, parameterTypes);
                                Object result = method.invoke(service, arguments);
                                output.writeObject(result);
                            } catch (Throwable t) {
                                output.writeObject(t);
                            } finally {
                                output.close();
                            }
                        } finally {
                            input.close();
                        }
                    } finally {
                        socket.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 引用服务
     *
     * @param <T>            接口泛型
     * @param interfaceClass 接口类型
     * @param host           服务器主机名
     * @param port           服务器端口
     * @return 远程服务
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static <T> T reference(final Class<T> interfaceClass, final String host, final int port) throws Exception {
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[]{interfaceClass}, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable {
                Socket socket = new Socket(host, port);
                try {
                    ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
                    try {
                        output.writeUTF(method.getName());
                        output.writeObject(method.getParameterTypes());
                        output.writeObject(arguments);
                        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                        try {
                            Object result = input.readObject();
                            if (result instanceof Throwable) {
                                throw (Throwable) result;
                            }
                            return result;
                        } finally {
                            input.close();
                        }
                    } finally {
                        output.close();
                    }
                } finally {
                    socket.close();
                }
            }
        });
    }
}

服务生产者：

    public static void main(String[] args) throws Exception {
        BizService service = new BizServiceImpl();
        RpcDemo.export(service, 6543);
    }

服务消费者：

    public static void main(String[] args) throws Exception {
        BizService service = RpcDemo.reference(BizService.class, "127.0.0.1", 6543);
        service.hello();
    }

该处的BizService就是一个最简单的业务接口，里面可以实现具体的业务,接口一般单独生产jar包给消费方使用。

可能对于一般读者也是最有价值的了吧,以上晕乎乎的可以先看Demo然后再下载了源码看看分析^_^

这个Demo也算是对一般长连接的最简易实现，当然Dubbo加了很多扩展及监控，还运用了很多Decorator模式，接口设计也很优雅，光看官网的一些接口图都晕乎乎了，所以还是要静下心来慢慢研读。

此处也算是对长连接RPC的实现做了一个小结，欢迎各兄弟交流吐槽~