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

This article mainly explains "what are the problems about Dubbo". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the problems about Dubbo"?

1 、 RPC

1.1 RPC definition

The system of Internet companies is composed of thousands of services, large and small, which are deployed on different machines, and the calls between services require network communication. Service consumers have to write a piece of code related to network communication for each service they call, which is not only complex but also error-prone. Also consider how to invoke the old service when the new service depends on the old service, and how to publish the new service to facilitate others to invoke when other services rely on the new service. How to solve this problem? The industry generally uses the way of RPC remote call to achieve.

RPC:

Remote Procedure Call Protocol is not only a remote procedure call, but also a way to call a remote service like a local service, which makes the caller unaware of the details of network communication. For example, when the service consumer executes helloWorldService.sayHello ("sowhat"), it is essentially calling the remote service. In fact, the idea of RPC,RPC is widely used in major Internet companies, such as Alibaba's dubbo, Dangdang's Dubbox, Facebook's thrift, Google's grpc, Twitter's finagle and so on.

1.2 RPC demo

After all that has been said, let's implement a simple version of RPC demo.

1.2.1 Public Interface

Public interface SoWhatService {String sayHello (String name);}

1.2.2 Service provider

Interface class implementation

Public class SoWhatServiceImpl implements SoWhatService {@ Override public String sayHello (String name) {return "Hello" + name;}}

Service registration external provider

