Dubbo 异步调用过程

开篇

• 本篇是基于Dubbo-2.6.7版本的异步调用的分析，在这个过程中会涉及异步的调用过程和响应过程的分析。
• 文章中会有一部分简单的例子，用于讲解异步的是使用方式。

异步调用说明

Dubbo 异步调用过程

• 关注userThread的行为，用户发出调用后，IOThread会在上下文RpcContext中设置Future，对应上图中步骤1.2.3。
• 用户从RpcContext中取得Future，然后wait这个Future其它的事情都由IOThread完成，对应上图中步骤4.5。
• server端响应后会把调用结果设置在RpcContext上下文当中，同时通知UserThread线程。

异步回调使用案例

// 此方法应该返回Foo，但异步后会立刻返回NULL
fooService.findFoo(fooId);
// 立刻得到当前调用的Future实例，当发生新的调用时这个东西将会被覆盖
Future fooFuture = RpcContext.getContext().getFuture();
 
// 调用另一个服务的方法
barService.findBar(barId);
// 立刻得到当前调用的Future
Future barFuture = RpcContext.getContext().getFuture();
 
// 此时，两个服务的方法在并发执行
// 等待第一个调用完成，线程会进入Sleep状态，当调用完成后被唤醒。
Foo foo = fooFuture.get();
// 同上
Bar bar = barFuture.get();
// 假如第一个调用需要等待5秒，第二个等待6秒，则整个调用过程完成的时间是6秒。

• 1、异步调用的实现步骤先执行fooService.findFoo()的执行服务调用。
• 2、获取RPC上下文RpcContext.getContext().getFuture()。
• 3、通过future.get()方法获取执行结果，如果当时没有结果当前线程就会被挂起。

Dubbo异步调用栈

• Consumer => InvokerInvocationHandler =>DubboInvoker =>HeaderExchangeClient。

InvokerInvocationHandler

public class InvokerInvocationHandler implements InvocationHandler {

    private final Invoker invoker;

    public InvokerInvocationHandler(Invoker handler) {
        this.invoker = handler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Class[] parameterTypes = method.getParameterTypes();
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(invoker, args);
        }
        if ("toString".equals(methodName) && parameterTypes.length == 0) {
            return invoker.toString();
        }
        if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
            return invoker.hashCode();
        }
        if ("equals".equals(methodName) && parameterTypes.length == 1) {
            return invoker.equals(args[0]);
        }
        return invoker.invoke(new RpcInvocation(method, args)).recreate();
    }

}

• InvokerInvocationHandler的invoke()方法创建rpc调用的RpcInvocation对象，这个对象会在单次调用的过程中传递，相当于单次调用的上下文。

RpcInvocation

public class RpcInvocation implements Invocation, Serializable {

    private static final long serialVersionUID = -4355285085441097045L;
    // 方法名字
    private String methodName;
    // 参数类型
    private Class[] parameterTypes;
    // 参数值
    private Object[] arguments;
    // 上下文透传的参数值
    private Map attachments;

    private transient Invoker invoker;

    public RpcInvocation() {
    }

    public RpcInvocation(Method method, Object[] arguments) {
        this(method.getName(), method.getParameterTypes(), arguments, null, null);
    }

    public RpcInvocation(Method method, Object[] arguments, Map attachment) {
        this(method.getName(), method.getParameterTypes(), arguments, attachment, null);
    }

    public RpcInvocation(String methodName, Class[] parameterTypes, Object[] arguments) {
        this(methodName, parameterTypes, arguments, null, null);
    }

    public RpcInvocation(String methodName, Class[] parameterTypes, Object[] arguments, Map attachments) {
        this(methodName, parameterTypes, arguments, attachments, null);
    }

    public RpcInvocation(String methodName, Class[] parameterTypes, Object[] arguments, Map attachments, Invoker invoker) {
        this.methodName = methodName;
        this.parameterTypes = parameterTypes == null ? new Class[0] : parameterTypes;
        this.arguments = arguments == null ? new Object[0] : arguments;
        this.attachments = attachments == null ? new HashMap() : attachments;
        this.invoker = invoker;
    }
}

RpcInvocation

• RpcInvocation的核心变量包括方法名、参数类型、参数值、附带上下文数据。
• methodName为方法名。
• parameterTypes为参数类型。
• arguments为参数值。
• attachments为附带上下文数据。

异步调用流程

dubbo异步调用.jpg

DubboInvoker

public class DubboInvoker extends AbstractInvoker {
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        RpcInvocation inv = (RpcInvocation) invocation;
        final String methodName = RpcUtils.getMethodName(invocation);
        inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
        inv.setAttachment(Constants.VERSION_KEY, version);

        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