上一章简单对dubbo的使用做了一个很简单的概括和总结,今天介绍一下能够让dubbo如此灵活强大的技术支撑ESPI机制,为什么叫ESPI,因为是为了和JDK的SPI的区分开来,默认的JDK是自带SPI机制,所谓SPI就是服务提供接口编程,它的组成有3个部分来实现
& 编写接口和对应的实现类
& 编写服务清单文件
& 编写服务实现的配置文件
那么加了一个E,就是代表的Extension是扩展的意思,既然是扩展,功能上肯定比原始的SPI要强大很多,先简单做一个对比.
& JDK的SPI默认是加载所有的扩展点的实现,不存在延时加载机制
& JDK的SPI如果扩展点加载失败,无法获取到对应的扩展点名称
& JDK的SPI不支持动态实现AOP和IOC这种特殊机制
接下来就分析Dubbo中的扩展点实现,就是虽然这个功能很强大,但是dubbo实现起来并不是那么的复杂,核心代码基本上都放在一个类里面来实现了,这个就是ExtensionLoader类,主要把这个了解透了,基本是就把握了Dubbo的SPI机制.这个类里面的代码行不超过1000行,所以接下会针对每一个方法进行分析,当然是用它很简单只需要一行代码即可,ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(DubboProtocol.NAME);就可以获取到一个扩展点对应的实现了.那就开始分析每一个方法:
getExtensionLoader:静态工厂方法getExtensionLoader
该方法是一个静态工厂方法，是一个编程api，通过该方法获得一个某个参数制定的扩展类的ExtensionLoader对
象。
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 interface!");
}
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
//先从缓存中获取
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
//存储到缓存
//保证多线程下针对同一个类型 不会出现覆盖
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
//System.out.println("getExtensionLoader-EXTENSION_LOADERS:"+type+"="+new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
这里用到了缓存:存储的结构是如下所示:
从上面的源代码可以分析出来dubbo的spi机制有几个特点:
1. dubbo的SPI扩展点必须是接口。
2. dubbo的SPI扩展点接口必须用注解SPI标注。
3. 某个扩展点的ExtensionLoader是获取的时候延迟生成，并且会进行缓存。
getExtension:根据指定的名称获取扩展实例
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
//获取默认的扩展实例
return getDefaultExtension();
}
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
cachedInstances.putIfAbsent(name, new Holder<Object>());
holder = cachedInstances.get(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;
}
上面代码的大概功能如下:
1. 扩展点名称不能空，否则抛出异常。
2. 扩展点名称传入true则表示获取默认扩展点实例。
3. 扩展点支持缓存，说明扩展点对象在SPI容器中单例的，需要考虑线程安全。
4. 扩展点对象生成时延迟创建的，实现了对jdk的spi的改进。
getDefaultExtension:获取默认的扩展实例
/**
* 返回一个默认的扩展点实现
*/
public T getDefaultExtension() {
getExtensionClasses();
if (null == cachedDefaultName || cachedDefaultName.length() == 0
|| "true".equals(cachedDefaultName)) {
return null;
}
return getExtension(cachedDefaultName);
}
获得默认的扩展对象，属性cachedDefaultName的值并不是参数传递进来的，它是在方法获得扩展类getExtensionClasses()中赋值的。稍后我们一起看看该方法的实现。如果没有加载到默认的扩展点实现，则返回
null。这里的getExtension方法最终会调用createExtension这个方法
createExtension：创建某种对象扩展
private T createExtension(String name) {
//加载所有的扩展类
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);
}
//对象动态注入
injectExtension(instance);
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
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);
}
}
上面方法主要实现了下面的功能:
1. 根据扩展名称获得扩展实现类。先会调用方法getExtensionClasses加载扩展类列表，然后获取指定名称对应
的扩展类。
2. 若找不到扩展类则抛出异常。
3. 从扩展实例缓存中找到该扩展类的实例。若找到则直接返回。
4. 若未找到缓存对象则产生新对象。调用的方法是clazz.newInstance())。
5. 给扩展实例执行依赖注入。调用了方法injectExtension，从而实现了对jdk的spi机制的ioc和aop功能扩展。
getExtesnsionClasses:获取所有扩展类的列表
/**
* 加载所有的扩展点的类 组装成map
* @return
*/
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get();
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
//加载所有扩展类
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
继续看loadExtensionClasses方法;
/**
* 查找配置文件 加载所有的扩展类
* @return
*/
private Map<String, Class<?>> loadExtensionClasses() {
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
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];
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
//真正加载扩展类配置的文件目录
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadFile(extensionClasses, DUBBO_DIRECTORY);
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
其实真正实现加载扩展类的目录是loadFile方法
loadFile：加载dubbo所有的扩展点配置的文件目录
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
ClassLoader classLoader = findClassLoader();
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
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) {
Class<?> clazz = Class.forName(line, true, classLoader);
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Error when load extension class(interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + "is not subtype of interface.");
}
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
} else {
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();
String[] names = NAME_SEPARATOR.split(name);
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);
}
}
上面的代码实现了如下的功能:
1. 先从加载的缓冲中获取扩展点实现类对象。若获取到则直接返回，否则需要加载。
2. 缓存有击穿的风险。即当扩展点无实现类的情况下会每次都进行扩展点记载，该操作是非常耗时的操作，因此
要避免这种情况。
3. 加载扩展点实现类。通过调用方法loadExtensionClasses实现。
4. 扩展点接口上的SPI注解可以指定默认的扩展点名称。而且只能设置一个默认扩展点，不允许多个。这个很好
理解。代码可以看出此时会将SPI注解的value值赋值给属性cachedDefaultName。
5. 扫描classpath下的三个目录加载SPI配置信息。分别类路径下的：METAINF/
services/、METAINF/dubbo/和 METAINF/
dubbo/internal/，加载顺序与该顺序正好相反，METAINF/dubbo/internal/ 最早开始加载。
6. 加载类路径下所有SPI配置文件。文件命名是：目录名+{扩展接口的类名}，比如扩展接口Protocol则文件名
为："METAINF/dubbo/com.alibaba.dubbo.rpc.Protocol"。加载这些配置文件中的内容。
7. 逐行读取配置文件中的内容。
8. 配置文件支持'#'后面的均为注视，可以忽略。
9. 配置文件类似properties文件格式。内容格式是： {name}={className}。其中等号左边是扩展点实现名称，右
边是扩展点实现的全局类名，需要包含在类路径中，否则类加载会抛出异常。可以写多行，每行表示一个实现
类。
10. 找到类名后会使用当前的classloader加载该类。若加载失败则会记录异常。
11. 检查该扩展实现类的合法性。该类必须是扩展接口类的实现类。若不是则会抛出异常。
12. 检查扩展实现类是否为Adaptive标注类。如果是注解Adaptive标注的类（在类上注解，方法注解不算），则会
将改类赋值给cachedAdaptiveClass类，表示该类为一个适配器类，然后退出。
13. 否则尝试获取包含参数为type的构造函数。如果有包含参数为type的构造函数，则说明该实现类是一个包装器
类，会将cachedWrapperClasses的属性设置为该值，然后退出。
14. 否则继续获得无参构造函数。尝试获取无参数构造函数，若无则会抛出异常。
15. 检查扩展类名称。如果没有名称则会尝试自动生成，即若扩展点定义为com.alibaba.dubbo.rpc.Protocol，则扩
展类名必须为com.alibaba.dubbo.rpc.XxxProtocol的才可以生成，自动生成的名称为xxx。即将前缀替换为小
写。否则会抛出异常。
16. 扩展名称支持多个。名称如果是以','隔开，则表示名称是多个，多个名称都会被记录下来，引用相同的扩展实
现类。
17. 如果扩展类有Activate注解，则会将注解实例activate放入集合属性cachedActivates中。
18. 将扩展实现的名称和类分别放入缓存中
getAdaptiveExtension:获得自适应扩展
/**
* 获取自适应扩展
* @return
*/
@SuppressWarnings("unchecked")
public T getAdaptiveExtension() {
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
//创建一个自适应扩展
instance = createAdaptiveExtension();
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);
}
}
return (T) instance;
}
createAdaptiveExtension:创建一个自适应扩展,它会调用
private String createAdaptiveExtensionClassCode() {
StringBuilder codeBuidler = new StringBuilder();
Method[] methods = type.getMethods();
boolean hasAdaptiveAnnotation = false;
for (Method m : methods) {
if (m.isAnnotationPresent(Adaptive.class)) {
hasAdaptiveAnnotation = true;
break;
}
}
// no need to generate adaptive class since there's no adaptive method found.
if (!hasAdaptiveAnnotation)
throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
codeBuidler.append("package " + type.getPackage().getName() + ";");
codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");
codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adaptive" + " implements " + type.getCanonicalName() + " {");
for (Method method : methods) {
Class<?> rt = method.getReturnType();
Class<?>[] pts = method.getParameterTypes();
Class<?>[] ets = method.getExceptionTypes();
Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
StringBuilder code = new StringBuilder(512);
if (adaptiveAnnotation == null) {
code.append("throw new UnsupportedOperationException(\"method ")
.append(method.toString()).append(" of interface ")
.append(type.getName()).append(" is not adaptive method!\");");
} else {
int urlTypeIndex = -1;
for (int i = 0; i < pts.length; ++i) {
if (pts[i].equals(URL.class)) {
urlTypeIndex = i;
break;
}
}
// found parameter in URL type
if (urlTypeIndex != -1) {
// Null Point check
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
urlTypeIndex);
code.append(s);
s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
code.append(s);
}
// did not find parameter in URL type
else {
String attribMethod = null;
// find URL getter method
LBL_PTS:
for (int i = 0; i < pts.length; ++i) {
Method[] ms = pts[i].getMethods();
for (Method m : ms) {
String name = m.getName();
if ((name.startsWith("get") || name.length() > 3)
&& Modifier.isPublic(m.getModifiers())
&& !Modifier.isStatic(m.getModifiers())
&& m.getParameterTypes().length == 0
&& m.getReturnType() == URL.class) {
urlTypeIndex = i;
attribMethod = name;
break LBL_PTS;
}
}
}
if (attribMethod == null) {
throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
+ ": not found url parameter or url attribute in parameters of method " + method.getName());
}
// Null point check
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
urlTypeIndex, pts[urlTypeIndex].getName());
code.append(s);
s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
code.append(s);
s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
code.append(s);
}
String[] value = adaptiveAnnotation.value();
// value is not set, use the value generated from class name as the key
if (value.length == 0) {
char[] charArray = type.getSimpleName().toCharArray();
StringBuilder sb = new StringBuilder(128);
for (int i = 0; i < charArray.length; i++) {
if (Character.isUpperCase(charArray[i])) {
if (i != 0) {
sb.append(".");
}
sb.append(Character.toLowerCase(charArray[i]));
} else {
sb.append(charArray[i]);
}
}
value = new String[]{sb.toString()};
}
boolean hasInvocation = false;
for (int i = 0; i < pts.length; ++i) {
if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
// Null Point check
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
code.append(s);
s = String.format("\nString methodName = arg%d.getMethodName();", i);
code.append(s);
hasInvocation = true;
break;
}
}
String defaultExtName = cachedDefaultName;
String getNameCode = null;
for (int i = value.length - 1; i >= 0; --i) {
if (i == value.length - 1) {
if (null != defaultExtName) {
if (!"protocol".equals(value[i]))
if (hasInvocation)
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
else
getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
} else {
if (!"protocol".equals(value[i]))
if (hasInvocation)
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
else
getNameCode = "url.getProtocol()";
}
} else {
if (!"protocol".equals(value[i]))
if (hasInvocation)
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
else
getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
}
}
code.append("\nString extName = ").append(getNameCode).append(";");
// check extName == null?
String s = String.format("\nif(extName == null) " +
"throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
type.getName(), Arrays.toString(value));
code.append(s);
s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
code.append(s);
// return statement
if (!rt.equals(void.class)) {
code.append("\nreturn ");
}
s = String.format("extension.%s(", method.getName());
code.append(s);
for (int i = 0; i < pts.length; i++) {
if (i != 0)
code.append(", ");
code.append("arg").append(i);
}
code.append(");");
}
codeBuidler.append("\npublic " + rt.getCanonicalName() + " " + method.getName() + "(");
for (int i = 0; i < pts.length; i++) {
if (i > 0) {
codeBuidler.append(", ");
}
codeBuidler.append(pts[i].getCanonicalName());
codeBuidler.append(" ");
codeBuidler.append("arg" + i);
}
codeBuidler.append(")");
if (ets.length > 0) {
codeBuidler.append(" throws ");
for (int i = 0; i < ets.length; i++) {
if (i > 0) {
codeBuidler.append(", ");
}
codeBuidler.append(ets[i].getCanonicalName());
}
}
codeBuidler.append(" {");
codeBuidler.append(code.toString());
codeBuidler.append("\n}");
}
codeBuidler.append("\n}");
if (logger.isDebugEnabled()) {
logger.debug(codeBuidler.toString());
}
return codeBuidler.toString();
}
总结一下核心步骤:
1. 先从缓存中获得扩展点适配实例。如果有则直接获得，否则需要创建。
2. 若有类通过属性cachedAdaptiveClass的类创建。否则需要获取类。
3. 如果获取类失败，则需要调用方法createAdaptiveExtensionClass动态创建适配器类。
4. 如果扩展点类type没有方法被注解Adaptive注释过，则无需创建适配器类，则抛出异常。
5. 动态生成一个适配器实现类。生成的类名是： type.getSimpleName() + "$Adpative"。
6. 生成的类要实现每一个type中包含Adaptive注释过方法。若没有则该方法被抛出不支持的异常。
7. 实现包含Adaptive注释过方法。先通过type参数类型为URL或者getXXX返回值为URL的获得url对象值。并且会
检查url值是否为空，如果为空则会抛出异常。
8. 若方法上的Adaptive注解的value是空，则使用“扩展点接口名的点分隔" 作为Key。
9. 以value作为key，从url对象中获得值，然后将获得的值调用方法getExtension获得扩展点实现对象。这样就实
现了动态注入扩展实现。
getActivateExtension:获取自动激活扩展列表
private List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> exts = new ArrayList<T>();
List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
getExtensionClasses();
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
if (isMatchGroup(group, activate.group())) {
T ext = getExtension(name);
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
if (Constants.DEFAULT_KEY.equals(name)) {
if (usrs.size() > 0) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (usrs.size() > 0) {
exts.addAll(usrs);
}
return exts;
}
大概功能如下:
1. 有多个重载方法可以获得自动激活的扩展实例列表。
2. 如果values（即扩展点名称）列表中不包含默认值“default”
则开始遍历map对象cachedActivates中的所有
activate。
3. 若扩展点被Activate注解标准，则检查activate中的group是否匹配
至此为止相关核心源码就分析完了,在dubbo中有三种注解是和SPI有关的
@SPI:标注当前的接口是一个扩展点
@Adaptive:标注在方法上或者类上
@Activate:标注要激活的扩展点
和ExtensionLoader相关的还有一个对应的工厂接口：
@SPI
public interface ExtensionFactory {
/**
* Get extension.
*
* @param type object type.
* @param name object name.
* @return object instance.
*/
<T> T getExtension(Class<T> type, String name);
}
它有三个实现
daptiveExtensionFactory持有所有ExtensionFactory对象的集合，dubbo内部默认实现的对象工厂是SpiExtensionFactory和SpringExtensionFactory，他们经过TreeMap排好序的查找顺序是优先先从SpiExtensionFactory获取，如果返回空在从SpringExtensionFactory获取。
1） SpiExtensionFactory工厂获取要被注入的对象，就是要获取dubbo spi扩展的实现，所以传入的参数类型必须是接口类型并且接口上打上了@SPI注解，返回的是一个设配类对象。
2）SpringExtensionFactory，Dubbo利用spring的扩展机制跟spring做了很好的融合。在发布或者去引用一个服务的时候，会把spring的容器添加到SpringExtensionFactory工厂集合中去， 当SpiExtensionFactory没有获取到对象的时候会遍历SpringExtensionFactory中的spring容器来获取要注入的对象
接下来以dubbo为实例,简单分析一下是如何使用spi机制的:就以protocol为例:
package com.alibaba.dubbo.rpc; import com.alibaba.dubbo.common.URL; import com.alibaba.dubbo.common.extension.Adaptive; import com.alibaba.dubbo.common.extension.SPI; /** * Protocol. (API/SPI, Singleton, ThreadSafe) */ @SPI("dubbo") public interface Protocol { /** * 获取缺省端口 * @return */ int getDefaultPort(); /** * 暴露远程服务 * @param invoker * @param <T> * @return * @throws RpcException */ @Adaptive <T> Exporter<T> export(Invoker<T> invoker) throws RpcException; /** * 引用远程服务 * @param type * @param url * @param <T> * @return * @throws RpcException */ @Adaptive <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException; /** * 释放协议 */ void destroy(); }
这里的Exporter和Invoker都是接口且它们自身都不再标准@SPI注解:,然后看一下这个Protocol生成的适配代码:
public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
public void destroy() {
throw new UnsupportedOperationException(
"method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of
interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}
public int getDefaultPort() {
throw new UnsupportedOperationException(
"method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of
interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}
public com.alibaba.dubbo.rpc.Exporter export(
com.alibaba.dubbo.rpc.Invoker arg0)
throws com.alibaba.dubbo.rpc.RpcException {
if (arg0 == null)
throw new IllegalArgumentException(
"com.alibaba.dubbo.rpc.Invoker argument == null");
if (arg0.getUrl() == null)
throw new IllegalArgumentException(
"com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
com.alibaba.dubbo.common.URL url = arg0.getUrl();
String extName = (url.getProtocol() == null ? "dubbo" : url
.getProtocol());
if (extName == null)
throw new IllegalStateException(
"Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url("
+ url.toString() + ") use keys([protocol])");
com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)
ExtensionLoader
.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class)
.getExtension(extName);
return extension.export(arg0);
}
public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0,
com.alibaba.dubbo.common.URL arg1)
throws com.alibaba.dubbo.rpc.RpcException {
if (arg1 == null)
throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg1;
String extName = (url.getProtocol() == null ? "dubbo" : url
.getProtocol());
if (extName == null)
throw new IllegalStateException(
"Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url("
+ url.toString() + ") use keys([protocol])");
com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)
1. 只会代理扩展点接口上有@Adaptive标注的方法。没有标注的方法调用会抛出不支持该方法的异常。
2. 从类型为url的参数或者参数的url属性中获得url对象，从url中获得value作为扩展点的名称。
3. 从扩展点加载器中获得对应名称的扩展点。
4. 再调用扩展点的方法。
dubbo中的protocol协议有很多种实现
具体选择的是哪一种,这个时候adaptive会根据url里面的参数进行扩展点的获取,然后再获取扩展点里面的方法.