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

This article introduces the knowledge of "how to achieve full-link asynchrony in Apache Dubbo". In the operation of practical cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Starting from version 2.7.0, Dubbo has upgraded its support for java8, which is based on the CompletableFuture under the JUC package and supports all asynchronous programming interfaces, which solves the inconvenience of using the asynchronous calling function before version 2.7.0.

Dubbo asynchronous invocation is also implemented based on NIO's non-blocking capability. Service consumers do not need to start multiple threads to invoke multiple remote services in parallel. The invocation process is as follows:

Previous drawbacks of Dubbo2.7.0

Prior to 2.7.0, the service consumer of Dubbo invoked the service provider asynchronously as follows:

Public interface UserService {String findUser (String name);}

/ / this call will immediately return nulluserService.findUser (fooId); / / get the Future reference of the call, and when the result is returned, it will be notified and set to this FutureFuture userFuture = RpcContext.getContext () .getFuture (); userFuture.get ()

Or

/ / this call will immediately return nulluserService.findUser (userId); / / get the ResponseFuture built into Dubbo and set the callback ResponseFuture future = ((FutureAdapter) RpcContext.getContext (). GetFuture ()). GetFuture (); future.setCallback (new ResponseCallback () {@ Override public void done (Object response) {System.out.print (response);} @ Override public void caught (Throwable exception) {exception.printStackTrace ();}}))

We can see that both in terms of usage and cleanliness of the code, it is extremely unfriendly and requires a lot of additional operations to get the results after the asynchronous call.

Dubbo2.7.0 CompletableFuture-based enhancements

After the release of 2.7.0, Dubbo was upgraded to support java8, and asynchronous calls were enhanced based on CompletableFuture. 2.7.0 allows the interface to return CompletableFuture. With this type of return value, it is easier to implement asynchronous programming on the Consumer and provider side.

Several ways of Dubbo2.7.0 programming based on CompletableFuture

Method 1. The interface returns CompletableFuture directly.

In Dubbo-based applications, both service consumers and service providers rely on a two-party SDK. We can directly define the return value of the interface of the two-party SDK as the CompletableFuture type. According to this return type, the service consumer can easily make asynchronous calls.

/ / API definition public interface UsercService {CompletableFuture findUser (String name);} / / public class UserServiceImpl implements UserService {public CompletableFuture findUser (String name) {return CompletableFuture.supplyAsync (())-> {try {Thread.sleep (5000);} catch (InterruptedException e) {e.printStackTrace ();} return new User () });}} / Consumer side final UserService userService = (AsyncService) context.getBean ("userService"); CompletableFuture future = userService.findUser ("liuli"); future.whenComplete ((v, t)-> {if (t! = null) {t.printStackTrace ();} else {System.out.println ("Response:" + v);}})

Method 2. Overload the original method

If we don't want to modify the original method, we can overload the original method and define the overloaded method as the return value of type CompletableFuture.

/ / define the interface public interface UserService {/ / original method User findUser (String name) / / to ensure that the method-level service governance rules remain valid, it is recommended to keep the method name unchanged: findUser / / use default implementation to avoid additional implementation costs for server providers / / boolean placeHoler is only increased to achieve overloading, as long as the Java syntax rules allow, you can use any method to overload the means default CompletableFuture findUser (String name, boolean placeHolder) {return CompletableFuture.completedFuture (findUser (name)) }} / / public class UserServiceImpl implements UserService {@ Override public User findUser (String name) {return new User ();}} / Consumer side UserService userService = (UserService) context.getBean ("userService"); CompletableFuture future = userService.findUser ("liuli"); System.out.println ("async call ret:" + future.get ())

In this way, the service consumer can directly call the overloaded findUser method.

Method 3. Implement asynchronous call based on AsyncContext

/ / API definition public interface UserService {User findUser (String name);} / Provider side public class UserServiceImpl implements UsercService {public User findUser (String name) {final AsyncContext asyncContext = RpcContext.startAsync (); / / time-consuming method executes new Thread (()-> {User user = new User ()) in the thread; / / returns the result asyncContext.write (user) }) .start (); return null;}} / / Consumer side UserService userService = (UserService) context.getBean ("userService"); System.out.println (userService.findUser ("liuli"))

Asynchronism is turned on in the body of the method through RpcContext.startAsync (), and the time-consuming business executes asynchronously in the new thread, and the result of the execution is written back through the asynvContext.write method, which directly returns null.

This is the end of the content of "how to achieve full-link async in Apache Dubbo". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

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.