Dubbo SPI机制ExtensionLoader浅析

深碍√TFBOYSˉ_ 2022-10-22 04:21 22阅读 0赞

### 1.getExtensionLoader ###

返回SPI接口对应的ExtensionLoader

// 根据类型查找对应的扩展加载器，如果没有，则创建一个并且加入EXTENSION_LOADERS
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) { 
        if (type == null) { 
            throw new IllegalArgumentException("Extension type == null");
        }
        if (!type.isInterface()) { 
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        if (!withExtensionAnnotation(type)) { 
            throw new IllegalArgumentException("Extension type (" + type +
                                               ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }
    	// private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) { 
            // private final Class<?> type;
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

### 2.getExtension ###

根据扩展点名称获取对应的实现类实例

public T getExtension(String name) { 
        if (StringUtils.isEmpty(name)) { 
            throw new IllegalArgumentException("Extension name == null");
        }
        if ("true".equals(name)) { 
            return getDefaultExtension();
        }
        // private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();
        // 根据扩展名查找对应的Holder,如果没有则创建一个并放入cachedInstances
        // 如果有的话直接返回缓存的实例
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        if (instance == null) { 
            synchronized (holder) { 
                instance = holder.get();
                if (instance == null) { 
                    // 创建扩展点实现
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

private T createExtension(String name) { 
        // 如果cachedClasses为空，使用三种LoadingStrategy从三个目录中获取name对应的CLass
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) { 
            throw findException(name);
        }
        try { 
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) { 
                // 如果缓存中没有，则通过newInstance方法创建实例并放入EXTENSION_INSTANCES中
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) { 
                for (Class<?> wrapperClass : wrapperClasses) { 
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            initExtension(instance);
            return instance;
        } catch (Throwable t) { 
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                                            type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }