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

This article mainly explains "what is the Dubbo SPI mechanism". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Now let the editor take you to learn "what is the Dubbo SPI mechanism"?

What is SPI?

SPI is a kind of abbreviation, the full name is Service Provider Interface,Java itself provides a set of SPI mechanism, the essence of SPI is to configure the fully qualified name of the interface implementation class in the file, and the service loader reads the configuration file and loads the implementation class, so that the implementation class can be replaced dynamically for the interface at run time, which is also a means for many framework components to achieve extended functions.

However, the Dubbo SPI mechanism we are going to talk about today is a little different from Java SPI. Instead of using Java's native SPI mechanism, Dubbo has improved and enhanced it, so that it can easily extend the function of Dubbo.

To learn something, you have to learn with questions. Let's ask a few questions first, and then move on.

1. What is SPI (explained at the beginning)

What's the difference between 2.Dubbo SPI and Java native?

3. How to write the two implementations

How to implement Java SPI

Define an interface first:

Public interface Car {void startUp ();}

Then create two classes, both implementing the Car interface

Public class Truck implements Car {@ Override public void startUp () {System.out.println ("The truck started");}} public class Train implements Car {@ Override public void startUp () {System.out.println ("The train started");}}

Then create a fully qualified name of the interface, com.example.demo.spi.Car, under the project META-INF/services folder.

The fully qualified name of the implementation class is written on the content of the file, as follows:

Com.example.demo.spi.Train com.example.demo.spi.Truck

Finally, write a test code:

Public class JavaSPITest {@ Test public void testCar () {ServiceLoader serviceLoader = ServiceLoader.load (Car.class); serviceLoader.forEach (Car::startUp);}}

Output result after execution:

The train started The truck started

How to implement Dubbo SPI

The SPI used by Dubbo is not native to Java, but has been reimplemented. The main logic is in the ExtensionLoader class, and the logic is not difficult. I'll talk about it later.

Look at the use, it is not much different from that of Java. Based on the previous example, the interface class needs to be annotated with @ SPI:

@ SPI public interface Car {void startUp ();}

The implementation class does not need to be changed

The configuration file needs to be placed under META-INF/dubbo. There are some differences in how to write the configuration. Look directly at the code:

Train = com.example.demo.spi.Train truck = com.example.demo.spi.Truck

Finally, it's time to test the class. Look at the code first:

Public class JavaSPITest {@ Test public void testCar () {ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader (Car.class); Car car = extensionLoader.getExtension ("train"); car.startUp ();}}

Execution result:

The train started

Notes commonly used in Dubbo SPI

@ SPI is marked as an extended interface

@ Adaptive adaptive extension implementation class flag

@ Activate tag for automatic activation condition

Summarize the differences between the two:

The difference in usage Dubbo uses ExtensionLoader instead of ServiceLoader, and its main logic is encapsulated in this class

Configuration files are stored in different directories, Java in META-INF/services,Dubbo and META-INF/dubbo,META-INF/dubbo/internal

Java SPI will instantiate all the implementations of the extension point at once. If an extension implementation is initialized and is not needed, a lot of resources will be wasted.

Dubbo SPI adds support for extension points IOC and AOP, and one extension point can be injected directly into other extension points by setter

The Java SPI loading process failed and the name of the extension point was not available. For example, the ScriptEngine,getName () of the JDK standard gets the name of the script type. If RubyScriptEngine fails to load the RubyScriptEngine class because the jruby.jar it depends on does not exist, there will be no hint for this failure. When the user executes the ruby script, it will report whether ruby is supported, not the reason for the real failure.

Can the first three questions have been answered? Isn't it very simple?

Dubbo SPI source code analysis

Dubbo SPI is used to obtain an ExtensionLoader instance through the getExtensionLoader method of ExtensionLoader, and then obtain the extended class object through the getExtension method of ExtensionLoader. The getExtensionLoader method is used to obtain the ExtensionLoader corresponding to the extension class from the cache. If there is no cache, create a new instance and add the code directly:

Public T getExtension (String name) {if (name = = null | | name.length () = = 0) {throw new IllegalArgumentException ("Extension name = = null");} if ("true" .equals (name)) {/ / get the default extension implementation class return getDefaultExtension ();} / / used to hold the target object Holder holder = cachedInstances.get (name) If (holder = = null) {cachedInstances.putIfAbsent (name, new Holder ()); holder = cachedInstances.get (name);} Object instance = holder.get (); / / DCL if (instance = = null) {synchronized (holder) {instance = holder.get () If (instance = = null) {/ / create an extended instance instance = createExtension (name); / / set the instance to holder holder.set (instance);} return (T) instance;}

The main thing the above code does is to check the cache first. The cache does not exist to create an extension object.

Let's take a look at the creation process:

Private T createExtension (String name) {/ / load all extension classes from the configuration file to get the mapping table from configuration item name to configuration class Class clazz = getExtensionClasses () .get (name); if (clazz = = null) {throw findException (name);} try {T instance = (T) EXTENSION_INSTANCES.get (clazz) If (instance = = null) {/ / reflection creates an instance EXTENSION_INSTANCES.putIfAbsent (clazz, clazz.newInstance ()); instance = (T) EXTENSION_INSTANCES.get (clazz);} / / injects dependency injectExtension (instance) into the instance; Set > wrappers = cachedWrapperClasses If (wrappers = = null) {cachedWrapperClasses = new ConcurrentHashSet c = extensionClasses.get (n); if (c = = null) {/ / the mapping relationship between storage name and Class extensionClasses.put (n, clazz);} else if (c! = clazz) {throw new IllegalStateException ("...") }

To sum up, the loadClass method operates on different caches, such as cachedAdaptiveClass, cachedWrapperClasses, cachedNames, and so on.

Here basically about the cache class loading process analysis, other logic is not difficult, carefully read down plus Debug can understand.

At this point, I believe you have a deeper understanding of "what is the Dubbo SPI mechanism", might as well come to the actual operation of it! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.