搞懂dubbo的SPI扩展机制

1
2
3
4
public interface Animal {
   void run();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Cat implements Animal{
   @Override
   public void run() {
      System.out.println("小猫步走起来～");
   }
}
public class Dog implements Animal {
   @Override
   public void run() {
      System.out.println("小狗飞奔～");
   }
}

1
2
3
com.sunnick.animal.impl.Dog  
com.sunnick.animal.impl.Cat

1
2
3
4
5
6
7
8
9
public static void main(String[] s){
   System.out.println("======this is SPI======");
   ServiceLoader<Animal> serviceLoader = ServiceLoader.load(Animal.class);  
       Iterator<Animal> animals = serviceLoader.iterator();  
       while (animals.hasNext()) {  
           animals.next().run();
       }
}

1
2
3
4
======this is SPI======
小狗飞奔～
小猫步走起来～

1
2
3
4
5
6
7
8
9
10
try {
    String fullName = PREFIX + service.getName();
    if (loader == null)
        configs = ClassLoader.getSystemResources(fullName);
    else
        configs = loader.getResources(fullName);
} catch (IOException x) {
    fail(service, "Error locating configuration files", x);
}

1
2
3
4
5
6
7
8
9
String cn = nextName;
nextName = null;
Class<?> c = null;
try {
    c = Class.forName(cn, false, loader);
} catch (ClassNotFoundException x) {
    fail(service,"Provider " + cn + " not found");
}

1
2
3
dog=com.sunnick.animal.impl.Dog  
cat=com.sunnick.animal.impl.Cat

1
2
3
4
5
@SPI
public interface Animal {
   void run();
}

1
2
3
4
5
6
7
8
9
10
public void testDubboSPI(){
   System.out.println("======dubbo SPI======");
   ExtensionLoader<Animal> extensionLoader =
         ExtensionLoader.getExtensionLoader(Animal.class);
   Animal cat = extensionLoader.getExtension("cat");
   cat.run();
   Animal dog = extensionLoader.getExtension("dog");
   dog.run();
}

1
2
3
4
======dubbo SPI======
小猫步走起来～
小狗飞奔～

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public T getExtension(String name) {
    if(name != null && name.length() != 0) {
        if("true".equals(name)) {
    // 获取默认的拓展实现类
            return this.getDefaultExtension();
        } else {
      // Holder，顾名思义，用于持有目标对象
            Holder holder = (Holder)this.cachedInstances.get(name);
            if(holder == null) {
                this.cachedInstances.putIfAbsent(name, new Holder());
                holder = (Holder)this.cachedInstances.get(name);
            }
            Object instance = holder.get();
      // 双重检查
            if(instance == null) {
                synchronized(holder) {
                    instance = holder.get();
                    if(instance == null) {
             // 创建拓展实例
                        instance = this.createExtension(name);
                        holder.set(instance);
                    }
                }
            }
            return instance;
        }
    } else {
        throw new IllegalArgumentException("Extension name == null");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private T createExtension(String name) {
//获取所有的SPI配置文件，并解析配置文件中的键值对
    Class clazz = (Class)this.getExtensionClasses().get(name);
    if(clazz == null) {
        throw this.findException(name);
    } else {
        try {
            Object t = EXTENSION_INSTANCES.get(clazz);
            if(t == null) {
          //通过反射创建实例
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                t = EXTENSION_INSTANCES.get(clazz);
            }
    //此处省略一些源码 ......
            return t;
        } catch (Throwable var7) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " + this.type + ")  could not be instantiated: " + var7.getMessage(), var7);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private Map<String, Class<?>> getExtensionClasses() {
// 从缓存中获取已加载的拓展类
    Map classes = (Map)this.cachedClasses.get();
//双重检查
    if(classes == null) {
        Holder var2 = this.cachedClasses;
        synchronized(this.cachedClasses) {
            classes = (Map)this.cachedClasses.get();
            if(classes == null) {
          //加载拓展类
                classes = this.loadExtensionClasses();
                this.cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
private Map<String, Class<?>> loadExtensionClasses() {
// 获取 SPI 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的，即示例中的Animal
    SPI defaultAnnotation = (SPI)this.type.getAnnotation(SPI.class);
    if(defaultAnnotation != null) {
        String extensionClasses = defaultAnnotation.value();
        if(extensionClasses != null && (extensionClasses = extensionClasses.trim()).length() > 0) {
      // 对 SPI 注解内容进行切分
            String[] names = NAME_SEPARATOR.split(extensionClasses);
      // 检测 SPI 注解内容是否合法，不合法则抛出异常
            if(names.length > 1) {
                throw new IllegalStateException("more than 1 default extension name on extension " + this.type.getName() + ": " + Arrays.toString(names));
            }

            if(names.length == 1) {
                this.cachedDefaultName = names[0];
            }
        }
    }
    HashMap extensionClasses1 = new HashMap();
// 加载指定文件夹下的配置文件
    this.loadFile(extensionClasses1, "META-INF/dubbo/internal/");
    this.loadFile(extensionClasses1, "META-INF/dubbo/");
    this.loadFile(extensionClasses1, "META-INF/services/");
    return extensionClasses1;
}