dubbo服务调用过程浅析

完成了服务的初始化之后，生成了代理，生成的动态代理类对接口的方法进行了包装，每次调用都会调用到InvocationHandler的invoke()方法，此方法中会进行远程服务调用一些列复杂过程，诸如网络通信，编码，解码，序列化等，然后将结果返回。在InvokerInvocationHandler.invoker()方法中，最后调用invoker.invoke(new RpcInvocation(method, args))，首先invoker为构造InvokerInvocationHandler传入的，具体类型为MockClusterInvoker，然后调用MockClusterInvoker.invoke-->FailfastClusterInvoker.doInvoke()

public Result invoke(Invocation invocation) throws RpcException {
        Result result = null;
        String value = directory.getUrl().getMethodParameter(invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim(); 
        if (value.length() == 0 || value.equalsIgnoreCase("false")){//没有mock
            //no mock
            result = this.invoker.invoke(invocation);
   ..................................................................
}

然后调用到FailfastClusterInvoker.invoke()，此对象持有接口服务的RegistryDirectory，里面含有远程提供者的具体信息，是在服务消费者初始化时，通过订阅zk相应节点得到的。此方法的调用过程比较复杂，会调用负载均衡算法，根据一定的策略，选取一个提供者，生成DubboInvoker对象。调用过程：AbstractClusterInvoker.invoke()--> FailfastClusterInvoker.doInvoke()

public Result invoke(final Invocation invocation) throws RpcException {
        checkWhetherDestroyed();
        LoadBalance loadbalance;//加载loadbalance
        List> invokers = list(invocation);//根据method加载invokers
        if (invokers != null && invokers.size() > 0) {//默认采用随机策略的loadbalance
            loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(invokers.get(0).getUrl()
                    .getMethodParameter(invocation.getMethodName(),Constants.LOADBALANCE_KEY, Constants.DEFAULT_LOADBALANCE));
        } else {
            loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(Constants.DEFAULT_LOADBALANCE);
        }
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
        /** invocation:方法,参数类型，参数
         *  invokers:此接口提供端的Invoker；
         *  loadbalance:均衡负载
         */
        return doInvoke(invocation, invokers, loadbalance);
    }

下面看如何加载invokers的，进入到 list(invocation)方法，调用过程：AbstractDirectory.list()-->RegistryDirectory.doList()

 public List> doList(Invocation invocation) {
         ........................................................
        List> invokers = null;
        // 本地method-->lnvokers对应关系
        Map>> localMethodInvokerMap = this.methodInvokerMap; 
        if (localMethodInvokerMap != null && localMethodInvokerMap.size() > 0) {
             //获取方法名称和参数
            String methodName = RpcUtils.getMethodName(invocation);
            Object[] args = RpcUtils.getArguments(invocation);
            if(args != null && args.length > 0 && args[0] != null
                    && (args[0] instanceof String || args[0].getClass().isEnum())) {
                invokers = localMethodInvokerMap.get(methodName + "." + args[0]); // 可根据第一个参数枚举路由
            }
            if(invokers == null) {//根据方法获取
                invokers = localMethodInvokerMap.get(methodName);
            }
            if(invokers == null) {//获取*匹配的
                invokers = localMethodInvokerMap.get(Constants.ANY_VALUE);
            }
            if(invokers == null) {//获取所有
                Iterator>> iterator = localMethodInvokerMap.values().iterator();
                if (iterator.hasNext()) {
                    invokers = iterator.next();
                }
            }
        }
        return invokers == null ? new ArrayList>(0) : invokers;
    }

下面回到AbstractDirectory.list()，在这个方法中进行路由规则的匹配，匹配规则，路由规则也是spi机制的，有脚本、文件、表达式，一般通过服务治理中心配置，与接口服务关联，具体参见dubbo官方文档。路由匹配完成之后，获取到provider端的所有可用的Invokers，回到AbstractClusterInvoker.invoke()方法，最终返回provider端可用的Invokers，然后调用FailfastClusterInvoker.doInvoke():

 public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);//检查invokers的可用性
        Invoker invoker = select(loadbalance, invocation, invokers, null);
        try {
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            if (e instanceof RpcException && ((RpcException)e).isBiz()) { // biz exception.
                throw (RpcException) e;
            }
           .........................
        }
    }

select(loadbalance, invocation, invokers, null)会根据loadbalance进行负载均衡算法匹配，此处为随机选择：
com.alibaba.dubbo.rpc.cluster.loadbalance.RandomLoadBalance

 protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
        int length = invokers.size(); // 总个数
        int totalWeight = 0; // 总权重
        boolean sameWeight = true; // 权重是否都一样
        for (int i = 0; i < length; i++) {
            int weight = getWeight(invokers.get(i), invocation);
            totalWeight += weight; // 累计总权重
            if (sameWeight && i > 0
                    && weight != getWeight(invokers.get(i - 1), invocation)) {
                sameWeight = false; // 计算所有权重是否一样
            }
        }
        if (totalWeight > 0 && ! sameWeight) {
            // 如果权重不相同且权重大于0则按总权重数随机
            int offset = random.nextInt(totalWeight);
            // 并确定随机值落在哪个片断上
            for (int i = 0; i < length; i++) {
                offset -= getWeight(invokers.get(i), invocation);
                if (offset < 0) {
                    return invokers.get(i);
                }
            }
        }
        // 如果权重相同或权重为0则均等随机
        return invokers.get(random.nextInt(length));
    }

回到FailfastClusterInvoker.doInvoke()，根据负载均衡算法返回一个Invoker，为dubboInvoker,下面进行DubboInvoke.invoke()的调用

  protected Result doInvoke(final Invocation invocation) throws Throwable {
        //RpcInvocation封装了调用方法的对象和参数类型，具体参数
        RpcInvocation inv = (RpcInvocation) invocation;
         //获取具体的方法名称
        final String methodName = RpcUtils.getMethodName(invocation);
        inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
        inv.setAttachment(Constants.VERSION_KEY, version);
        //调用客户端，在refer中已经初始化好了，为HeaderExchangeClient
        ExchangeClient currentClient;
        if (clients.length == 1) {
            currentClient = clients[0];
        } else {
            currentClient = clients[index.getAndIncrement() % clients.length];
        }
        try {
            boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
            boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
            int timeout = getUrl().getMethodParameter(methodName, Constants.TIMEOUT_KEY,Constants.DEFAULT_TIMEOUT);
            if (isOneway) {//没有返回参数
                boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
                currentClient.send(inv, isSent);
                RpcContext.getContext().setFuture(null);
                return new RpcResult();
            } else if (isAsync) {//异步
                ResponseFuture future = currentClient.request(inv, timeout) ;
                RpcContext.getContext().setFuture(new FutureAdapter