Dubbo interview questions

MyBatis (MyBatis) (ZooKeeper) (Dubbo) (Elasticsearch) (Redis) (MySQL) (Dubbo) Java concurrent programming interview questions (1)

• Interface Service Layer: This layer is related to business logic, and the corresponding interfaces and implementations are designed according to the services of provider and consumer
• Configuration Layer (Config): External configuration interface, centered on ServiceConfig and ReferenceConfig
• Service Proxy Layer: service interface transparent proxy, which generates the service client Stub and server Skeleton. The ServiceProxy is centered on the ServiceProxy, and the extension interface is ProxyFactory
• Service Registry Layer: Encapsulates the registration and discovery of service addresses, centering on service urls and extending interfaces to RegistryFactory, Registry, and RegistryService
• Routing Layer (Cluster): encapsulates routing and load balancing for multiple providers, and Bridges registries, invoker-centric, with extended interfaces asCluster, Directory, Router and LoadBlancce
• Monitor Layer: Monitors the number of RPC calls and call time. With Statistics as the center, the interfaces are MonitorFactory, Monitor, and MonitorService
• Remote Call Layer (Protocal): Encapsulates RPC calls with Invocation and Result centered and extends interfaces to Protocal, Invoker, and Exporter
• Information Exchange Layer: Encapsulates the request response mode, synchronous to asynchronous. Centered on Request and Response, the extended interface isExchanger, ExchangeChannel, ExchangeClient and ExchangeServer
• Network Transport LayerAbstract Mina and NetTY are unified interfaces centered on Message, and extended interfaces include Channel, Transporter, Client, Server, and Codec
• Data Serialization Layer (Serialize): reusable tools with Serialization, ObjectInput, ObjectOutput, and ThreadPool extensions

It blocks by default and can be called asynchronously, if there is no return value. Dubbo is a non-blocking parallel invocation based on NIO. The client can complete the parallel invocation of multiple remote services without starting multithreading. Compared with multithreading, the overhead is relatively small.

Hessian serialization is recommended, as well as Duddo, FastJson, and Java serialization.

Adopt multi-version development, do not affect the old version.

You can directly connect to a service point-to-point by modifying the configuration, or directly connect to a service through Telnet.

The corresponding service cannot be found in the registry. Check if the service implementation class has added the @service annotation and cannot connect to the registry. Check if the corresponding test IP in the configuration file is correct

Dubbo framework uses a variety of design patterns during initialization and communication, which can flexibly control functions such as class loading and weight limit control.

• Factory mode: Provider invokes the Export method of ServiceConfig when exporting the service. There is a field in ServiceConfig:

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtensi on(a);
Copy the code

There’s a lot of this code in Dubbo. This is also a factory pattern, except that the implementation class is retrieved using the JDK SPI mechanism. The advantage of this implementation is that it is extensible, and to extend the implementation, you can simply add a file to the classpath, with zero code intrusion. In addition, Adaptive implementation, like the one above, can dynamically decide which implementation to call when calling, but because this implementation uses dynamic proxy, it will cause trouble in code debugging, and the implementation class actually called needs to be analyzed.

• Decorator pattern: Dubbo makes heavy use of decorator pattern in both startup and invocation phases. In the case of a Provider, this is done in the ProtocolFilterWrapper buildInvokerChain, which implements a Filter that has group= Provider in its annotations. In order, the last call order is:

EchoFilter -> ClassLoaderFilter -> GenericFilter -> ContextFilter -> ExecuteLimitFilter -> TraceFilter -> TimeoutFilter -> MonitorFilter -> ExceptionFilter
Copy the code

More specifically, it’s a mix of decorator and chain of responsibility patterns. For example, EchoFilter is used to determine if it is an echo test request, and if it is, it returns the content directly, which is a chain of responsibility. Something like ClassLoaderFilter simply adds functionality to the main function, changing the ClassLoader of the current thread, which is a typical decorator pattern.

• Observer mode: When Dubbo’s Provider is started, it interacts with the registry to register its own service and then subscribe to its own service. When Dubbo’s Provider is subscribed, the Observer mode is used and a Listener is started. The registry checks for service updates every 5 seconds and sends a Notify message to the service provider. After receiving the notify message, the provider runs the notify method of NotifyListener and executes the listener method.
• Dynamic proxy mode: The Adaptive implementation of Dubbo’s ExtensionLoader class extending JDK SPI is typical of dynamic proxy implementations. Dubbo needs to control the implementation class flexibly, that is, in the call phase, dynamically decide which implementation class to call according to the parameters, so the method of using the proxy class can achieve flexible call. The code that generates the proxy class is ExtensionLoadercreateAdaptiveExtensionClassCodeMethods. The main logic of the proxy class is to get the value of the specified parameter in the URL parameter as the key to get the implementation class.

• The STANDARD SPI in the JDK loads all extension implementations at once. If there are extensions that are time consuming but are not used, it is a waste of resources. So it’s not realistic to just want to load one implementation

• DUBBO SPI

  • Extensions to Dubbo do not require any changes to Dubbo’s source code
  • Lazy loading allows you to load only as many extensions as you want at a time.
  • Added support for extension points IOC and AOP, where an extension point can be directly setter injected into other extension points.
  • Dubbo’s extension mechanism works well with third-party IoC containers and supports Spring beans by default.

To improve the speed of data access. Dubbo provides declarative caching to reduce user caching efforts

<dubbo:reference cache="true" />
Copy the code

Cache =”true” cache=”true”

Dubbo must rely on JDK, otherwise optional.

Set mock=”return NULL “via dubbo: Reference. You can also change the mock value to true, and then implement a mock class in the same path as the interface, using the “interface name + mock” suffix. Then implement your own degradation logic in the Mock class

Dubbox is an extension project made by Dangdang based on Dubbo after Dubbo stopped maintenance, such as adding Restful service calls and updating open source components.

There’s Spring Cloud for Spring, Thrift for Facebook, Finagle for Twitter