前言
良好的扩展性对于一个框架而言尤其重要，框架顾名思义就是搭好核心架子，给予用户简单便捷的使用，同时也需要满足他们定制化的需求。
Dubbo 就依靠 SPI 机制实现了插件化功能，几乎将所有的功能组件做成基于 SPI 实现，并且默认提供了很多可以直接使用的扩展点，实现了面向功能进行拆分的对扩展开放的架构。
其实就是在系统启动的时候，根据你的一些配置信息，动态地识别你的实现是谁，然后把实现搞出来，注入给接口类型的变量；
什么是 SPI
首先我们得先知道什么叫 SPI。
SPI (Service Provider Interface)，主要是用来在框架中使用的，最常见和莫过于我们在访问数据库时候用到的java.sql.Driver接口了。
你想一下首先市面上的数据库五花八门，不同的数据库底层协议的大不相同，所以首先需要定制一个接口，来约束一下这些数据库，使得 Java 语言的使用者在调用数据库的时候可以方便、统一的面向接口编程。
数据库厂商们需要根据接口来开发他们对应的实现，那么问题来了，真正使用的时候到底用哪个实现呢？从哪里找到实现类呢？
这时候 Java SPI 机制就派上用场了，不知道到底用哪个实现类和找不到实现类，我们告诉它不就完事了呗。
大家都约定好将实现类的配置写在一个地方，然后到时候都去哪个地方查一下不就知道了吗？
Java SPI 就是这样做的，约定在 Classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，然后文件里面记录的是此 jar 包提供的具体实现类的全限定名。
这样当我们引用了某个 jar 包的时候就可以去找这个 jar 包的 META-INF/services/ 目录，再根据接口名找到文件，然后读取文件里面的内容去进行实现类的加载与实例化。
比如我们看下 MySQL 是怎么做的。
再来看一下文件里面的内容。
伪代码
ServiceLoader<接口> serviceLoaders = ServiceLoader.load(接口.class);
for(接口 变量 : serviceLoaders) {
变量.xx
} SPI机制，有什么用处？
dubbo框架，他有很多很多的组件，Protocol、LoadBalance、Invoke、Exchange，他的实现类，为了你留出充足的扩展空间，全面采用了SPI机制的思想；
关键组件在代码里全部没有写死实现类，所有关键组件的实现类，都是在代码运行的时候，动态地去查找以及实例化出来的；
我们几乎可以对dubbo的各种组件都进行定制，基于dubbo SPI的机制，做一些配置，就可以替换掉dubbo默认的自己的组件；
为什么Dubbo要自己实现一套SPI机制
Java SPI，你配置的那些实现类，不管用没用到，都会给你一下子拿出来；假设一个实现类初始化过程比较消耗资源且耗时，但是你的代码里面又用不上它，这就产生了资源的浪费。
Dubbo SPI，主要是根据你的需要去拿实现类，缓存机制，dubbo SPI机制里，还提供了IOC和AOP等功能；
Dubbo SPI机制有已下几个特点
自动包装：加载某个扩展点实现时，如果发现存在参数为扩展点的构造函数，那么这个扩展点实现就是Wrapper类。
自动加载：如果扩展实现类的成员属性也是一个扩展点，那么ExtensionLoader会加载并注入这个依赖的扩展点。这是Dubbo SPI的IOC特性，依赖扩展点通过setter方法进行注入。
自动适应：在注入一个扩展点时，当一个扩展点有多个实现类，在程序运行前可能我们并不知道要加载哪个实现类。自适应扩展则支持在运行时根据URL参数动态加载实现。Dubbo提供@Adaptive注解来实现自适应。@Adaptive如果作用于类上，那么标明该类是一个自适应扩展类。作用于方法上，则会运行时生成一个代理类来进行转发，由代理类根据URL中的传参去加载真正的实现。
自动激活：对于集合类扩展点，比如Filter、xxxListener，可以同时加载多个实现。此时可以使用自动激活来实现。
SPI机制有几个重要的注解：
1、@SPI注解，被此注解标记的接口，就表示是一个可扩展的接口，并标注默认值。
2、@Adaptive注解，有两种注解方式：一种是注解在类上，一种是注解在方法上。
3、@Activate注解，此注解需要注解在类上或者方法上，并注明被激活的条件，以及所有的被激活实现类中的排序信息
源码分析
/**
* dubbo SPI机制的核心类
* @param <T>
*/
public class ExtensionLoader<T> {
private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
/** 实现类->对象 缓存，注：实现类只是一个java类，而对象是根据java类生成出来的 */
private final ConcurrentMap<Class<?>, Object> extensionInstances = new ConcurrentHashMap<>(64);
private final Class<?> type;
private final ExtensionInjector injector;
/** 缓存名称 */
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<>();
/** 缓存类信息 */
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();
private final Map<String, Object> cachedActivates = Collections.synchronizedMap(new LinkedHashMap<>());
private final Map<String, Set<String>> cachedActivateGroups = Collections.synchronizedMap(new LinkedHashMap<>());
private final Map<String, String[][]> cachedActivateValues = Collections.synchronizedMap(new LinkedHashMap<>());
/** 实例集合的缓存map */
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();
/** 缓存的一些Adaptive的东西 */
private final Holder<Object> cachedAdaptiveInstance = new Holder<>();
private volatile Class<?> cachedAdaptiveClass = null;
private String cachedDefaultName;
private volatile Throwable createAdaptiveInstanceError;
private Set<Class<?>> cachedWrapperClasses;
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<>();
private static volatile LoadingStrategy[] strategies = loadLoadingStrategies();
/**
* Record all unacceptable exceptions when using SPI
*/
private Set<String> unacceptableExceptions = new ConcurrentHashSet<>();
private ExtensionDirector extensionDirector;
private List<ExtensionPostProcessor> extensionPostProcessors;
private InstantiationStrategy instantiationStrategy;
private Environment environment;
private ActivateComparator activateComparator;
private ScopeModel scopeModel;
private AtomicBoolean destroyed = new AtomicBoolean();
public static void setLoadingStrategies(LoadingStrategy... strategies) {
if (ArrayUtils.isNotEmpty(strategies)) {
ExtensionLoader.strategies = strategies;
}
}
/**
* Load all {@link Prioritized prioritized} {@link LoadingStrategy Loading Strategies} via {@link ServiceLoader}
*
* @return non-null
* @since 2.7.7
*/
private static LoadingStrategy[] loadLoadingStrategies() {
return stream(load(LoadingStrategy.class).spliterator(), false)
.sorted()
.toArray(LoadingStrategy[]::new);
}
/**
* Get all {@link LoadingStrategy Loading Strategies}
*
* @return non-null
* @see LoadingStrategy
* @see Prioritized
* @since 2.7.7
*/
public static List<LoadingStrategy> getLoadingStrategies() {
return asList(strategies);
}
ExtensionLoader(Class<?> type, ExtensionDirector extensionDirector, ScopeModel scopeModel) {
this.type = type;
this.extensionDirector = extensionDirector;
this.extensionPostProcessors = extensionDirector.getExtensionPostProcessors();
initInstantiationStrategy();
this.injector = (type == ExtensionInjector.class ? null : extensionDirector.getExtensionLoader(ExtensionInjector.class)
.getAdaptiveExtension());
this.activateComparator = new ActivateComparator(extensionDirector);
this.scopeModel = scopeModel;
}
private void initInstantiationStrategy() {
for (ExtensionPostProcessor extensionPostProcessor : extensionPostProcessors) {
if (extensionPostProcessor instanceof ScopeModelAccessor) {
instantiationStrategy = new InstantiationStrategy((ScopeModelAccessor) extensionPostProcessor);
break;
}
}
if (instantiationStrategy == null) {
instantiationStrategy = new InstantiationStrategy();
}
}
/**
* @see ApplicationModel#getExtensionDirector()
* @see FrameworkModel#getExtensionDirector()
* @see ModuleModel#getExtensionDirector()
* @see ExtensionDirector#getExtensionLoader(java.lang.Class)
* @deprecated get extension loader from extension director of some module.
*/
@Deprecated
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
return ApplicationModel.defaultModel().getDefaultModule().getExtensionLoader(type);
}
// For testing purposes only
public static void resetExtensionLoader(Class type) {
// ExtensionLoader loader = EXTENSION_LOADERS.get(type);
// if (loader != null) {
// // Remove all instances associated with this loader as well
// Map<String, Class<?>> classes = loader.getExtensionClasses();
// for (Map.Entry<String, Class<?>> entry : classes.entrySet()) {
// EXTENSION_INSTANCES.remove(entry.getValue());
// }
// classes.clear();
// EXTENSION_LOADERS.remove(type);
// }
}
public void destroy() {
if (!destroyed.compareAndSet(false, true)) {
return;
}
// destroy raw extension instance
extensionInstances.forEach((type, instance) -> {
if (instance instanceof Disposable) {
Disposable disposable = (Disposable) instance;
try {
disposable.destroy();
} catch (Exception e) {
logger.error("Error destroying extension " + disposable, e);
}
}
});
extensionInstances.clear();
// destroy wrapped extension instance
for (Holder<Object> holder : cachedInstances.values()) {
Object wrappedInstance = holder.get();
if (wrappedInstance instanceof Disposable) {
Disposable disposable = (Disposable) wrappedInstance;
try {
disposable.destroy();
} catch (Exception e) {
logger.error("Error destroying extension " + disposable, e);
}
}
}
cachedInstances.clear();
}
private void checkDestroyed() {
if (destroyed.get()) {
throw new IllegalStateException("ExtensionLoader is destroyed: " + type);
}
}
private static ClassLoader findClassLoader() {
return ClassUtils.getClassLoader(ExtensionLoader.class);
}
public String getExtensionName(T extensionInstance) {
return getExtensionName(extensionInstance.getClass());
}
public String getExtensionName(Class<?> extensionClass) {
getExtensionClasses();// load class
return cachedNames.get(extensionClass);
}
/**
* This is equivalent to {@code getActivateExtension(url, key, null)}
*
* @param url url
* @param key url parameter key which used to get extension point names
* @return extension list which are activated.
* @see #getActivateExtension(org.apache.dubbo.common.URL, String, String)
*/
public List<T> getActivateExtension(URL url, String key) {
return getActivateExtension(url, key, null);
}
/**
* This is equivalent to {@code getActivateExtension(url, values, null)}
*
* @param url url
* @param values extension point names
* @return extension list which are activated
* @see #getActivateExtension(org.apache.dubbo.common.URL, String[], String)
*/
public List<T> getActivateExtension(URL url, String[] values) {
return getActivateExtension(url, values, null);
}
/**
* This is equivalent to {@code getActivateExtension(url, url.getParameter(key).split(","), null)}
*
* @param url url
* @param key url parameter key which used to get extension point names
* @param group group
* @return extension list which are activated.
* @see #getActivateExtension(org.apache.dubbo.common.URL, String[], String)
*/
public List<T> getActivateExtension(URL url, String key, String group) {
String value = url.getParameter(key);
return getActivateExtension(url, StringUtils.isEmpty(value) ? null : COMMA_SPLIT_PATTERN.split(value), group);
}
/**
* Get activate extensions.
*
* @param url url
* @param values extension point names
* @param group group
* @return extension list which are activated
* @see org.apache.dubbo.common.extension.Activate
*/
/**
* 根据Activate注解，对一个接口可以自动激活多个实现类
* @param url
* @param values
* @param group
* @return
*/
public List<T> getActivateExtension(URL url, String[] values, String group) {
/** 检查是否注销 */
checkDestroyed();
// solve the bug of using @SPI's wrapper method to report a null pointer exception.
Map<Class<?>, T> activateExtensionsMap = new TreeMap<>(activateComparator);
List<String> names = values == null ? new ArrayList<>(0) : asList(values);
Set<String> namesSet = new HashSet<>(names);
if (!namesSet.contains(REMOVE_VALUE_PREFIX + DEFAULT_KEY)) {
if (cachedActivateGroups.size() == 0) {
synchronized (cachedActivateGroups) {
// cache all extensions
if (cachedActivateGroups.size() == 0) {
getExtensionClasses();
for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Object activate = entry.getValue();
String[] activateGroup, activateValue;
if (activate instanceof Activate) {
activateGroup = ((Activate) activate).group();
activateValue = ((Activate) activate).value();
} else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
activateValue = ((com.alibaba.dubbo.common.extension.Activate) activate).value();
} else {
continue;
}
cachedActivateGroups.put(name, new HashSet<>(Arrays.asList(activateGroup)));
String[][] keyPairs = new String[activateValue.length][];
for (int i = 0; i < activateValue.length; i++) {
if (activateValue[i].contains(":")) {
keyPairs[i] = new String[2];
String[] arr = activateValue[i].split(":");
keyPairs[i][0] = arr[0];
keyPairs[i][1] = arr[1];
} else {
keyPairs[i] = new String[1];
keyPairs[i][0] = activateValue[i];
}
}
cachedActivateValues.put(name, keyPairs);
}
}
}
}
// traverse all cached extensions
cachedActivateGroups.forEach((name, activateGroup) -> {
if (isMatchGroup(group, activateGroup)
&& !namesSet.contains(name)
&& !namesSet.contains(REMOVE_VALUE_PREFIX + name)
&& isActive(cachedActivateValues.get(name), url)) {
/**
* key：name对应的实现类
* value：name对应的实现类的对象
*/
activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
}
});
}
if (namesSet.contains(DEFAULT_KEY)) {
// will affect order
// `ext1,default,ext2` means ext1 will happens before all of the default extensions while ext2 will after them
ArrayList<T> extensionsResult = new ArrayList<>(activateExtensionsMap.size() + names.size());
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(REMOVE_VALUE_PREFIX)
&& !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
if (!DEFAULT_KEY.equals(name)) {
if (containsExtension(name)) {
extensionsResult.add(getExtension(name));
}
} else {
extensionsResult.addAll(activateExtensionsMap.values());
}
}
}
return extensionsResult;
} else {
// add extensions, will be sorted by its order
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(REMOVE_VALUE_PREFIX)
&& !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
if (!DEFAULT_KEY.equals(name)) {
if (containsExtension(name)) {
activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
}
}
}
}
return new ArrayList<>(activateExtensionsMap.values());
}
}
public List<T> getActivateExtensions() {
checkDestroyed();
List<T> activateExtensions = new ArrayList<>();
TreeMap<Class<?>, T> activateExtensionsMap = new TreeMap<>(activateComparator);
getExtensionClasses();
for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Object activate = entry.getValue();
if (!(activate instanceof Activate)) {
continue;
}
activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
}
if (!activateExtensionsMap.isEmpty()) {
activateExtensions.addAll(activateExtensionsMap.values());
}
return activateExtensions;
}
private boolean isMatchGroup(String group, Set<String> groups) {
if (StringUtils.isEmpty(group)) {
return true;
}
if (CollectionUtils.isNotEmpty(groups)) {
return groups.contains(group);
}
return false;
}
private boolean isActive(String[][] keyPairs, URL url) {
if (keyPairs.length == 0) {
return true;
}
for (String[] keyPair : keyPairs) {
// @Active(value="key1:value1, key2:value2")
String key;
String keyValue = null;
if (keyPair.length > 1) {
key = keyPair[0];
keyValue = keyPair[1];
} else {
key = keyPair[0];
}
String realValue = url.getParameter(key);
if (StringUtils.isEmpty(realValue)) {
realValue = url.getAnyMethodParameter(key);
}
if ((keyValue != null && keyValue.equals(realValue)) || (keyValue == null && ConfigUtils.isNotEmpty(realValue))) {
return true;
}
}
return false;
}
/**
* Get extension's instance. Return <code>null</code> if extension is not found or is not initialized. Pls. note
* that this method will not trigger extension load.
* <p>
* In order to trigger extension load, call {@link #getExtension(String)} instead.
*
* @see #getExtension(String)
*/
@SuppressWarnings("unchecked")
public T getLoadedExtension(String name) {
checkDestroyed();
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
Holder<Object> holder = getOrCreateHolder(name);
return (T) holder.get();
}
private Holder<Object> getOrCreateHolder(String name) {
/** 根据名称去缓存中获取对应的Holder */
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
/** 如果为空则构建一个空的缓存并返回 */
cachedInstances.putIfAbsent(name, new Holder<>());
holder = cachedInstances.get(name);
}
return holder;
}
/**
* Return the list of extensions which are already loaded.
* <p>
* Usually {@link #getSupportedExtensions()} should be called in order to get all extensions.
*
* @see #getSupportedExtensions()
*/
public Set<String> getLoadedExtensions() {
return Collections.unmodifiableSet(new TreeSet<>(cachedInstances.keySet()));
}
public List<T> getLoadedExtensionInstances() {
checkDestroyed();
List<T> instances = new ArrayList<>();
cachedInstances.values().forEach(holder -> instances.add((T) holder.get()));
return instances;
}
public Object getLoadedAdaptiveExtensionInstances() {
return cachedAdaptiveInstance.get();
}
/**
* Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
* will be thrown.
*/
@SuppressWarnings("unchecked")
/**
* 根据名称寻找对应的扩展类，没有找到则跑出异常
*/
public T getExtension(String name) {
T extension = getExtension(name, true);
if (extension == null) {
throw new IllegalArgumentException("Not find extension: " + name);
}
return extension;
}
public T getExtension(String name, boolean wrap) {
checkDestroyed();
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
if ("true".equals(name)) {
return getDefaultExtension();
}
/** 赋值缓存key */
String cacheKey = name;
if (!wrap) {
cacheKey += "_origin";
}
/** 基于缓存key构建了一个Holder容器 */
final Holder<Object> holder = getOrCreateHolder(cacheKey);
/** 调用Holder的get方法，获取里面具体封装的实现类的对象 */
Object instance = holder.get();
/** 如果为空则去构建一个实现类的对象 */
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
/** 创建一个对象 */
instance = createExtension(name, wrap);
/** 将创建出来的对象设置给Holder */
holder.set(instance);
}
}
}
return (T) instance;
}
/**
* Get the extension by specified name if found, or {@link #getDefaultExtension() returns the default one}
*
* @param name the name of extension
* @return non-null
*/
public T getOrDefaultExtension(String name) {
return containsExtension(name) ? getExtension(name) : getDefaultExtension();
}
/**
* Return default extension, return <code>null</code> if it's not configured.
*/
public T getDefaultExtension() {
getExtensionClasses();
if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
return null;
}
return getExtension(cachedDefaultName);
}
public boolean hasExtension(String name) {
checkDestroyed();
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
Class<?> c = this.getExtensionClass(name);
return c != null;
}
public Set<String> getSupportedExtensions() {
checkDestroyed();
Map<String, Class<?>> classes = getExtensionClasses();
return Collections.unmodifiableSet(new TreeSet<>(classes.keySet()));
}
public Set<T> getSupportedExtensionInstances() {
checkDestroyed();
List<T> instances = new LinkedList<>();
Set<String> supportedExtensions = getSupportedExtensions();
if (CollectionUtils.isNotEmpty(supportedExtensions)) {
for (String name : supportedExtensions) {
instances.add(getExtension(name));
}
}
// sort the Prioritized instances
sort(instances, Prioritized.COMPARATOR);
return new LinkedHashSet<>(instances);
}
/**
* Return default extension name, return <code>null</code> if not configured.
*/
public String getDefaultExtensionName() {
getExtensionClasses();
return cachedDefaultName;
}
/**
* Register new extension via API
*
* @param name extension name
* @param clazz extension class
* @throws IllegalStateException when extension with the same name has already been registered.
*/
public void addExtension(String name, Class<?> clazz) {
checkDestroyed();
getExtensionClasses(); // load classes
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Input type " +
clazz + " doesn't implement the Extension " + type);
}
if (clazz.isInterface()) {
throw new IllegalStateException("Input type " +
clazz + " can't be interface!");
}
if (!clazz.isAnnotationPresent(Adaptive.class)) {
if (StringUtils.isBlank(name)) {
throw new IllegalStateException("Extension name is blank (Extension " + type + ")!");
}
if (cachedClasses.get().containsKey(name)) {
throw new IllegalStateException("Extension name " +
name + " already exists (Extension " + type + ")!");
}
cachedNames.put(clazz, name);
cachedClasses.get().put(name, clazz);
} else {
if (cachedAdaptiveClass != null) {
throw new IllegalStateException("Adaptive Extension already exists (Extension " + type + ")!");
}
cachedAdaptiveClass = clazz;
}
}
/**
* Replace the existing extension via API
*
* @param name extension name
* @param clazz extension class
* @throws IllegalStateException when extension to be placed doesn't exist
* @deprecated not recommended any longer, and use only when test
*/
@Deprecated
public void replaceExtension(String name, Class<?> clazz) {
checkDestroyed();
getExtensionClasses(); // load classes
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Input type " +
clazz + " doesn't implement Extension " + type);
}
if (clazz.isInterface()) {
throw new IllegalStateException("Input type " +
clazz + " can't be interface!");
}
if (!clazz.isAnnotationPresent(Adaptive.class)) {
if (StringUtils.isBlank(name)) {
throw new IllegalStateException("Extension name is blank (Extension " + type + ")!");
}
if (!cachedClasses.get().containsKey(name)) {
throw new IllegalStateException("Extension name " +
name + " doesn't exist (Extension " + type + ")!");
}
cachedNames.put(clazz, name);
cachedClasses.get().put(name, clazz);
cachedInstances.remove(name);
} else {
if (cachedAdaptiveClass == null) {
throw new IllegalStateException("Adaptive Extension doesn't exist (Extension " + type + ")!");
}
cachedAdaptiveClass = clazz;
cachedAdaptiveInstance.set(null);
}
}
@SuppressWarnings("unchecked")
/**
* 针对Adaptive注解的SPI扩展机制，如果有多个实现类
* 可以根据url里带的一些参数直接匹配定位对应的一个实现类
*/
public T getAdaptiveExtension() {
/** 检查是否被销毁 */
checkDestroyed();
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError != null) {
throw new IllegalStateException("Failed to create adaptive instance: " +
createAdaptiveInstanceError.toString(),
createAdaptiveInstanceError);
}
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
/** 创建自适应扩展 */
instance = createAdaptiveExtension();
/** 设置缓存 */
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
createAdaptiveInstanceError = t;
throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
}
}
}
}
return (T) instance;
}
private IllegalStateException findException(String name) {
StringBuilder buf = new StringBuilder("No such extension " + type.getName() + " by name " + name);
int i = 1;
for (Map.Entry<String, IllegalStateException> entry : exceptions.entrySet()) {
if (entry.getKey().toLowerCase().startsWith(name.toLowerCase())) {
if (i == 1) {
buf.append(", possible causes: ");
}
buf.append("\r\n(");
buf.append(i++);
buf.append(") ");
buf.append(entry.getKey());
buf.append(":\r\n");
buf.append(StringUtils.toString(entry.getValue()));
}
}
if (i == 1) {
buf.append(", no related exception was found, please check whether related SPI module is missing.");
}
return new IllegalStateException(buf.toString());
}
@SuppressWarnings("unchecked")
private T createExtension(String name, boolean wrap) {
/**
* 根据名称从加载出来的那些实现类里拿出来一个具体的class
* 根据接口拿到的实现类，在构建实现类的对象注入给接口类型的变量
*/
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null || unacceptableExceptions.contains(name)) {
throw findException(name);
}
try {
/** 获取缓存中的数据 */
T instance = (T) extensionInstances.get(clazz);
if (instance == null) {
/** 如果缓存没有命中则会去构建一个实现类的对象 */
extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));
instance = (T) extensionInstances.get(clazz);
/** 对实例对象进行初始化之前的后处理 */
instance = postProcessBeforeInitialization(instance, name);
/** 依赖注入：dubbo SPI机制也扮演了类试Spring容器的机制，会托管你的实现类的对象，对其进行依赖注入 */
injectExtension(instance);
/** 对实例对象进行初始化之后的后处理 */
instance = postProcessAfterInitialization(instance, name);
}
/** 如果需要对这个实现类的实例进行包装则进行后续处理 */
if (wrap) {
List<Class<?>> wrapperClassesList = new ArrayList<>();
if (cachedWrapperClasses != null) {
wrapperClassesList.addAll(cachedWrapperClasses);
wrapperClassesList.sort(WrapperComparator.COMPARATOR);
Collections.reverse(wrapperClassesList);
}
if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
for (Class<?> wrapperClass : wrapperClassesList) {
Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
boolean match = (wrapper == null) ||
((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&
!ArrayUtils.contains(wrapper.mismatches(), name));
if (match) {
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
instance = postProcessAfterInitialization(instance, name);
}
}
}
}
// Warning: After an instance of Lifecycle is wrapped by cachedWrapperClasses, it may not still be Lifecycle instance, this application may not invoke the lifecycle.initialize hook.
initExtension(instance);
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}
private Object createExtensionInstance(Class<?> type) throws ReflectiveOperationException {
return instantiationStrategy.instantiate(type);
}
private T postProcessBeforeInitialization(T instance, String name) throws Exception {
if (extensionPostProcessors != null) {
for (ExtensionPostProcessor processor : extensionPostProcessors) {
instance = (T) processor.postProcessBeforeInitialization(instance, name);
}
}
return instance;
}
private T postProcessAfterInitialization(T instance, String name) throws Exception {
if (instance instanceof ExtensionAccessorAware) {
((ExtensionAccessorAware) instance).setExtensionAccessor(extensionDirector);
}
if (extensionPostProcessors != null) {
for (ExtensionPostProcessor processor : extensionPostProcessors) {
instance = (T) processor.postProcessAfterInitialization(instance, name);
}
}
return instance;
}
private boolean containsExtension(String name) {
return getExtensionClasses().containsKey(name);
}
private T injectExtension(T instance) {
if (injector == null) {
return instance;
}
try {
for (Method method : instance.getClass().getMethods()) {
/** 如果不是setter方法进入下一循环 */
if (!isSetter(method)) {
continue;
}
/**
* Check {@link DisableInject} to see if we need auto injection for this property
*/
/** 如果加了DisableInject注解进入下一循环 */
if (method.isAnnotationPresent(DisableInject.class)) {
continue;
}
/** 基于setter方法进行依赖注入 */
Class<?> pt = method.getParameterTypes()[0];
/** 如果参数是原始类型进入下一循环 */
if (ReflectUtils.isPrimitives(pt)) {
continue;
}
try {
/** 获取setter属性 */
String property = getSetterProperty(method);
/**
* 根据setter属性获取对象
* 如果你注入的对象是其他SPI机制里实现类的对象
* 此时可以直接从容器中获取注入就好了
*/
Object object = injector.getInstance(pt, property);
if (object != null) {
/** 调用setter方法完成依赖注入 */
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("Failed to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
private void initExtension(T instance) {
if (instance instanceof Lifecycle) {
/**
* 如果实现类实现了Lifecycle接口则会将其强转成Lifecycle，在调用initialize方法去做一些处理
* 这个算是dbuuo留给我们的扩展点，如果我们需要在类初始化的时候做一些事情可以继承此接口
* 在initialize方法里面写入对应的逻辑
*/
Lifecycle lifecycle = (Lifecycle) instance;
lifecycle.initialize();
}
}
/**
* get properties name for setter, for instance: setVersion, return "version"
* <p>
* return "", if setter name with length less than 3
*/
private String getSetterProperty(Method method) {
return method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
}
/**
* return true if and only if:
* <p>
* 1, public
* <p>
* 2, name starts with "set"
* <p>
* 3, only has one parameter
*/
private boolean isSetter(Method method) {
return method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers());
}
private Class<?> getExtensionClass(String name) {
if (type == null) {
throw new IllegalArgumentException("Extension type == null");
}
if (name == null) {
throw new IllegalArgumentException("Extension name == null");
}
return getExtensionClasses().get(name);
}
private Map<String, Class<?>> getExtensionClasses() {
/** 获取缓存中的Class集合 */
Map<String, Class<?>> classes = cachedClasses.get();
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
/** 核心：如果为空则去寻找对应的ExtensionClasses */
classes = loadExtensionClasses();
/** 如果获取到了则会放入缓存下次获取时直接返回 */
cachedClasses.set(classes);
}
}
}
return classes;
}
/**
* synchronized in getExtensionClasses
*/
private Map<String, Class<?>> loadExtensionClasses() {
/** 判断是否销毁 */
checkDestroyed();
/**缓存默认的扩展名称 */
cacheDefaultExtensionName();
/** 扩展类集合 */
Map<String, Class<?>> extensionClasses = new HashMap<>();
for (LoadingStrategy strategy : strategies) {
loadDirectory(extensionClasses, strategy, type.getName());
// compatible with old ExtensionFactory
if (this.type == ExtensionInjector.class) {
loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
}
}
return extensionClasses;
}
private void loadDirectory(Map<String, Class<?>> extensionClasses, LoadingStrategy strategy, String type) {
/** 针对常规的类进行装载 */
loadDirectory(extensionClasses, strategy.directory(), type, strategy.preferExtensionClassLoader(),
strategy.overridden(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
/** 将接口中的org.apache替换成com.alibaba */
String oldType = type.replace("org.apache", "com.alibaba");
loadDirectory(extensionClasses, strategy.directory(), oldType, strategy.preferExtensionClassLoader(),
strategy.overridden(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
}
/**
* extract and cache default extension name if exists
*/
private void cacheDefaultExtensionName() {
/** 获取添加到接口的SPI注解 */
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation == null) {
return;
}
/** 获取注解里的值 */
String value = defaultAnnotation.value();
if ((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 */
cachedDefaultName = names[0];
}
}
}
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
loadDirectory(extensionClasses, dir, type, false, false, new String[]{}, new String[]{});
}
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
boolean extensionLoaderClassLoaderFirst, boolean overridden,
String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
/**
* dir：目录
* type：接口的名字
*/
String fileName = dir + type;
try {
List<ClassLoader> classLoadersToLoad = new LinkedList<>();
// try to load from ExtensionLoader's ClassLoader first
if (extensionLoaderClassLoaderFirst) {
ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
classLoadersToLoad.add(extensionLoaderClassLoader);
}
}
// load from scope model
Set<ClassLoader> classLoaders = scopeModel.getClassLoaders();
if (CollectionUtils.isEmpty(classLoaders)) {
/** 基于文件名通过ClassLoader去加载资源集合 */
Enumeration<java.net.URL> resources = ClassLoader.getSystemResources(fileName);
if (resources != null) {
while (resources.hasMoreElements()) {
loadResource(extensionClasses, null, resources.nextElement(), overridden, excludedPackages, onlyExtensionClassLoaderPackages);
}
}
} else {
classLoadersToLoad.addAll(classLoaders);
}
Map<ClassLoader, Set<java.net.URL>> resources = ClassLoaderResourceLoader.loadResources(fileName, classLoadersToLoad);
resources.forEach(((classLoader, urls) -> {
loadFromClass(extensionClasses, overridden, urls, classLoader, excludedPackages, onlyExtensionClassLoaderPackages);
}));
} catch (Throwable t) {
logger.error("Exception occurred when loading extension class (interface: " +
type + ", description file: " + fileName + ").", t);
}
}
private void loadFromClass(Map<String, Class<?>> extensionClasses, boolean overridden, Set<java.net.URL> urls, ClassLoader classLoader,
String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
if (CollectionUtils.isNotEmpty(urls)) {
for (java.net.URL url : urls) {
loadResource(extensionClasses, classLoader, url, overridden, excludedPackages, onlyExtensionClassLoaderPackages);
}
}
}
/**
* 基于配置文件以及相应的规则进行io读取和加载相应的ExtensionClass
* 对Adaptive注解标注的类会通过其不同的机制去分别进行处理和缓存
* @param extensionClasses
* @param classLoader
* @param resourceURL
* @param overridden
* @param excludedPackages
* @param onlyExtensionClassLoaderPackages
*/
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
java.net.URL resourceURL, boolean overridden, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
try {
/** 通过io操作读取文件数据 */
try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
String line;
String clazz;
/** 一行一行读取数据*/
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();
clazz = line.substring(i + 1).trim();
} else {
clazz = line;
}
if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)
&& !isExcludedByClassLoader(clazz, classLoader, onlyExtensionClassLoaderPackages)) {
loadClass(extensionClasses, resourceURL,
/** 加载扩展类的实现 */
Class.forName(clazz, true, classLoader),
name, overridden);
}
} catch (Throwable t) {
IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type +
", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
exceptions.put(line, e);
}
}
}
}
} catch (Throwable t) {
logger.error("Exception occurred when loading extension class (interface: " +
type + ", class file: " + resourceURL + ") in " + resourceURL, t);
}
}
private boolean isExcluded(String className, String... excludedPackages) {
if (excludedPackages != null) {
for (String excludePackage : excludedPackages) {
if (className.startsWith(excludePackage + ".")) {
return true;
}
}
}
return false;
}
private boolean isExcludedByClassLoader(String className, ClassLoader classLoader, String... onlyExtensionClassLoaderPackages) {
if (onlyExtensionClassLoaderPackages != null) {
for (String excludePackage : onlyExtensionClassLoaderPackages) {
if (className.startsWith(excludePackage + ".")) {
// if target classLoader is not ExtensionLoader's classLoader should be excluded
return !Objects.equals(ExtensionLoader.class.getClassLoader(), classLoader);
}
}
}
return false;
}
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
boolean overridden) throws NoSuchMethodException {
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Error occurred when loading extension class (interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + " is not subtype of interface.");
}
/** 判断类上面是否加了Adaptive注解 */
if (clazz.isAnnotationPresent(Adaptive.class)) {
/** 如果实现类是@Adaptive类型的，会赋值给cachedAdaptiveClass，这个用来存放被@Adaptive注解的实现类 */
cacheAdaptiveClass(clazz, overridden);
}
/**
* 判断是否是wrapper类型
* 如果得到的实现类的构造方法中的参数是扩展点类型的，就是一个Wrapper类
* 比如ProtocolFilterWrapper，实现了Protocol类，
* 而它的构造方法是这样public ProtocolFilterWrapper(Protocol protocol)
* 就说明这个类是一个包装类
*/
else if (isWrapperClass(clazz)) {
/** cachedWrapperClasses用来存放当前扩展点实现类中的包装类 */
cacheWrapperClass(clazz);
} else {
/** 没有名字，就是配置文件中没有xxx=xxxx.com.xxx这种 */
if (StringUtils.isEmpty(name)) {
/** 去找@Extension注解中配置的值 */
name = findAnnotationName(clazz);
if (name.length() == 0) {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
}
}
/** 有可能配置了多个名字 */
String[] names = NAME_SEPARATOR.split(name);
if (ArrayUtils.isNotEmpty(names)) {
/** 第一个名字作为键，放进cachedActivates这个map中缓存 */
cacheActivateClass(clazz, names[0]);
for (String n : names) {
/** 放入Extension实现类与名称映射的缓存中去，每个class只对应第一个名称有效 */
cacheName(clazz, n);
/** 放入到extensionClasses缓存中去，多个name可能对应一份extensionClasses */
saveInExtensionClass(extensionClasses, clazz, n, overridden);
}
}
}
}
/**
* cache name
*/
private void cacheName(Class<?> clazz, String name) {
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, name);
}
}
/**
* put clazz in extensionClasses
*/
private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name, boolean overridden) {
Class<?> c = extensionClasses.get(name);
if (c == null || overridden) {
extensionClasses.put(name, clazz);
} else if (c != clazz) {
// duplicate implementation is unacceptable
unacceptableExceptions.add(name);
String duplicateMsg = "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
logger.error(duplicateMsg);
throw new IllegalStateException(duplicateMsg);
}
}
/**
* cache Activate class which is annotated with <code>Activate</code>
* <p>
* for compatibility, also cache class with old alibaba Activate annotation
*/
private void cacheActivateClass(Class<?> clazz, String name) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
cachedActivates.put(name, activate);
} else {
// support com.alibaba.dubbo.common.extension.Activate
com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
if (oldActivate != null) {
cachedActivates.put(name, oldActivate);
}
}
}
/**
* cache Adaptive class which is annotated with <code>Adaptive</code>
*/
private void cacheAdaptiveClass(Class<?> clazz, boolean overridden) {
if (cachedAdaptiveClass == null || overridden) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getName()
+ ", " + clazz.getName());
}
}
/**
* cache wrapper class
* <p>
* like: ProtocolFilterWrapper, ProtocolListenerWrapper
*/
private void cacheWrapperClass(Class<?> clazz) {
if (cachedWrapperClasses == null) {
cachedWrapperClasses = new ConcurrentHashSet<>();
}
cachedWrapperClasses.add(clazz);
}
/**
* test if clazz is a wrapper class
* <p>
* which has Constructor with given class type as its only argument
*/
private boolean isWrapperClass(Class<?> clazz) {
try {
clazz.getConstructor(type);
return true;
} catch (NoSuchMethodException e) {
return false;
}
}
@SuppressWarnings("deprecation")
private String findAnnotationName(Class<?> clazz) {
Extension extension = clazz.getAnnotation(Extension.class);
if (extension != null) {
return extension.value();
}
String name = clazz.getSimpleName();
if (name.endsWith(type.getSimpleName())) {
name = name.substring(0, name.length() - type.getSimpleName().length());
}
return name.toLowerCase();
}
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
try {
/** 获取自适应扩展类，通过反射实例化 */
T instance = (T) getAdaptiveExtensionClass().newInstance();
/** 对实例对象进行初始化之前的后处理 */
instance = postProcessBeforeInitialization(instance, null);
/** 依赖注入 */
instance = injectExtension(instance);
/** 对实例对象进行初始化之后的后处理 */
instance = postProcessAfterInitialization(instance, null);
/** 初始化 */
initExtension(instance);
return instance;
} catch (Exception e) {
throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses();
/**
* 如果缓存中已经找到自适应类的话直接返回，意思也就是这个spi有Adaptive的注解类
* 比如：当前获取的自适应实现类是AdaptiveExtensionFactory或者是AdaptiveCompiler
* 就直接返回，这两个类是特殊用处的，不用代码生成，而是现成的代码
*/
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
/** 否则需要代理类去创建具体的Adaptive自适应的扩展类 */
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
private Class<?> createAdaptiveExtensionClass() {
// Adaptive Classes' ClassLoader should be the same with Real SPI interface classes' ClassLoader
ClassLoader classLoader = type.getClassLoader();
try {
if (NativeUtils.isNative()) {
return classLoader.loadClass(type.getName() + "$Adaptive");
}
} catch (Throwable ignore) {
}
/**
* 利用AdaptiveClassCodeGenerator进行类代码生成
* 类代码是动态生成出来的
*/
String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
/** 对动态生成的类代码进行动态编译成Class字节码对象 */
org.apache.dubbo.common.compiler.Compiler compiler = extensionDirector.getExtensionLoader(
org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(type, code, classLoader);
}
private Environment getEnvironment() {
if (environment == null) {
environment = (Environment) extensionDirector.getExtensionLoader(ApplicationExt.class).getExtension(Environment.NAME);
}
return environment;
}
@Override
public String toString() {
return this.getClass().getName() + "[" + type.getName() + "]";
}
}