/ * Service Registration external provider * / public class ServiceFramework {public static void export (Object service, int port) throws Exception {ServerSocket server = new ServerSocket (port); while (true) {Socket socket = server.accept (); new Thread (()-> {try {/ / deserialization ObjectInputStream input = new ObjectInputStream (socket.getInputStream ()) / / read method name String methodName = (String) input.readObject (); / / Parameter type Class [] parameterTypes = (Class []) input.readObject (); / / Parameter Object [] arguments = (Object []) input.readObject (); / / find method Method method = service.getClass (). GetMethod (methodName, parameterTypes); / / call method Object result = method.invoke (service, arguments) / / return result ObjectOutputStream output = new ObjectOutputStream (socket.getOutputStream ()); output.writeObject (result);} catch (Exception e) {e.printStackTrace ();}}) .start ();}

Service operation

Public class ServerMain {public static void main (String [] args) {/ / Service provider exposes interface SoWhatService service = new SoWhatServiceImpl (); try {ServiceFramework.export (service, 1412);} catch (Exception e) {e.printStackTrace ();}

1.2.3 Service Caller

Dynamic proxy invokes remote service

/ * * @ author sowhat * dynamic proxy invokes remote services * / public class RpcFunction {public static T refer (Class interfaceClass, String host, int port) throws Exception {return (T) Proxy.newProxyInstance (interfaceClass.getClassLoader (), new Class [] {interfaceClass}, new InvocationHandler () {@ Override public Object invoke (Object proxy, Method method) Object [] arguments) throws Throwable {/ / specify the ip and port of provider Socket socket = new Socket (host, port) ObjectOutputStream output = new ObjectOutputStream (socket.getOutputStream ()); / / pass method name output.writeObject (method.getName ()); / / pass parameter type output.writeObject (method.getParameterTypes ()); / / pass parameter value output.writeObject (arguments); ObjectInputStream input = new ObjectInputStream (socket.getInputStream ()); / / read result Object result = input.readObject (); return result });}}

Call method

Public class RunMain {public static void main (String [] args) {try {/ / Service caller needs to set dependency SoWhatService service = RpcFunction.refer (SoWhatService.class, "127.0.0.1", 1412); System.out.println (service.sayHello ("sowhat1412"));} catch (Exception e) {e.printStackTrace ();}

2. Dubbo framework design.

2.1 introduction to Dubbo

Dubbo is an open source tool developed by Alibaba, which is mainly divided into 2.6.x and 2.7.x versions. It is a distributed, high-performance and transparent RPC service framework, which provides efficient service governance solutions such as automatic service registration and automatic discovery. It can be seamlessly integrated with the Spring framework. It provides six core competencies:

1. High performance RPC invocation for Interface Agent

two。 Intelligent fault tolerance and load balancing

3. Automatic service registration and discovery

4. Highly scalable

5. Run-time traffic scheduling

6. Visual service governance and operation and maintenance

Calling procedure:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

The service provider Provider starts and registers the services it can provide with Registry.

The service consumer Consumer subscribes to the required services from Registry. Consumer parses the meta-information provided by Registry and selects Provider calls from the services through load balancer.

If the service provider Provider metadata changes, Registry will push the changes to Consumer to ensure that Consumer gets the latest available information.

Note:

Provider and Consumer record the number and time of calls in memory, send statistics to Monitor regularly, and send them with a short connection.

Monitor and Registry are optional and can be written directly in the configuration file, and Provider is directly connected to Consumer.

It's okay for Monitor to hang up with Registry. Consumer locally caches Provider information.

Consumer calls Provider directly without going through Registry. There is a long connection between Provider and Consumer to Registry.

2.2 Dubbo framework layering

As shown in the figure above, generally speaking, Dubbo is divided into three layers.

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Busines layer: the user provides the interface and implementation, as well as some configuration information.

RPC layer: the core layer of real RPC calls, encapsulating the entire RPC call process, load balancing, cluster fault tolerance, proxy.

Remoting layer: the encapsulation of network transport protocols and data transformations.

If each layer is subdivided, there are altogether ten layers.

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Interface service layer (Service): this layer is related to business logic, and the corresponding interfaces and implementations are designed according to the business of provider and consumer.

Configuration layer (Config): configure the interface externally and initialize the configuration centered on ServiceConfig and ReferenceConfig.

Service proxy layer (Proxy): the service interface transparent proxy. Both Provider and Consumer generate proxy classes, which make the service interface transparent. The proxy layer implements service invocation and result return.

Service Registration layer (Registry): encapsulates the registration and discovery of service addresses, focusing on the service URL.

Routing layer (Cluster): encapsulates the routing and load balancing of multiple providers, bridges the registry, takes Invoker as the center, and extends the interfaces for Cluster, Directory, Router and LoadBlancce.

Monitoring layer (Monitor): monitoring the number and time of RPC calls, with Statistics as the center, and extending interfaces for MonitorFactory, Monitor and MonitorService.

Remote invocation layer (Protocal): encapsulates RPC calls, centers on Invocation and Result, and extends interfaces for Protocal, Invoker and Exporter.

Information exchange layer (Exchange): encapsulates the request response mode and changes steps synchronously. With Request and Response as the center, the extended interfaces are Exchanger, ExchangeChannel, ExchangeClient and ExchangeServer.

Network Transport layer (Transport): abstract mina and netty are unified interfaces, Message is the center, and the extended interfaces are Channel, Transporter, Client, Server and Codec.

Data serialization layer (Serialize): reusable tools with extension interfaces for Serialization, ObjectInput, ObjectOutput, and ThreadPool.

The calling relationship between them can be seen directly on the official website below.

3. Dubbo SPI mechanism

Dubbo uses micro-kernel design + SPI extension technology to build the core framework and meet the customized needs of users. Let's focus on SPI here.

3.1 microkernel

Microkernel and macro kernel at the operating system level:

Microkernel Microkernel: a kernel design architecture that consists of as concise programs as possible to achieve the most basic functions needed by an operating system, including underlying addressing space management, thread management, and inter-process communication. Successful examples are QNX systems, such as BlackBerry and car markets.

Macro kernel Monolithic: process management, memory management, file system, process communication and other functions are all implemented as the kernel, while the micro kernel retains only the most basic functions. Linux is the macro kernel architecture design.

The generalized microkernel in Dubbo:

The idea is the core system + plug-ins, to put it bluntly, it abstracts the immutable functions as the core, and expands the changed functions as plug-ins, which is in line with the open and closed principle and is easier to expand and maintain. For example, in the small overlord game machine, the body itself is the core system, and the game film is the plug-in. Vscode, Idea and chrome are all products of microkernels.

In fact, the micro-kernel architecture is always an architectural idea, which can be a framework level or a module design. Its essence is to abstract the changed parts into plug-ins, so that various requirements can be quickly and easily met without affecting the overall stability.

3.2 SPI meaning

The mainstream databases are MySQL, Oracle, DB2 and so on. These databases are developed by different companies, and their underlying protocols are different, so how to restrict them? Generally, it is to customize the unified interface, regardless of the specific implementation, anyway, it can be programmed to the same interface. Just wait until you actually use it with a concrete implementation class, but the question is where to find that implementation class? At this point, you can use the agreed law to write the implementation class to the specified location.

SPI, whose full name is Service Provider Interface, is a service discovery mechanism. It prescribes to look for files in the META-INF/services folder under the ClassPath path and automatically load the classes defined in the files.

3.3 SPI demo

Interface:

Package com.example.demo.spi; public interface SPIService {void execute ();}

Implementation class 1:

Public class SpiImpl1 implements SPIService {@ Override public void execute () {System.out.println ("SpiImpl1.execute ()");}}

Implementation class 2:

Public class SpiImpl2 implements SPIService {@ Override public void execute () {System.out.println ("SpiImpl2.execute ()");}}

Configuration path

Call load class

Package com.example.demo.spi; import sun.misc.Service; import java.util.Iterator; import java.util.ServiceLoader; public class Test {public static void main (String [] args) {Iterator providers = Service.providers (SPIService.class); ServiceLoader load = ServiceLoader.load (SPIService.class); while (providers.hasNext ()) {SPIService ser = providers.next (); ser.execute () } System.out.println ("- -"); Iterator iterator = load.iterator (); while (iterator.hasNext ()) {SPIService ser = iterator.next (); ser.execute ();}

3.4 SPI source code tracking

The logic of the underlying call to ServiceLoader.load (SPIService.class) is as follows: the underlying calls to iterator.hasNext () and iterator.next () are as follows:

3.5 Java SPI disadvantages

You cannot load on demand. When Java SPI loads extension points, it loads all available extension points at once, many of which are unnecessary and a waste of system resources.

The way to get an implementation class is not flexible enough, it can only be obtained in the form of Iterator, and the corresponding implementation class cannot be obtained according to a parameter.

If AOP and dependency injection are not supported, JAVA SPI may lose the exception information of the load extension point, making it difficult to trace the problem.

3.6 Dubbo SPI

Dubbo, which is not easy to use with JDK, implements a SPI of its own, which can instantiate the specified implementation class by name, and implement IOC, AOP and adaptive extension SPI.

Key = com.sowhat.value

Unlike Java SPI, Dubbo's convention for configuration file directories is divided into three categories of directories.

META-INF/services/: the SPI configuration file in this directory is used to be compatible with Java SPI.

META-INF/dubbo/: this directory holds user-defined SPI configuration files.

META-INF/dubbo/internal/: this directory stores the SPI configuration file used internally by Dubbo.

If you use it, it is easy to introduce dependency, and then Baidu tutorial can be done.

@ Test void sowhat () {ExtensionLoader spiService = ExtensionLoader.getExtensionLoader (SPIService.class); / / get the implementation class object SPIService demo1 = spiService.getExtension ("SpiImpl1"); demo1.execute ();}

3.7 Dubbo SPI source code tracking

The whole idea of the ExtensionLoader.getExtension method is to find out whether the cache exists. If it does not exist, read the SPI file, create classes through reflection, and then set dependency injection for these things. If there is a wrapper class, the execution process is shown below:

Let's talk about four important parts:

1.injectExtension IOC

Look for the set method, and then inject if you find the dependent object based on the parameter.

2.WrapperClass AOP

Wrapper class, Dubbo helps you to automatically wrap, as long as the constructor of an extension class has only one parameter and is an extension interface type, it will be judged to be a wrapper class.

3.Activate

Active has three attributes, group indicates which side the decoration is on, provider or consumer,value indicates that it is activated when it appears in the URL parameter, and order indicates the order of the implementation classes.

3.8 Adaptive adaptive extension

Requirements: after loading the SPI extension according to the configuration, you do not want the extension to be loaded at startup, but want to dynamically select the corresponding extension according to the parameters at the time of the request. Implementation: Dubbo uses a proxy mechanism to achieve adaptive extension, compiling a proxy class through JDK or Javassist for the interface that the user wants to extend, and then creating an instance through reflection. The instance will know the required extension class according to the request parameters of the original method, and then get the real instance to call it through ExtensionLoader.getExtensionLoader (type.class) .getExtension (name). See the official website example.

Adaptive implementation class of public interface WheelMaker {Wheel makeWheel (URL url);} / / WheelMaker interface public class AdaptiveWheelMaker implements WheelMaker {public Wheel makeWheel (URL url) {if (url = = null) {throw new IllegalArgumentException ("url = = null");} / / 1. Call the getXXX method of url to get the parameter values String wheelMakerName = url.getParameter ("Wheel.maker"); if (wheelMakerName = = null) {throw new IllegalArgumentException ("wheelMakerName = = null");} / / 2. Call ExtensionLoader's getExtensionLoader to get the loader / / 3. Call the getExtension of ExtensionLoader to load the implementation class WheelMaker wheelMaker = ExtensionLoader.getExtensionLoader (WheelMaker.class). GetExtension (wheelMakerName) based on the parameters obtained from url as the class name; / / 4. Call the concrete method of the implementation class to implement the call. Return wheelMaker.makeWheel (URL url);}}

Looking at the source code of Adaptive annotations shows that the annotations can be used on classes or methods, and Adaptive annotations have different implementation logic on classes or methods.

7.8.1 Adaptive comments on the class

When Adaptive annotations are on a class, Dubbo will not generate proxy classes for this class, and Adaptive annotations on classes are rare. In Dubbo, only two classes are annotated by Adaptive, namely AdaptiveCompiler and AdaptiveExtensionFactory, indicating that the loading logic of the extension is manually coded, which is not the focus of our attention.

7.8.2 Adaptive comments on the method

When Adaptive comments on the method, Dubbo generates proxy logic for the method, indicating that the extended loading logic needs to be automatically generated by the framework. The general implementation mechanism is as follows:

Load the interface marked with @ Adaptive annotation. If it does not exist, the Adaptive mechanism is not supported.

Generate subclass code for the target interface according to a certain template, compile the generated code, and then generate objects of this class through reflection

Combined with the generated object instance, the configuration of the specified key is obtained through the incoming URL object, and then the corresponding class object of the key is loaded, and finally the call is delegated to the class object.

@ SPI ("apple") public interface FruitGranter {Fruit grant (); @ Adaptive String watering (URL url);}-/ / Apple grower public class AppleGranter implements FruitGranter {@ Override public Fruit grant () {return new Apple ();} @ Override public String watering (URL url) {System.out.println ("watering apple"); return "watering finished" }}-- / / Banana grower public class BananaGranter implements FruitGranter {@ Override public Fruit grant () {return new Banana ();} @ Override public String watering (URL url) {System.out.println ("watering banana"); return "watering success";}}

Call the method implementation:

Public class ExtensionLoaderTest {@ Test public void testGetExtensionLoader () {/ / first create a URL object for simulation URL url = URL.valueOf ("dubbo://192.168.0.1:1412?fruit.granter=apple"); / / get a FruitGranter object FruitGranter granter= ExtensionLoader.getExtensionLoader (FruitGranter.class) .getAdaptiveExtension () through ExtensionLoader / / use this FruitGranter to call its "adaptively annotated" method to get the call result String result = granter.watering (url); System.out.println (result);}}

Generate an inner class as above. The call process is as follows:

4. Dubbo service exposure process

4.1 Service exposure Overview

The Dubbo framework takes URL as the bus mode, and all the state data information in the running process can be obtained through URL, such as what serialization, communication and load balancing are used in the current system, are presented through the parameters of URL, so in the process of running the framework, the corresponding data is needed at a certain stage, which can be obtained from the parameter list of URL through the corresponding Key. The specific parameters of URL are as follows:

Protocol: refers to various protocols in dubbo, such as: dubbo thrift http username/password: username / password host/port: host / port path: interface name parameters: parameter key value pair

Protocol://username:password@host:port/path?k=v

Service exposure is divided into three parts in terms of code flow:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Check the configuration and finally assemble it into URL.

Expose services to local services and remote services.

The service is registered with the registry.

From the perspective of object-building transformation, service exposure is divided into two steps:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Encapsulate the service as an Invoker.

Convert Invoker to Exporter through protocol.

4.2 Service exposed source code tracking

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

The container starts. After the Spring IOC is refreshed, call onApplicationEvent to open the service exposure, ServiceBean.

Export and doExport are stitched together to build URL. In order to shield the details of the call, an executable is exposed, and the invoker is obtained through ProxyFactory.

Calling the concrete Protocol converts the wrapped invoker into exporter, where SPI is used.

Then start the server server, listen on the port, and use NettyServer to create a listening server.

Register URL with the registry through RegistryProtocol, so that consumer can obtain provider information. Picture

5. Dubbo service reference process

An executable in Dubbo is an invoker, so both provider and consumer have to move closer to invoker. From the above demo, we can see that in order to call the remote interface without feeling, the underlying layer needs a proxy class to wrap the invoker.

There are two opportunities for the introduction of services:

Hungry Han style:

By implementing the afterPropertiesSet method in the InitializingBean interface of Spring, the container introduces the service by calling the afterPropertiesSet method of ReferenceBean.

Lazy style (default):

Lazy style is to start the introduction process only when the service is injected into other classes.

There are three ways to reference a service:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Local introduction: service exposure is locally exposed to avoid network invocation overhead.

Direct connection introduces remote service: do not start the registry, directly write the remote Provider address for direct connection.

Introduce remote services through the registry: decide how to load balance and invoke remote services through the registry.

Service reference process:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Check the configuration to build map, map to build URL, through the protocol on URL to use adaptive extension mechanism to call the corresponding protocol.refer to get the corresponding invoker, here

If you want to register yourself in the registry, then subscribe to the relevant information of the registry, get the ip of provider and other information, and then connect through the shared netty client.

When there are multiple URL, first traverse to build the invoker, then encapsulate it by StaticDirectory, and then merge through cluster, exposing only one invoker.

Then build the proxy, encapsulating the invoker to return the service reference, and then Comsumer invokes this proxy class.

Call method:

Oneway: doesn't care whether the request was sent successfully.

Async asynchronous call: Dubbo is naturally asynchronous. After the client invokes the request, the returned ResponseFuture is stored in the context, and the user can call future.get to get the result at any time. The asynchronous call identifies the request through a unique ID.

Sync synchronous call: future.get is called in the Dubbo source code, and the user feels that the method is blocked and must wait for the result before returning.

6. The whole process of Dubbo call

You may need to consider these things before calling:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Consumer and provider agree on a communication protocol, and dubbo supports a variety of protocols, such as dubbo, rmi, hessian, http, webservice and so on. The default is dubbo protocol, the connection belongs to a single long connection, NIO asynchronous communication. It is suitable to transfer a small amount of data (within 100kb for a single request), but the concurrency is very high.

Conventional serialization patterns are roughly divided into two categories, one is character type (XML or json people can understand but low transmission efficiency), and the other is binary stream (compact data, machine-friendly). Hessian2 is used as the serialization protocol by default.

Consumer provides the corresponding interface, method name, parameter type, parameter value and version number when calling provider.

The provider list provides services to the public, which involves the cloud load balancer selecting a provider to provide services.

Consumer and provider send messages to monitor regularly.

Call the general process:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

The client initiates a request to invoke the interface, which invokes the generated proxy class. The proxy class generates RpcInvocation and then calls the invoke method.

ClusterInvoker gets a list of services in the registry and gives an available invoker through load balancing.

Serialization and deserialization of network transmission data. Invoke the network service through NettyServer.

The server business thread pool accepts parsing data, and finds invoker from exportMap for invoke.

Call the real Impl to get the result and return it.

Call method:

Oneway: does not care whether the request is sent successfully, and the consumption is the least.

Sync synchronous call: future.get is called in the Dubbo source code, and the user feels that the method is blocked and must wait for the result before returning.

Async asynchronous call: Dubbo is naturally asynchronous. After the client invokes the request, the returned ResponseFuture is stored in the context, and the user can call future.get to get the result at any time. The asynchronous call identifies the request through a unique ID.

7. Dubbo cluster fault-tolerant load balancer

Dubbo introduces Cluster, Directory, Router, LoadBalance and Invoker modules to ensure the robustness of the Dubbo system. The relationship between them is shown below:

When a service is discovered, multiple remote calls are put into the Directory and then encapsulated into an Invoker through Cluster, which provides fault tolerance.

When consumers substitute, get an available invoker from Directory through load balancer, and finally initiate a call.

You can think that the Cluster in Dubbo encapsulates the above and comes with a variety of robust features.

7.1 Cluster fault tolerance

Cluster fault tolerance is implemented through the Cluster subclass on the consumer side. The Cluster interface has 10 implementation classes, and each Cluster implementation class creates a corresponding ClusterInvoker object. The core idea is to allow users to selectively call the Cluster middle layer, shielding the specific implementation details behind.

ClusterCluster Invoker functions the automatic switching function of FailoverClusterFailoverClusterInvoker failure. By default, FailfastClusterFailfastClusterInvoker is called once. If there is an error in the failed exception FailsafeClusterFailsafeClusterInvoker call, the log record FailbackClusterFailbackClusterInvoker failure returns empty. Retry ForkingClusterForkingClusterInvoker twice a task concurrently, and one OK calls invoker one by one. If all available AvailableClusterAvailableClusterInvoker is available, use that MergeableClusterMergeableClusterInvoker to combine and return the result.

7.2 Intelligent fault-tolerant load balancing

There are generally four load balancing strategies in Dubbo.

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

RandomLoadBalance: weighted random, its algorithm idea is simple. Suppose you have a set of servers servers = [A, B, C], the corresponding weights are weights = [5,3,2], and the sum of weights is 10. Now these weight values are tiled on one-dimensional coordinate values. [0,5) interval belongs to server A, [5,8) interval belongs to server B, and [8,10) interval belongs to server C. Next, a random number in the range of [0,10) is generated by the random number generator, and then the interval on which the random number will fall is calculated. The default implementation.

LeastActiveLoadBalance: load balancer with minimum number of active calls. Choose the provider with the least number of active calls to make calls. A small number of active calls means it is easy now, and the number of active calls is all added up from 0. A request active number + 1, and a request processing completed active number-1, so a small number of active calls can reflect the processing speed in disguise.

RoundRobinLoadBalance: weighted polling load balancer. For example, there are two servers An and B, and the order in which polling is called is A, B, A, and B. if the weight is added, the weight of A to B is 2:1, then the order of call is A, A, B, A, A, B.

ConsistentHashLoadBalance: consistent Hash load balancer generates a hash value from the server's IP and other information, projects the hash value onto the ring as a node, and then looks for the first node greater than or equal to the hash value of this key clockwise when key comes to find it. Generally speaking, virtual nodes are also introduced to make the data more decentralized and avoid data tilting to crush a node. The following figure shows that Dubbo has 160 virtual nodes by default. Picture

7.3 Intelligent fault-tolerant service catalog

With regard to the service directory Directory, you can understand it as a collection of the same service Invoker, and the core is the RegistryDirectory class. It has three functions.

Get the invoker list from the registry.

Monitor the changes of the registry invoker, the up and down of invoker.

Refresh the invokers list to the service directory.

7.4 Intelligent fault-tolerant service routing

Service routing is actually a routing rule that specifies which service providers the service consumer can invoke. A conditional routing rule consists of two conditions that are used to match service consumers and providers, respectively. For example, there is a rule:

Host = 10.20.153.14 = > host = 10.20.153.12

This rule indicates that service consumers with an IP of 10.20.153.14 can only call services on machines with an IP of 10.20.153.12, not services on other machines. The format of conditional routing rules is as follows:

[service consumer matching criteria] = > [service provider matching criteria]

If the service consumer matching condition is empty, it means that no restriction is imposed on the service consumer. If the service provider matching condition is empty, the service is disabled for some service consumers.

8. Design RPC

After reading through the general implementation of Dubbo, you can actually follow suit. A RPC framework roughly requires the following things:

The registration of the service can be done with the one found. You can use ZooKeeper or Redis to implement it.

Next, when consumer initiates a request, your interface-oriented programming, ah, uses a dynamic proxy to implement the call.

Multiple provider provide the same service. You use LoadBalance.

After you finally choose a machine, you agree on the communication protocol, how to serialize and deserialize?

The bottom layer is implemented in the ready-made high-performance Netty framework NIO pattern.

After the service is turned on, there is monitor.

Thank you for your reading, the above is the content of "what are the problems about Dubbo". After the study of this article, I believe you have a deeper understanding of what is the problem of Dubbo, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.