在上篇文章中我们提到了创建适配器类的过程
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
(T) getAdaptiveExtensionClass().newInstance() 是获取适配器类，然后利用反射进行实例化。他的最外层injectExtension方法，所做的就是Dubbo的IOC,将扩展中的属性进行赋值。接下来我们看一下他的实现
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
/**
* 寻找实例中的所有的方法
*/
for (Method method : instance.getClass().getMethods()) {
/**
* 将属性的set方法找出来
*/
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
/**
* set方法一个参数，所以找到第一个参数
*
* 例如： public void setPeople(People p){
* this.p=p
* }
*/
Class<?> pt = method.getParameterTypes()[0];
try {
/**
* 获取属性名称 ：people
*/
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) {
/**
* 利用反射添加进实例中，完成ioc
*/
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方法，根据方法命名获取到需要从容器内搜索的对象的名称，如果能搜索到，就利用反射进行注入。逻辑很清晰，唯一的疑惑点就是，根据名称和类型搜索相应的对象的逻辑，也就是Object object = objectFactory.getExtension(pt, property);首先我们得知道objectFactory是怎么来的。我们在根据type创建ExtensionLoader时，进行的创建，我们再回顾下
private ExtensionLoader(Class<?> type) {
this.type = type;
/**
* type如果是ExtensionFactory类型，那么objectFactory是null,否则是ExtensionFactory类型的适配器类型
*/
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
我们要寻找ExtensionFactory的扩展，发现他的扩展中有个类AdaptiveExtensionFactory上面有@Adaptive的注解，那么最后就是它作为扩展类，也就是objectFactory的实例对象。所以当调用objectFactory.getExtension时其实就是这段代码
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;
}
factories是一个变量，他的填充处就是AdaptiveExtensionFactory的构造方法
public AdaptiveExtensionFactory() {
/**
* 找到ExtensionFactory的ExtensionLoader
*/
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
for (String name : loader.getSupportedExtensions()) {
/**
* 根据name获取具体的扩展，放到list中
*/
list.add(loader.getExtension(name));
}
/**
* 赋值给factories
*/
factories = Collections.unmodifiableList(list);
}
获取ExtensionFactory类型的扩展，出了ExtensionFactory有两个，一个是SpiExtensionFactory，另外一个是SpringExtensionFactory。我们看下他再SPI文件中的声明
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
所以使用的是spi的扩展会起作用，使用的就是SpiExtensionFactory来搜索具体的对象用来依赖注入。下面我们看下SpiExtensionFactory是怎么搜索的。
public class SpiExtensionFactory implements ExtensionFactory {
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
if (!loader.getSupportedExtensions().isEmpty()) {
return loader.getAdaptiveExtension();
}
}
return null;
}
}
判断传入的类型是否加上了@SPI的注解并且是否是个接口，如果是的话，获取此类型的Adaptive扩展。
大家对这个流程是否通畅了呢？
预告，看这里
下一篇: Dubbo 服务暴露详解
END
