Async optimization

[chickenlj]

What is the purpose of the change

Fixes #3287

Brief changelog

GenericService provides extra CompletableFuture method.
Invoker chain
Embedded Filter implementations.

Verifying this change

Follow this checklist to help us incorporate your contribution quickly and easily:

• Make sure there is a GITHUB_issue field for the change (usually before you start working on it). Trivial changes like typos do not require a GITHUB issue. Your pull request should address just this issue, without pulling in other changes - one PR resolves one issue.
• Format the pull request title like [Dubbo-XXX] Fix UnknownException when host config not exist #XXX. Each commit in the pull request should have a meaningful subject line and body.
• Write a pull request description that is detailed enough to understand what the pull request does, how, and why.
• Write necessary unit-test to verify your logic correction, more mock a little better when cross module dependency exist. If the new feature or significant change is committed, please remember to add integration-test in test module.
• Run mvn clean install -DskipTests=false & mvn clean test-compile failsafe:integration-test to make sure unit-test and integration-test pass.
• If this contribution is large, please follow the Software Donation Guide.

[chickenlj]

I am thinking of grouping onResponse onError into a Listener interface, they are all callbacks and should not being defined directly in Filter.

[ralf0131]

This pull request is too large to review... Could you provide a guide to the reviewers?

[ralf0131]

All the UT are failing. Could you take a look at it?

[chickenlj]

This pull request is too large to review... Could you provide a guide to the reviewers?

Sorry, but I am afraid this one has to be this way. I tried to refactor the whole call process inside Dubbo to make it totally asynchronous, the changes in this pull request are all restricted to this goal and they are almost the minimum changesets to make the framework work again.

I will try to provide a reviewing guide to help anyone who's willing to review.

[chickenlj]

#3847

[chickenlj]

Although many files have been modified in the PR, there are only 3 key points, all other changes are made to adapt to these core designs.

1. Refactoring of internal Filters, making them work with the async pattern by registering Listener to each Filter.

@SPI
public interface Filter {
    /**
     * Does not need to override/implement this method.
     */
    Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException;

    interface Listener {

        void onResponse(Result result, Invoker<?> invoker, Invocation invocation);

        void onError(Throwable t, Invoker<?> invoker, Invocation invocation);
    }

}

2. Use AsyncRpcResult as the type return back to the Filter chain.

• Add status interface to Result interface

public interface Result extends Serializable {
  
    Result thenApplyWithContext(Function<Result, Result> fn);

    <U> CompletableFuture<U> thenApply(Function<Result, ? extends U> fn);

    Result get() throws InterruptedException, ExecutionException;

}

• AsyncRpcResult

public class AsyncRpcResult implements Result {
    private CompletableFuture<AppResponse> responseFuture;
    ...
}

• Rename RpcResult to AppResponse with the meaning no changed

public class AppResponse implements Result, Serializable {
}

3. Add async method with CompletableFuture signature to GenericService

public interface GenericService {

    /**
     * Generic invocation
     *
     * @param method         Method name, e.g. findPerson. If there are overridden methods, parameter info is
     *                       required, e.g. findPerson(java.lang.String)
     * @param parameterTypes Parameter types
     * @param args           Arguments
     * @return invocation return value
     * @throws GenericException potential exception thrown from the invocation
     */
    Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException;

    default CompletableFuture<Object> $invokeAsync(String method, String[] parameterTypes, Object[] args) throws GenericException {
        Object object = $invoke(method, parameterTypes, args);
        if (object instanceof CompletableFuture) {
            return (CompletableFuture<Object>) object;
        }
        return CompletableFuture.completedFuture(object);
    }

}

Below are the async and sync workflows respectively:

[Jeff-Lv]

LGTM