Shulou(Shulou.com)06/03 Report--

This article mainly introduces "how to use Dubbo asynchronous processing". In daily operation, I believe many people have doubts about how to use Dubbo asynchronous processing problems. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "how to use Dubbo asynchronous processing". Next, please follow the editor to study!

Asynchronous invocation

We usually use synchronous calls from Dubbo, that is, after invoking the Dubbo request, the calling thread will block until the service provider returns the result.

In contrast, the Dubbo asynchronous invocation does not block the calling thread, so we can execute other business logic while the service provider returns the result.

Let's learn how to use Dubbo asynchronous calls from a code example.

PS: the Dubbo version of the following example is 2.7.

The first way

Dubbo asynchronous calls are at the method level, so we need to do some special configuration for the methods specified in the reference interface.

The asynchronous invocation configuration is actually similar to the normal xml service reference configuration, except that we also need to add a dubbo:method to configure the specified method to be invoked asynchronously.

The sample xml configuration is as follows:

After the service reference is configured, if this method is called directly, null will be returned immediately, and the server-side invocation logic will be executed asynchronously internally.

/ / this call immediately returns null String world = asyncService.sayHello ("world")

/ / draw a timing diagram

If we need to get the results returned by the service provider, we need to use RpcContext at this time. This class is specifically used in Dubbo to save some key information during "RPC" calls.

So we can get a lot of information about "RPC" with this class, and this time we mainly use the following methods to get CompletableFuture.

RpcContext.getContext () .getCompletableFuture ()

CompletableFuture is an asynchronous task enhancement class provided after JDK1.8, and we can directly call its get method to get the returned results.

/ / this call will immediately return null String world = asyncService.sayHello ("world"); / / get the Future reference of the call, and when the result is returned, it will be notified and set to this Future CompletableFuture helloFuture = RpcContext.getContext () .getCompletableFuture (); helloFuture.get ()

One thing to pay attention to here. After calling the get method, the thread is blocked "until the server returns the result or the service call times out".

In addition, if we don't want the thread to be blocked, we can use whenComplete, add a callback method, and then return the result asynchronously.

/ / this call immediately returns null String world = asyncService.sayHello ("world"); / / gets the Future reference of the call, and when the result is returned, it will be notified and set to this Future CompletableFuture helloFuture = RpcContext.getContext (). GetCompletableFuture (); / / add callback helloFuture.whenComplete ((retValue, exception)-> {if (exception = = null) {System.out.println ("return value:" + retValue) for Future) } else {exception.printStackTrace ();}})

As we can see from the above example, the asynchronous invocation on the consumer side of Dubbo relies on the CompletableFuture provided by JDK, which is very powerful and provides a lot of methods.

Brother Hei has written an article before, which gives a more complete introduction to the use of CompletableFuture. If you are interested, you can learn it in depth.

/ / TODO article

We use the xml reference service in the above way, but now many students should directly use the Dubbo annotation reference service.

If you want to use annotations directly, it's actually very simple, just use the @ Method annotation.

The configuration method is as follows:

@ Reference (interfaceClass = AsyncService.class, timeout = 1000, methods = {@ Method (name = "sayHello", async = true)}) private AsyncService asyncService

The second way

In the first way, we also need to modify the Dubbo configuration, which is relatively cumbersome. Then the second way does not require additional configuration, it can simply use RpcContext#asyncCall to complete the asynchronous call.

The sample code is as follows:

/ use asyncCall asynchronous call CompletableFuture f = RpcContext.getContext (). AsyncCall (()-> asyncService.sayHello ("async call request")); / / get will block until the server returns, or until the service call times out System.out.println ("async call returned:" + f.get ()); / / asynchronous call, do not care that the server returns RpcContext.getContext () .server ()-> {asyncService.sayHello ("one way call request1") })

This way the return is still a CompletableFuture object, operating just like the first way.

The third way

Finally, this is the last way, which is different from the above two approaches, it can be done without RpcContext at all, and the development process is the same as a normal Dubbo service.

First, you need the service provider to define the CompletableFuture-signed service in advance:

Public interface AsyncService {CompletableFuture sayHello (String name);}

"notice that the return type of the interface is CompletableFuture. "

The implementation logic of the server interface is as follows:

Public class AsyncServiceImpl implements AsyncService {private static Logger logger = LoggerFactory.getLogger (AsyncServiceImpl.class); @ Override public CompletableFuture sayHello (String name) {return CompletableFuture.supplyAsync (())-> {try {Thread.sleep (10000);} catch (InterruptedException e) {e.printStackTrace ();} return "async response from provider." );}}

The server needs to use CompletableFuture to complete the business logic.

At this point, the consumer side does not need to rely on RpcContext, and can directly invoke the service provider.

/ / return CompletableFuture CompletableFuture future = asyncService.sayHello ("async call request") directly; / / add callback future.whenComplete ((v, t)-> {if (t! = null) {t.printStackTrace ();} else {System.out.println ("Response:" + v);}}); / / earlier than the result output System.out.println ("Executed before response return.")

This approach is convenient for callers, does not need to introduce other objects, and can use asynchronous calls in the same way as synchronous.

Other parameters

The above describes the use of three kinds of Dubbo asynchronous calls, and the following is mainly about the other parameters involved in asynchronous calls.

Sent

We can set it in dubbo:method:

You can also set the following in the comments:

Reference (interfaceClass = XXX.class, version = AnnotationConstants.VERSION, timeout = 1000, methods = {@ Method (name = "greeting", timeout = 3000, retries = 1, sent = false)})

By default, sent=false, Dubbo will put the message on the IO queue and return immediately. If there is a downtime at this time, the message may not be sent to the server.

Then if we set it to sent=true,Dubbo, it will wait for the message to be sent before it will return, otherwise an exception will be thrown.

Return

The Dubbo asynchronous call creates a Future object by default and then sets it to RpcContext. So if we don't care about the return value and just want to execute asynchronously, we can configure return= "false" to reduce the cost of creating and managing Future objects.

At this point, the study on "how to use Dubbo asynchronous processing" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.