1.抛出问题
dubbo的设计思路是微内核+插件，Filter等插件被dubbo创建，而不是被spring创建。
Filter和spring两不相认，如果想在Filter中使用被spring管理的对象，注入spring的bean，怎么办？
2.先给出结论
在Filter中新建一个setter方法。此方法名称形如setAbc，有且仅有一个参数。
在spring上下文中定义一个名为“abc”的bean，类型要对。
如此即可实现，在Fliter被实例化后，此setter被调用，传入名为“abc”的bean（一定要类型正确，名字对上更好，详细算法见3.2节结尾处）。
（4.章介绍另一种机制，spring利用instrumentation，load-time-weaver令非spring管理的对象也能使用spring基础设施，开阔思路，不建议用）
3.源码分析
这部分尽可能从现象到原因探索。
- 插件实例化后可被调
setter，参数从objectFactory中来 -
objectFactory是ExtensionFactory接口类型的，SpringExtensionFactory是此接口的一个实现类 -
SpringExtensionFactory在使用dubbo-spring时被设置好
3.1.插件实例化后可被调setter，参数从objectFactory中来
Filter中的setter可被dubbo调起，在spring的ApplicationContext中按名字查找并塞进一个bean。
Filter等插件被按SPI机制管理，com.alibaba.dubbo.common.extension.ExtensionLoader<T>的public T getExtension(String name)函数被用于加载特定的插件，其中有一层缓存，真正的创建过程在private T createExtension(String name)函数中。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, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
injectExtension(instance);
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);
}
}
可见其中的主要步骤：
- 调用
Class的newInstance()方法，实例化插件 - 调用
ExtensionLoader<T>的injectExtension(T instance)，从objectFactory中拿一个bean，调用插件的setter方法 - 处理一下
wrapper
再看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())) {
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;
}
可见其中的主要步骤：
- 遍历方法
- 如果是
setter（即，方法名以“set”开头，有1个参数，是public） - 得到属性名，从
objectFactory中得到bean - 调用
setter
3.2.objectFactory是ExtensionFactory接口类型的，SpringExtensionFactory是此接口的一个实现类
属性private final ExtensionFactory objectFactory在私有构造函数中被初始化：
private ExtensionLoader(Class<?> type) {
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
接口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);
}
按照dubbo的SPI机制的惯例，见META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory内容：
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
关注“spring”名称对应的SpringExtensionFactory，其源码片段：
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;
}
}
}
logger.warn("No spring extension(bean) named:" + name + ", try to find an extension(bean) of type " + type.getName());
for (ApplicationContext context : contexts) {
try {
return context.getBean(type);
} catch (NoUniqueBeanDefinitionException multiBeanExe) {
throw multiBeanExe;
} catch (NoSuchBeanDefinitionException noBeanExe) {
if (logger.isDebugEnabled()) {
logger.debug("Error when get spring extension(bean) for type:" + type.getName(), noBeanExe);
}
}
}
logger.warn("No spring extension(bean) named:" + name + ", type:" + type.getName() + " found, stop get bean.");
return null;
}
可见其中查找逻辑：
- 遍历
ApplicationContext - 先按名字找bean，要求类型必须正确
- 如果上一步找不到，就不考虑此名字了。改为仅按类型找，要求比类型bean必须是唯一的
3.3.SpringExtensionFactory在使用dubbo-spring时被设置好
查找SpringExtensionFactory在哪里被调用，仅ReferenceBean和ServiceBean，这两个类是使用dubbo-spring一定绕不开的。
涉及SpringExtensionFactory的逻辑相似，ReferenceBean和ServiceBean均实现了ApplicationContextAware，回调方法中有
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
SpringExtensionFactory.addApplicationContext(applicationContext);
}
（ServiceBean的此方法中多了增加监听器的功能）
可见其中调用了SpringExtensionFactory的静态方法public static void addApplicationContext(ApplicationContext context)
4.另一种做法
核心思路是利用instrumentation和load-time-weaver。
启动时加入-javaagent参数，在自定义Filter上加@Configurable注解。
不建议的理由主要是需要修改启动脚本。
