一、扩展点分析之ExtensionLoader
Dubbo的扩展点框架主要位于com.alibaba.dubbo.common.extension这个包下,其结构如下:
com.alibaba.dubbo.common.extension
|
|--factory
| |--AdaptiveExtensionFactory
| |--SpiExtensionFactory
|
|--support
| |--ActivateComparator
|
|--Activate #自动激活加载扩展的注解
|--Adaptive #自适应扩展点的注解
|--ExtensionFactory #扩展点对象生成工厂接口
|--ExtensionLoader #扩展点加载器,扩展点的查找,校验,加载等核心逻辑的实现类
|--SPI #扩展点注解
Dubbo的扩展点主要基于ExtensionLoader这个单例类进行加载,在进行相关扩展时需注意扩展实现的线程安全性),其具有以下特性:
(1)扩展点自动包装(Wrapper)
(2)扩展点自动装配
(3)扩展点自适应(Adaptive)
(4)扩展点自动激活(Active)
1、扩展点缓存
相关参数缓存在对应的数据结构中,先列出如下,方便后面看源代码时查阅:
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>(); private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String,Class<?>>>(); private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>(); private volatile Class<?> cachedAdaptiveClass = null; private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>(); private String cachedDefaultName; private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>(); private Set<Class<?>> cachedWrapperClasses;
(1)cachedAdaptiveClass : 当前Extension类型对应的AdaptiveExtension类型(只能一个)
(2)cachedWrapperClasses : 当前Extension类型对应的所有Wrapper实现类型(无顺序)
(3)cachedActivates : 当前Extension实现自动激活实现缓存(map,无序)
(4)cachedNames : 扩展点实现类对应的名称(如配置多个名称则值为第一个)
当loadExtensionClasses方法执行完成之后,还有一下变量被赋值:
(5)cachedDefaultName : 当前扩展点的默认实现名称
当getExtensionClasses方法执行完成之后,除了上述变量被赋值之外,还有以下变量被赋值:
(6)cachedClasses : 扩展点实现名称对应的实现类(一个实现类可能有多个名称)
其实也就是说,在调用了getExtensionClasses方法之后,当前扩展点对应的实现类的一些信息就已经加载进来了并且被缓存了。后面的许多操作都可以直接通过这些缓存数据来进行处理了。
2、ExtensionLoader实例方法
ExtensionLoader
没有提供public
的构造方法,但是提供了一个public static
的getExtensionLoader
,这个方法就是获取ExtensionLoader
实例的工厂方法。其public
成员方法中有三个比较重要的方法:
- getActivateExtension :根据条件获取当前扩展可自动激活的实现
- getExtension : 根据名称获取当前扩展的指定实现
- getAdaptiveExtension : 获取当前扩展的自适应实现
每一个ExtensionLoader
实例仅负责加载特定SPI
扩展的实现*。因此想要获取某个扩展的实现,首先要获取到该扩展对应的ExtensionLoader
实例,下面我们就来看一下获取ExtensionLoader
实例的工厂方法getExtensionLoader
:
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)) { // 只接受使用@SPI注解注释的接口类型
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
// 先从静态缓存中获取对应的ExtensionLoader实例
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type)); // 为Extension类型创建ExtensionLoader实例,并放入静态缓存
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
该方法需要一个Class
类型的参数,该参数表示希望加载的扩展点类型,该参数必须是接口,且该接口必须被@SPI
注解注释,否则拒绝处理。检查通过之后首先会检查ExtensionLoader缓存中是否已经存在该扩展对应的ExtensionLoader
,如果有则直接返回,否则创建一个新的ExtensionLoader
负责加载该扩展实现,同时将其缓存起来。可以看到对于每一个扩展,dubbo中只会有一个对应的ExtensionLoader
实例。
接下来看下ExtensionLoader
的私有构造函数:
private ExtensionLoader(Class<?> type) {
this.type = type;
// 如果扩展类型是ExtensionFactory,那么则设置为null
// 这里通过getAdaptiveExtension方法获取一个运行时自适应的扩展类型(每个Extension只能有一个@Adaptive类型的实现,如果没有dubbo会动态生成一个类)
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
这里保存了对应的扩展类型,并且设置了一个额外的objectFactory
属性,他是一个ExtensionFactory
类型,ExtensionFactory
主要用于加载扩展的实现:
@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);
}
同时ExtensionFactory
也被@SPI
注解注释,说明他也是一个扩展点,从前面com.alibaba.dubbo.common.extension
包的结构图中可以看到,dubbo内部提供了两个实现类:SpiExtensionFactory
和 AdaptiveExtensionFactory
,实际上还有一个SpringExtensionFactory
,不同的实现可以已不同的方式来完成扩展点实现的加载,这块稍后再来学习。从ExtensionLoader
的构造函数中可以看到,如果要加载的扩展点类型是ExtensionFactory
是,object
字段被设置为null。由于ExtensionLoader
的使用范围有限(基本上局限在ExtensionLoader
中),因此对他做了特殊对待:在需要使用ExtensionFactory
的地方,都是通过对应的自适应实现来代替。
默认的ExtensionFactory
实现中,AdaptiveExtensionFactotry
被@Adaptive
注解注释,也就是它就是ExtensionFactory
对应的自适应扩展实现(每个扩展点最多只能有一个自适应实现,如果所有实现中没有被@Adaptive
注释的,那么dubbo会动态生成一个自适应实现类),也就是说,所有对ExtensionFactory
调用的地方,实际上调用的都是AdpativeExtensionFactory
,那么我们看下他的实现代码:
@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()) { // 将所有ExtensionFactory实现保存起来
list.add(loader.getExtension(name));
}
factories = Collections.unmodifiableList(list);
}
public <T> T getExtension(Class<T> type, String name) {
// 依次遍历各个ExtensionFactory实现的getExtension方法,一旦获取到Extension即返回
// 如果遍历完所有的ExtensionFactory实现均无法找到Extension,则返回null
for (ExtensionFactory factory : factories) {
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
综上可以看到,他会遍历当前系统中所有的ExtensionFactory
实现来获取指定的扩展实现,获取到扩展实现或遍历完所有的ExtensionFactory
实现。这里调用了ExtensionLoader
的getSupportedExtensions
方法来获取ExtensionFactory
的所有实现,又回到了ExtensionLoader
类。
3、ExtensionLoader实例方法具体流程分析
(1)、getExtension
getExtension(name)
-> createExtension(name) #如果无缓存则创建
-> getExtensionClasses().get(name) #获取name对应的扩展类型
-> 实例化扩展类
-> injectExtension(instance) # 扩展点注入
-> instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)) #循环遍历所有wrapper实现,实例化wrapper并进行扩展点注入
(2)、getAdaptiveExtension
public T getAdaptiveExtension()
-> createAdaptiveExtension() #如果无缓存则创建
-> getAdaptiveExtensionClass().newInstance() #获取AdaptiveExtensionClass
-> getExtensionClasses() # 加载当前扩展所有实现,看是否有实现被标注为@Adaptive
-> createAdaptiveExtensionClass() #如果没有实现被标注为@Adaptive,则动态创建一个Adaptive实现类
-> createAdaptiveExtensionClassCode() #动态生成实现类java代码
-> compiler.compile(code, classLoader) #动态编译java代码,加载类并实例化
-> injectExtension(instance)
(3)、getActivateExtension
该方法有多个重载方法,不过最终都是调用了三个参数的那一个重载形式。其代码结构也相对剪短,就不需要在列出概要流程了。
4、详细代码分析
(1)、getAdaptiveExtension
从前面ExtensionLoader
的私有构造函数中可以看出,在选择ExtensionFactory
的时候,并不是调用getExtension(name)
来获取某个具体的实现类,而是调用getAdaptiveExtension
来获取一个自适应的实现。那么首先我们就来分析一下getAdaptiveExtension
这个方法的实现吧:
public T getAdaptiveExtension() {
Object instance = cachedAdaptiveInstance.get(); // 首先判断是否已经有缓存的实例对象
if (instance == null) {
if(createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
instance = createAdaptiveExtension(); // 没有缓存的实例,创建新的AdaptiveExtension实例
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;
}
首先检查缓存的adaptiveInstance是否存在,如果存在则直接使用,否则的话调用createAdaptiveExtension
方法来创建新的adaptiveInstance并且缓存起来。也就是说对于某个扩展点,每次调用ExtensionLoader.getAdaptiveExtension
获取到的都是同一个实例。
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance()); // 先获取AdaptiveExtensionClass,在获取其实例,最后进行注入处理
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
}
}
在createAdaptiveExtension
方法中,首先通过getAdaptiveExtensionClass
方法获取到最终的自适应实现类型,然后实例化一个自适应扩展实现的实例,最后进行扩展点注入操作。先看一个getAdaptiveExtensionClass
方法的实现:
private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses(); // 加载当前Extension的所有实现,如果有@Adaptive类型,则会赋值为cachedAdaptiveClass属性缓存起来
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass(); // 没有找到@Adaptive类型实现,则动态创建一个AdaptiveExtensionClass
}
他只是简单的调用了getExtensionClasses
方法,然后在判adaptiveCalss缓存是否被设置,如果被设置那么直接返回,否则调用createAdaptiveExntesionClass
方法动态生成一个自适应实现,关于动态生成自适应实现类然后编译加载并且实例化的过程这里暂时不分析,留到后面在分析吧。这里我们看getExtensionClassses
方法:
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get(); // 判断是否已经加载了当前Extension的所有实现类
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses(); // 如果还没有加载Extension的实现,则进行扫描加载,完成后赋值给cachedClasses变量
cachedClasses.set(classes);
}
}
}
return classes;
}
在getExtensionClasses
方法中,首先检查缓存的cachedClasses,如果没有再调用loadExtensionClasses
方法来加载,加载完成之后就会进行缓存。也就是说对于每个扩展点,其实现的加载只会执行一次。loadExtensionClasses
方法在上文已经介绍过,就是读取对应的配置文件,并将相关配置进行缓存。在此不再赘述。
(2)、injectExtension
创建自适应扩展点实现类型和实例化就已经完成了,下面就来看下扩展点自动注入的实现:
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {// 处理所有set方法
Class<?> pt = method.getParameterTypes()[0];// 获取set方法参数类型
try {
// 获取setter对应的property名称
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
Object object = objectFactory.getExtension(pt, property); // 根据类型,名称信息从ExtensionFactory获取
if (object != null) { // 如果不为空,说set方法的参数是扩展点类型,那么进行注入
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;
}
这里可以看到,扩展点自动注入的一句就是根据setter方法对应的参数类型和property名称从ExtensionFactory
中查询,如果有返回扩展点实例,那么就进行注入操作。到这里getAdaptiveExtension
方法就分析完毕了。
(3)getExtension
这个方法的主要作用是用来获取ExtensionLoader
实例代表的扩展的指定实现。已扩展实现的名字作为参数,结合前面学习getAdaptiveExtension
的代码,我们可以推测,这方法中也使用了在调用getExtensionClasses
方法的时候收集并缓存的数据,其中涉及到名字和具体实现类型对应关系的缓存属性是cachedClasses
。具体是是否如我们猜想的那样呢,学习一下相关代码就知道了:
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;
}
接着看createExtension
方法的实现:
private T createExtension(String name) {
Class<?> clazz = getExtensionClasses().get(name); // getExtensionClass内部使用cachedClasses缓存
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz); // 从已创建Extension实例缓存中获取
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
injectExtension(instance); // 属性注入
// Wrapper类型进行包装,层层包裹
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);
}
}
从代码中可以看到,内部调用了getExtensionClasses
方法来获取当前扩展的所有实现,而getExtensionClassse
方法会在第一次被调用的时候将结果缓存到cachedClasses
变量中,后面的调用就直接从缓存变量中获取了。这里还可以看到一个缓存EXTENSION_INSTANCES
,这个缓存是ExtensionLoader
的静态成员,也就是全局缓存,存放着所有的扩展点实现类型与其对应的已经实例化的实例对象(是所有扩展点,不是某一个扩展点),也就是说所有的扩展点实现在dubbo中最多都只会有一个实例。
拿到扩展点实现类型对应的实例之后,调用了injectExtension
方法对该实例进行扩展点注入,紧接着就是遍历该扩展点接口的所有Wrapper来对真正的扩展点实例进行Wrap操作,都是对通过将上一次的结果作为下一个Wrapper的构造函数参数传递进去实例化一个Wrapper对象,最后总返回回去的是Wrapper类型的实例而不是具体实现类的实例。
这里或许有一个疑问: 从代码中看,不论instance
是否存在于EXTENSION_INSTANCE
,都会进行扩展点注入和Wrap操作。那么如果对于同一个扩展点,调用了两次createExtension
方法的话,那不就进行了两次Wrap操作么?
如果外部能够直接调用createExtension
方法,那么确实可能出现这个问题。但是由于createExtension
方法是private
的,因此外部无法直接调用。而在ExtensionLoader
类中调用它的getExtension
方法(只有它这一处调用),内部自己做了缓存(cachedInstances
),因此当getExtension
方法内部调用了一次createExtension
方法之后,后面对getExtension
方法执行同样的调用时,会直接使用cachedInstances
缓存而不会再去调用createExtension
方法了。
(4)、getActivateExtension
getActivateExtension
方法主要获取当前扩展的所有可自动激活的实现。可根据入参(values)调整指定实现的顺序,在这个方法里面也使用到getExtensionClasses
方法中收集的缓存数据。
public 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); // 解析配置要使用的名称
// 如果未配置"-default",则加载所有Activates扩展(names指定的扩展)
if (! names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
getExtensionClasses(); // 加载当前Extension所有实现,会获取到当前Extension中所有@Active实现,赋值给cachedActivates变量
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) { // 遍历当前扩展所有的@Activate扩展
String name = entry.getKey();
Activate activate = entry.getValue();
if (isMatchGroup(group, activate.group())) { // 判断group是否满足,group为null则直接返回true
T ext = getExtension(name); // 获取扩展示例
// 排除names指定的扩展;并且如果names中没有指定移除该扩展(-name),且当前url匹配结果显示可激活才进行使用
if (! names.contains(name)
&& ! names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
Collections.sort(exts, ActivateComparator.COMPARATOR); // 默认排序
}
// 对names指定的扩展进行专门的处理
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i ++) { // 遍历names指定的扩展名
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)) { // default表示上面已经加载并且排序的exts,将排在default之前的Activate扩展放置到default组之前,例如:ext1,default,ext2
if (usrs.size() > 0) { // 如果此时user不为空,则user中存放的是配置在default之前的Activate扩展
exts.addAll(0, usrs); // 注意index是0,放在default前面
usrs.clear(); // 放到default之前,然后清空
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (usrs.size() > 0) { // 这里留下的都是配置在default之后的
exts.addAll(usrs); // 添加到default排序之后
}
return exts;
}
二、AdaptiveExtension动态生成及@Adaptive
Adaptive:因为dubbo底层会大量使用反射,出于性能考虑默认使用javassist字节码编译生成一个adaptive,由它动态委派处理。用户可以自己实现一个adaptive,只需要对某个类打上@adaptive即可。对于默认编译生成Adaptive的方案,需要使用@Adaptive声明接口上的哪些方法是adaptive方法。扩展点名称的key默认是接口类型上@SPI#value,方法上的@Adaptive#value有更高优先级。
官方文档描述动态生成的AdaptiveExtension
代码如下:
package <扩展点接口所在包>;
public class <扩展点接口名>$Adpative implements <扩展点接口> {
public <有@Adaptive注解的接口方法>(<方法参数>) {
if(是否有URL类型方法参数?) 使用该URL参数
else if(是否有方法类型上有URL属性) 使用该URL属性
# <else 在加载扩展点生成自适应扩展点类时抛异常,即加载扩展点失败!>
if(获取的URL == null) {
throw new IllegalArgumentException("url == null");
}
根据@Adaptive注解上声明的Key的顺序,从URL获致Value,作为实际扩展点名。
如URL没有Value,则使用缺省扩展点实现。如没有扩展点, throw new IllegalStateException("Fail to get extension");
在扩展点实现调用该方法,并返回结果。
}
public <有@Adaptive注解的接口方法>(<方法参数>) {
throw new UnsupportedOperationException("is not adaptive method!");
}
}
规则如下:
- 先在URL上找
@Adaptive
注解指定的Extension名; - 如果不设置则缺省使用Extension接口类名的点分隔小写字串(即对于Extension接口com.alibaba.dubbo.xxx.YyyInvokerWrapper的缺省值为String[] {“yyy.invoker.wrapper”})。
- 使用默认实现(@SPI指定),如果没有设定缺省扩展,则方法调用会抛出IllegalStateException。
动态注入的代码如下:
private T injectExtension(T instance) { try { if (objectFactory != null) { 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 { 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) { 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; }
从上面可以看到,进行注入的条件如下:
- set开头的方法
- 方法的参数只有一个
- 方法必须是public
我们知道一个接口的实现者可能有多个,此时到底注入哪一个呢?
@Adaptive 的 dubbo spi 扩展机制,它获取设配类不在通过前面过程生成设配类 java 源代码, 而是在读取扩展文件的时候遇到实现类打了注解@Adaptive 就把这个类作为设配类缓存在 ExtensionLoader 中,调用是直接返回。使用时首先通过ExtensionLoader生成了XXX(例如Protocol)的Adaptive,以在运行期通过动态决策委托实体对象处理。此时采取的策略是,并不去注入一个具体的实现者,而是注入一个动态生成的实现者,这个动态生成的实现者的逻辑是确定的,能够根据不同的参数来使用不同的实现者实现相应的方法。这个动态生成的实现者的class就是ExtensionLoader的Class<?> cachedAdaptiveClass
方法的参数必须是接口,并且是ExtensionLoader能够获取其扩展类。
继续看实现:
@SuppressWarnings("unchecked") private T createAdaptiveExtension() { try { return injectExtension((T) getAdaptiveExtensionClass().newInstance()); } catch (Exception e) { throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e); } }
会调用:
private Class<?> getAdaptiveExtensionClass() { getExtensionClasses(); if (cachedAdaptiveClass != null) { return cachedAdaptiveClass; } return cachedAdaptiveClass = createAdaptiveExtensionClass(); }
继续调用:
private Class<?> createAdaptiveExtensionClass() { String code = createAdaptiveExtensionClassCode(); ClassLoader classLoader = findClassLoader(); com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension(); return compiler.compile(code, classLoader); }
继续:
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; } } // 完全没有Adaptive方法,则不需要生成Adaptive类 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() + "$Adpative" + " 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; } } // 有类型为URL的参数 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); } // 参数没有URL类型 else { String attribMethod = null; // 找到参数的URL属性 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 adative 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(); // 没有设置Key,则使用“扩展点接口名的点分隔 作为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(); }
以Protocol为例,动态生成一个类:
package com.jason.dubbo; import com.alibaba.dubbo.common.extension.ExtensionLoader; 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.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) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName); return extension.refer(arg0, arg1); } 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); } }
从上面的代码中可以看到,Protocol$Adpative是根据URL参数中protocol属性的值来选择具体的实现类的。
如值为dubbo,则从ExtensionLoader<Protocol>中获取dubbo对应的实例,即DubboProtocol实例
如值为hessian,则从ExtensionLoader<Protocol>中获取hessian对应的实例,即HessianProtocol实例
也就是说Protocol$Adpative能够根据url中的protocol属性值动态的采用对应的实现。
对于上述获取动态实现者即Protocol$Adpative的过程还需要补充一些细节内容:
1 要求对应的接口中的某些方法必须含有Adaptive注解,没有Adaptive注解,则表示不需要生成动态类
2 对于接口的方法中不含Adaptive注解的,全部是不可调用的,如上述的destroy()方法
3 含有Adaptive注解的方法必须含有URL类型的参数,或者能够获取到URL,分别如上述的refer方法和export方法
4 从URL中根据什么参数来获取实现者信息呢?以Protocol为例,参数就为"protocol",默认是接口简单名称首字母小写或者接口中指定的默认实现,
三、Wrapper
包装类必须有一个参数为spi接口类型的构造函数,否则不能正常工作。判断warpper的标准是class有没有一个参数为接口类型的构造参数。Wrapper可以有多个,会被按顺序依次覆盖,假设spi定义如下:
A=a.b.c
B=a.b.wrapper1
C=a.b.wrapper2
wrapper的最终结构则为B-C-A
总结
基本上将dubbo的扩展点加载机制学习了一遍,有几点可能需要注意的地方:
- 每个
ExtensionLoader
实例只负责加载一个特定扩展点实现 - 每个扩展点对应最多只有一个
ExtensionLoader
实例 - 对于每个扩展点实现,最多只会有一个实例
- 一个扩展点实现可以对应多个名称(逗号分隔)
- 对于需要等到运行时才能决定使用哪一个具体实现的扩展点,应获取其自使用扩展点实现(AdaptiveExtension)
@Adaptive
注解要么注释在扩展点@SPI
的方法上,要么注释在其实现类的类定义上- 如果
@Adaptive
注解注释在@SPI
接口的方法上,那么原则上该接口所有方法都应该加@Adaptive
注解(自动生成的实现中默认为注解的方法抛异常) - 每个扩展点最多只能有一个被AdaptiveExtension
- 每个扩展点可以有多个可自动激活的扩展点实现(使用
@Activate
注解) - 由于每个扩展点实现最多只有一个实例,因此扩展点实现应保证线程安全
- 如果扩展点有多个Wrapper,那么最终其执行的顺序不确定(内部使用
ConcurrentHashSet
存储)
参考文献:
1、参考:http://blog.csdn.net/jdluojing/article/details/44947221
http://www.tuicool.com/articles/FR7NnyQ Dubbo源码学习之ExtentionLoader
http://blog.csdn.net/jdluojing/article/details/44947221