本文主要参考自Dubbo官方文档、Dubbo项目源码以及网络文章和相关书籍，并附上自身的一些理解，如有遗漏或错误，还望海涵并指出。谢谢！
------本文基于Dubbo-2.6.1版本
一、什么是SPI
SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dubbo 中，SPI 是一个非常重要的模块。基于 SPI，我们可以很容易的对 Dubbo 进行拓展。
Java中的框架大量使用了SPI机制来实现接口的动态拓展，譬如数据库连接驱动Driver(META-INF/services)，以及SpringBoot的Starter提供了自己的SPI机制(META-INF/spring.factories)。
dubbo对Java的SPI进行了增强，提供了对拓展点的IoC以及AOP的支持，并且相对于Java SPI来说，无需加载全部实现类，避免资源的浪费。dubbo SPI用以拓展协议、路由等26个拓展点，这也是整个dubbo体系的核心功能之一。
具体的SPI拓展用法参考dubbo文档：
http://dubbo.apache.org/zh-cn/docs/dev/SPI.html
二、基本使用
2.1、核心注解和URL类
首先介绍下三个SPI核心注解：@SPI、@Adaptive、@Activate，整个dubbo项目中只要有使用SPI的地方就需要用到这三个注解来实现底层的SPI机制，它们的作用是：
-
@SPI：
指定当前接口为可拓展接口，@SPI(“impl1”)表示该接口点默认实现类为"impl1"。 -
@Adaptive：
表明该可拓展接口的方法是可以被动态替换的（具有多个不同的实现类可以执行这个方法），@Adaptive({“key1”, “key2”})可以动态地通知指定key1或key2的实现类，来动态地执行制定实现类的该方法。
Adaptive 可注解在类或方法上。当 Adaptive 注解在类上时，Dubbo 不会为该类生成代理类。注解在方法（接口方法）上时，Dubbo 则会为该方法生成代理逻辑。Adaptive 注解在类上的情况很少，在 Dubbo 中，仅有两个类被 Adaptive 注解了，分别是 AdaptiveCompiler 和 AdaptiveExtensionFactory。此种情况，表示拓展的加载逻辑由人工编码完成。更多时候，Adaptive 是注解在接口方法上的，表示拓展的加载逻辑需由框架自动生成。 -
@Activate：
扩展点自动激活加载的注解，就是用条件来控制该扩展点实现是否被自动激活加载，在扩展实现类上面使用
注意：
1.所有扩展点都通过传递URL类携带配置信息，所以适配器中的方法必须携带URL参数，才能根据URL中的配置来选择对应的扩展实现。
2.@Adaptive注解中有一些key值，比如适配方法的注解中有两个key，分别为“key1”和“key2”，URL会首先去取key1对应的value来作为@SPI注解中写到的key值（也就是要执行的具体实现类方法），如果为空，则去取key2对应的value，如果还是为空，则会根据SPI默认的key去调用扩展的实现类，如果@SPI没有设定默认值，则会抛出IllegalStateException异常。
2.2、单元测试
来看看dubbo-common模块下的关于SPI的单元测试，就可以知道SPI是如何使用的了：
- 定义拓展接口
- SimpleExt
package com.alibaba.dubbo.common.extensionloader.ext1;
/**
* Simple extension, has no wrapper
*/
// 该接口的默认实现为impl1
@SPI("impl1")
public interface SimpleExt {
// @Adaptive example, do not specify a explicit key.
@Adaptive
String echo(URL url, String s);
@Adaptive({"key1", "key2"})
String yell(URL url, String s);
// no @Adaptive
String bang(URL url, int i);
}
- 定义实现类
- SimpleExtImpl1
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl1 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl1-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl1-yell";
}
public String bang(URL url, int i) {
return "bang1";
}
}
- SimpleExtImpl2
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl2 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl2-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl2-yell";
}
public String bang(URL url, int i) {
return "bang2";
}
}
- SimpleExtImpl3
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl3 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl3-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl3-yell";
}
public String bang(URL url, int i) {
return "bang3";
}
}
- 定义SPI配置文件
根据SPI的规则，为了实现对SimpleExt的动态拓展，需要在resource/META-INF/dubbo目录下以SimpleExt接口全限定名作为文本文件，并且在该文件中以xxx=全限定名Xxx实现类标示该接口的所有可能实现类：
- META-INF/dubbo/internal/com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt
# Comment 1
impl1=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl1#Hello World
impl2=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl2 # Comment 2
impl3=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl3 # with head space
注意，这里的dubbo/internal表明这是dubbo自身内置的实现
- 单元测试
- ExtensionLoader_Adaptive_Test
@Test
public void test_getAdaptiveExtension_defaultAdaptiveKey() throws Exception {
{
// URL中不指定key，使用默认的impl1作为实现类
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl1-echo", echo);
}
{
// URL中通过SimleExt接口的拆分名simple.ext指定实现类为impl2
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
map.put("simple.ext", "impl2");
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl2-echo", echo);
}
}
@Test
public void test_getAdaptiveExtension_customizeAdaptiveKey() throws Exception {
// URL通过key2和key1来分别指定实现类为impl2和impl3
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
map.put("key2", "impl2");
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.yell(url, "haha");
assertEquals("Ext1Impl2-yell", echo);
url = url.addParameter("key1", "impl3"); // note: URL is value's type
echo = ext.yell(url, "haha");
assertEquals("Ext1Impl3-yell", echo);
}
三、SPI机制源码解析
- Dubbo SPI机制源码的官方文档解读：http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html
整个SPI机制的实现代码都位于dubbo-common模块中的com.alibaba.dubbo.common.extension包下，来看看extension包所含的内容：
所含的Java代码量（不含注释）为900行左右：
其中，ExtensionLoader是Dubbo SPI机制的核心类，相当于Java SPI机制中的ServiceLoader，ServiceLoader通过加载的是META-INF/services下的内容，而ExtensionLoader加载的是META-INF/dubbo下的内容并且做出了更复杂的定制。
3.1、ExtensionLoader
ExtensionLoader是整个Dubbo SPI的核心类，用来实现对META-INF/dubbo下的实现类做SPI判断、动态加载、自动装配、封装成Wrapper给用户所使用。
3.1.1、属性
// logger
private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
// JDK SPI文件夹
private static final String SERVICES_DIRECTORY = "META-INF/services/";
// Dubbo 用户SPI文件夹
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
// Dubbo 内置SPI文件夹
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
// 正则表达式，以,分割成字符串数组
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
// 拓展加载器集合，key为拓展接口，value为对应的加载器
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
// 拓展加载器实例集合，key为拓展实现类，value为拓展接口
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
// ==============================
// 被拓展的接口对象
private final Class<?> type;
// 当前拓展对象工厂，内含getExtension方法
private final ExtensionFactory objectFactory;
// 缓存的拓展接口与拓展名
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
// 缓存的拓展实现类集合（Holder是拓展对象的包装实现类，在其中包装了实现类）
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
// 扩展名与加有@Activate的自动激活类的映射
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
// 缓存的扩展对象集合，key为扩展名，value为扩展对象
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
// 缓存的@Adaptive对象
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
// 缓存的自适应扩展对象的类
private volatile Class<?> cachedAdaptiveClass = null;
// 缓存的默认扩展名，@SPI中设置的值
private String cachedDefaultName;
// 创建@Adaptive对象失败异常
private volatile Throwable createAdaptiveInstanceError;
// 拓展Wrapper实现类集合
private Set<Class<?>> cachedWrapperClasses;
// 拓展名与加载对应拓展类发生的异常的映射
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();
3.1.2、拓展类资源加载
首先， 为了获取到拓展类，ExtensionLoader做的的一件事就是对拓展类资源进行加载，这个步骤依次调用了getExtensionClasses方法、loadExtensionClasses和loadFile方法：
1）getExtensionClasses
private Map<String, Class<?>> getExtensionClasses() {
// 从缓存中获取拓展实现类
Map<String, Class<?>> classes = cachedClasses.get();
// 双重检查加锁，若classes不存在，则使用loadExtensionClasses方法
// 将实现类加入cachedClasses中，再进行获取
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
2）loadExtensionClasses
private Map<String, Class<?>> loadExtensionClasses() {
// 获取到该拓展接口的@SPI注解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
// 将@SPI注解的默认实现类名称放入cachedDefaultName中
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if (value != null && (value = value.trim()).length() > 0) {
String[] names = NAME_SEPARATOR.split(value);
if (names.length > 1) {
throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
+ ": " + Arrays.toString(names));
}
if (names.length == 1) cachedDefaultName = names[0];
}
}
// 创建extensionClasses，以拓展类名称为key，以具体拓展类为value放入map中
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
// 从3个SPI文件夹中加载拓展类
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadFile(extensionClasses, DUBBO_DIRECTORY);
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
3）loadFile
/*
* 根据SPI DIR加载拓展类到Map中
*/
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
// 获取ExtensionLoader的ClassLoader
ClassLoader classLoader = findClassLoader();
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
// h获取到SPI DIR下的urls，对其解析
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL url = urls.nextElement();
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
try {
String line = null;
while ((line = reader.readLine()) != null) {
// 忽略注释
final int ci = line.indexOf('#');
if (ci >= 0) line = line.substring(0, ci);
line = line.trim();
if (line.length() > 0) {
try {
String name = null;
// 用=号分割出实现类名称和全限定名
int i = line.indexOf('=');
if (i > 0) {
name = line.substring(0, i).trim();
line = line.substring(i + 1).trim();
}
if (line.length() > 0) {
// 用反射+全限定名+ClassLoader获取到实现类的Class对象
Class<?> clazz = Class.forName(line, true, classLoader);
if (!type.isAssignableFrom(clazz)) {
// 如果clazz并不是type的实现类，抛出异常
throw new IllegalStateException("Error when load extension class(interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + "is not subtype of interface.");
}
// 如果class已经声明了@Adaptive注解，那么设置默认的cachedAdaptiveClass为class
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
// 如果多个实现类都声明了@Adaptive注解，抛出异常
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
} else {
// 缓存拓展 Wrapper 实现类到 cachedWrapperClasses
try {
clazz.getConstructor(type);
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
wrappers.add(clazz);
} catch (NoSuchMethodException e) {
clazz.getConstructor();
if (name == null || name.length() == 0) {
name = findAnnotationName(clazz);
if (name == null || name.length() == 0) {
if (clazz.getSimpleName().length() > type.getSimpleName().length()
&& clazz.getSimpleName().endsWith(type.getSimpleName())) {
name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
} else {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
}
}
}
String[] names = NAME_SEPARATOR.split(name);
// 将拓展实现类加载到extensionClasses这个Map中
if (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
cachedActivates.put(names[0], activate);
}
for (String n : names) {
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
}
} catch (Throwable t) {
// 发生异常，记录到异常集合
IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
exceptions.put(line, e);
}
}
} // end of while read lines
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + url + ") in " + url, t);
}
} // end of while urls
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
3.1.3、获取指定Extension
当完成了拓展点的实现资源加载之后，需要获取到特定的拓展类（Extension）以调用相应的方法，第一种获取Extension的方法是通过getExtension方法并指定拓展类名称（在SPI文件中配置的那个xxx=XxxProtocol中的xxx就是名称）：
ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(name)
2）createExtension
创建指定拓展类对象并缓存。
private T createExtension(String name) {
// 首先获取到第一步资源加载中已经加载好的实现类class
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
// Dubbo自实现的IoC，通过setter方法注入实例所需的对象或属性
injectExtension(instance);
// 构建Wrapper对象
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
for (Class<?> wrapperClass : wrapperClasses) {
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
type + ") could not be instantiated: " + t.getMessage(), t);
}
}
3）injectExtension
Dubbo 自实现的IoC（通过过setter方法注入）
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
// 获取到实例的Method对象，解析出setter方法
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
Class<?> pt = method.getParameterTypes()[0];
try {
// 获取setter方法中的参数
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
// 通过参数获取到所需注入的对象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 执行setter方法注入
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
3.1.4、获取自适应Extension
要获取到Extension实现类，除第一种直接指定名称获取Extension方法外，还可以用更简单的方式获取到Extension，也就是通过getAdaptiveExtension方法获取到自适应的Extension，由Dubbo SPI机制来决定获取到哪个Extension。
ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension()
1）getAdaptiveExtension
该方法获取到自适应的拓展实现类对象。
public T getAdaptiveExtension() {
// 获取缓存的Adaptive实例对象
Object instance = cachedAdaptiveInstance.get();
// 若instance不存在
if (instance == null) {
// 双重检查加锁,通过createAdaptiveExtension方法创建instance
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
// 创建AdaptiveExtension
instance = createAdaptiveExtension();
// 将该instance存储到cachedAdaptiveInstance中
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
createAdaptiveInstanceError = t;
throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
}
}
}
} else {
throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
}
}
// 返回该instance
return (T) instance;
}
2）createAdaptiveExtension
该方法，创建自适应拓展实现类对象。
private T createAdaptiveExtension() {
try {
// 还是通过injectExtension做IoC注入
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
3）getAdaptiveExtensionClass
private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
4）createAdaptiveExtensionClass
创建自适应拓展类的代码并进行编译返回，生成Xxx$Adaptive自适应类。
private Class<?> createAdaptiveExtensionClass() {
// 生成自适应类的代码字符串
String code = createAdaptiveExtensionClassCode();
// 获取ClassLoader
ClassLoader classLoader = findClassLoader();
// 对代码进行编译，生成相应的Class返回
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
}
3.2、ExtensionFactory
整个SPI体系最重要的ExtensionLoader的主要源码看完了，现在来看看一些Factory接口和实现类。
该接口自身也是一个可拓展的接口，在ExtensionLoader中injectExtension方法中被用来获取到setter方法注入的对象：
try {
// 获取setter方法中的参数
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
// 通过参数获取到所需注入的对象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 执行setter方法注入
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
代码：
@SPI
public interface ExtensionFactory {
/**
* 获取拓展实例
*
* @param type object 拓展接口.
* @param name object 拓展名.
* @return object 拓展实例.
*/
<T> T getExtension(Class<T> type, String name);
}
ExtensionFactory有两个实现类，其实新版本中存在三个实现类，分别是：
AdaptiveExtensionFactory、SpiExtensionFactory和SpringExtensionFactory，其中AdaptiveExtensionFactory是自适应的实现类，使用的是ExtensionLoader来注入对象；而SpiExtensionFactory也是使用ExtensionLoader来注入对象，但是它会直接获取到当前type的自适应对象进行注入；而SpringExtensionFactory则是使用Spring IoC容器中的Bean进行注入。
- AdaptiveExtensionFactory
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
private final List<ExtensionFactory> factories;
public AdaptiveExtensionFactory() {
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
for (String name : loader.getSupportedExtensions()) {
list.add(loader.getExtension(name));
}
factories = Collections.unmodifiableList(list);
}
public <T> T getExtension(Class<T> type, String name) {
for (ExtensionFactory factory : factories) {
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
- SpiExtensionFactory
public class SpiExtensionFactory implements ExtensionFactory {
/**
* 获得拓展对象
*
* @param type object type. 拓展接口
* @param name object name. 拓展名
* @param <T> 泛型
* @return 拓展对象
*/
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) { // 校验是 @SPI
// 加载拓展接口对应的 ExtensionLoader 对象
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
// 加载拓展对象
if (!loader.getSupportedExtensions().isEmpty()) {
return loader.getAdaptiveExtension();
}
}
return null;
}
}
- SpringExtensionFactory
public class SpringExtensionFactory implements ExtensionFactory {
/**
* Spring Context 集合
*/
private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
public static void addApplicationContext(ApplicationContext context) {
contexts.add(context);
}
public static void removeApplicationContext(ApplicationContext context) {
contexts.remove(context);
}
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
for (ApplicationContext context : contexts) {
if (context.containsBean(name)) {
// 获得属性
Object bean = context.getBean(name);
// 判断类型
if (type.isInstance(bean)) {
return (T) bean;
}
}
}
return null;
}
}
9606
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
