Dubbo-SPI机制
作者：互联网
前言
SPI全称为Service Provider Interface,是Java提供的一种服务发现机制。SPI的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。 正因此特性，我们可以很容易的通过SPI机制为我们的程序提供拓展功能。今天文章就从Java SPI到Dubbo的SPI，让我们看看Dubbo做了扩展。
Java SPI
实现
定义一个接口和接口的实现；
/**
* 动物
*
* @author wangtongzhou
* @since 2022-06-12 11:26
*/
public interface Animal {
String getName();
}
/**
* 猫
*
* @author wangtongzhou
* @since 2022-06-12 11:37
*/
public class Cat implements Animal {
@Override
public String getName() {
System.out.println("我是一只猫");
return "猫";
}
}
在resources目录下创建META-INF/services目录； 在对应的目录下创建接口全路径的文件； 添加文件内容为实现接口的全路径； 
使用ServiceLoader加载类相关内容；
/**
* spi
*
* @author wangtongzhou
* @since 2022-06-12 11:47
*/
public class Test {
public static void main(String[] args) {
ServiceLoader<Animal> animals=ServiceLoader.load(Animal.class);
animals.forEach(Animal::getName);
}
}
使用场景
数据库驱动加载接口实现类的加载，JDBC加载不同类型数据库的驱动； 
日志门面接口实现类加载，SLF4J加载不同提供商的日志实现类 
SpringBoot中的自动配置原理，即SpringFactoriesLoader类读取配置文件 spring.factories 中的配置文件的这种方式是一种 SPI 的思想； Dubbo中也大量使用SPI的方式实现框架的扩展，不过它对Java提供的原生SPI做了封装；
总结
优点
使用Java SPI机制的优势是实现解耦，使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离，而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。
缺点
JDK 标准的 SPI 会一次性加载实例化扩展点的所有实现，也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类，它也被加载并实例化了，这就造成了浪费; 获取某个实现类的方式不够灵活，只能通过Iterator形式获取，不能根据某个参数来获取对应的实现类；
Dubbo SPI
为什么学习Dubbo SPI
Dubbo的SPI层所有的接口都可以基于Dubbo框架做定制性的二次开发,扩展功能。比如负载均衡、协议、注册中心等等都可以扩展，这个是Dubbo强大和灵活的所在。
Dubbo SPI优势
按需加载，Dubbo SPI配置文件采用KV格式存储，key 被称为扩展名，当我们在为一个接口查找具体实现类时，可以指定扩展名来选择相应的扩展实现，只实例化这一个扩展实现即可，无须实例化 SPI 配置文件中的其他扩展实现类，避免资源浪费，此外通过 KV 格式的 SPI 配置文件，当我们使用的一个扩展实现类所在的 jar 包没有引入到项目中时，Dubbo SPI 在抛出异常的时候，会携带该扩展名信息，而不是简单地提示扩展实现类无法加载。这些更加准确的异常信息降低了排查问题的难度，提高了排查问题的效率。； 增加扩展类的 IOC 能力，Dubbo 的扩展能力并不仅仅只是发现扩展服务实现类，而是在此基础上更进一步，如果该扩展类的属性依赖其他对象，则 Dubbo 会自动的完成该依赖对象的注入功能； 增加扩展类的 AOP 能力，Dubbo 扩展能力会自动的发现扩展类的包装类，完成包装类的构造，增强扩展类的功能；
使用
自定义SPI注解接口以及实现对应接口；
/**
* 动物
*
* @author wangtongzhou
* @since 2022-06-12 11:26
*/
@SPI
public interface Animal {
String getName();
}
/**
* 猫
*
* @author wangtongzhou
* @since 2022-06-12 11:37
*/
public class Cat implements Animal {
@Override
public String getName() {
System.out.println("我是一只猫");
return "猫";
}
}
需要在 resource 目录下配置 META-INF/dubbo 或者 META-INF/dubbo/internal 或者 META-INF/services，并基于 SPI 接口去创建一个文件； 文件名称和接口名称保持一致，文件内容与Java SPI有差异，内容是KEY 对应 Value； 
使用ExtensionLoader调用；
/**
* 测试
*
* @author wangtongzhou
* @since 2022-06-12 17:32
*/
public class Test {
public static void main(String[] args) {
Animal animal= ExtensionLoader.getExtensionLoader(Animal.class).getExtension("cat");
System.out.println(animal.getName());
}
}
源码解析
通过上面的使用案例来看，Dubbo的某个接口被@SPI修饰的时候，就表示该接口是扩展接口，是通过ExtensionLoader.getExtensionLoader完成ExtensionLoader的初始化，然后再通过ExtensionLoader 的 getExtension 方法获取拓展类对象。接下来我们来整体看下@SPI加载过程。
Animal animal= ExtensionLoader.getExtensionLoader(Animal.class).getExtension("cat");
getExtensionLoader
首先是getExtensionLoader的方法，完成ExtensionLoader创建，该方法内部完成一些关于type的校验，然后根据EXTENSION_LOADERS缓存获取ExtensionLoader的实例，EXTENSION_LOADERS集合缓存了全部 ExtensionLoader 实例，其中的 Key 为扩展接口，Value 为加载其扩展实现的 ExtensionLoader 实例，如果不存在缓存的时候，则主动创建一个。
@SuppressWarnings("unchecked")
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 an interface!");
}
//必须@SPI
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type (" + type +
") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
}
//初始化ExtensionLoader
//判断下有没有缓存
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
接下来我们看一下ExtensionLoader构造函数的初始化，关于ExtensionLoader是一个私有的构造函数，如果当前的 type=ExtensionFactory,那么objectFactory=null, 否则会创建一个自适应扩展点给objectFacotry，这里介绍一下objectFactory，objectFactory有是三种实现，如下图:
其中AdaptiveExtensionFactory 不实现任何具体的功能，而是用来适配 ExtensionFactory 的 SpiExtensionFactory 和 SpringExtensionFactory 这两种实现。前者用于创建自适应的拓展，后则是到 Spring 的 IOC 容器中获取所需拓展。AdaptiveExtensionFactory 会根据运行时的一些状态来选择具体调用 ExtensionFactory 的哪个实现。
关于objectFactory的实现为AdaptiveExtensionFactory，AdaptiveExtensionFactory 内部维护了一个ExtensionFactory 列表，用于存储SpiExtensionFactory 和 SpringExtensionFactory的实现。
private ExtensionLoader(Class<?> type) {
this.type = type;
//type为普通接口时，objectFactory实现为AdaptiveExtensionFactory
//实现dubbo spi ioc功能
objectFactory =
(type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
关于这三者实现如下，不同点在于AdaptiveExtensionFactory类上面增加@Adaptive注解，至于为什么实现是AdaptiveExtensionFactory，应该有两处决定的一个是LoadingStrategy对象，该对象进行排序，保障了DubboExternalLoadingStrategy目录下的文件优先加载，另外一个就是ExtensionFactory的配置文件，AdaptiveExtensionFactory的配置在前。
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
//存储其他类型的 ExtensionFactory对象
private final List<ExtensionFactory> factories;
public AdaptiveExtensionFactory() {
//获取拓展点接口ExtensionFactory对应的ExtensionLoader
//每个拓展点接口都有一个对应的ExtensionLoader对象
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
//getSupportedExtensions得到所有非@Adaptive标注
//也非ExtensionFactory包装类的实现类的配置名
//getExtension通过配置名得到对象
for (String name : loader.getSupportedExtensions()) {
list.add(loader.getExtension(name));
}
factories = Collections.unmodifiableList(list);
}
@Override
public <T> T getExtension(Class<T> type, String name) {
//遍历所有其它ExtensionFactory实现类，调用它们的getExtension
for (ExtensionFactory factory : factories) {
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
public class SpiExtensionFactory implements ExtensionFactory {
@Override
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
//获取对应type的ExtensionLoader实例
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
if (!loader.getSupportedExtensions().isEmpty()) {
//获取适配器实现
return loader.getAdaptiveExtension();
}
}
return null;
}
}
public class SpringExtensionFactory implements ExtensionFactory {
private static final Logger logger = LoggerFactory.getLogger(SpringExtensionFactory.class);
private static final Set<ApplicationContext> CONTEXTS = new ConcurrentHashSet<ApplicationContext>();
public static void addApplicationContext(ApplicationContext context) {
CONTEXTS.add(context);
if (context instanceof ConfigurableApplicationContext) {
((ConfigurableApplicationContext) context).registerShutdownHook();
// see https://github.com/apache/dubbo/issues/7093
DubboShutdownHook.getDubboShutdownHook().unregister();
}
}
public static void removeApplicationContext(ApplicationContext context) {
CONTEXTS.remove(context);
}
public static Set<ApplicationContext> getContexts() {
return CONTEXTS;
}
// currently for test purpose
public static void clearContexts() {
CONTEXTS.clear();
}
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
//type必须是@SPI
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
return null;
}
//从Spring容器中获取Bean
for (ApplicationContext context : CONTEXTS) {
T bean = getOptionalBean(context, name, type);
if (bean != null) {
return bean;
}
}
//logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());
return null;
}
}
getAdaptiveExtension
先来看下整体的时序图，重点看createAdaptiveExtension，
createAdaptiveExtension方法内部有个核心的方法getAdaptiveExtensionClass，关于这个方法我们可以看到分成两步，一个种是通过getExtensionClasses加载，另外一种通过编译器生成代码；
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
private Class<?> getAdaptiveExtensionClass() {
//获取所有的扩展类
getExtensionClasses();
//如果可以适配
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
//如果没有适配扩展类就创建
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
getExtensionClasses
首先来看下getExtensionClasses方法，该方法获取所有的扩展类，主要是通过调用loadExtensionClasses来实现的，根据扩展名从 cachedClasses 缓存中获取扩展实现类。如果 cachedClasses 未初始化，则会扫描 SPI 目录获取查找相应的 SPI 配置文件，然后加载其中的扩展实现类，最后将扩展名和扩展实现类的映射关系记录到 cachedClasses 缓存中。 在Dubbo中按照SPI配置文件的用途，将其分成了三类目录。 ● META-INF/services/ 目录：该目录下的 SPI 配置文件用来兼容 JDK SPI ; ● META-INF/dubbo/ 目录：该目录用于存放用户自定义 SPI 配置文件; ● META-INF/dubbo/internal/ 目录：该目录用于存放 Dubbo 内部使用的 SPI 配置文件;
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从配置文件中加载扩展类信息，cacheDefaultExtensionName逻辑是在把SPI注解中的默认值放到缓存中去，loadDirectory从一个配置文件中扩展类信息；这里介绍一下Loading这个对象，该对象有是三个默认实现，采用的是Java SPI方式加载，同时都继承了Prioritized优先级接口，整体的继承图如下:
此处三个对象也对应了加载的目录的地址：
private Map<String, Class<?>> loadExtensionClasses() {
//缓存@SPI组件信息
cacheDefaultExtensionName();
Map<String, Class<?>> extensionClasses = new HashMap<>();
//加载 META-INF/dubbo/internal META-INF/dubbo META-INF/services/
//对应目录下的配置信息
for (LoadingStrategy strategy : strategies) {
loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(),
strategy.overridden(), strategy.excludedPackages());
loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"),
strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
}
return extensionClasses;
}
private void cacheDefaultExtensionName() {
//获取注解SPI接口
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation == null) {
return;
}
//如果存在默认值 将值赋值给cachedDefaultName
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
//@SPI value 只能是一个 此处相当于在进行参数校验
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];
}
}
}
loadResource
loadResource加载配置文件中的内容，主要的逻辑就是跳过“#”注释的内容，根据配置文件中的key=value的形式去分割，然后去加载value通过反射加载类，然后调用 loadClass 方法进行操作缓存。
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
java.net.URL resourceURL, boolean overridden, String... excludedPackages) {
try {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
String line;
String clazz = 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和实现类
name = line.substring(0, i).trim();
clazz = line.substring(i + 1).trim();
} else {
clazz = line;
}
if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)) {
//加载扩展类
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);
}
}
loadClass 方法操作了不同的缓存，比如 cachedAdaptiveClass、cachedWrapperClasses 和 cachedNames 等等。
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)) {
cacheAdaptiveClass(clazz, overridden);
//是否是扩展类，是的话就加入 cachedWrapperClasses 属性
} else if (isWrapperClass(clazz)) {
cacheWrapperClass(clazz);
} else {
//检测是否有默认构造起
clazz.getConstructor();
if (StringUtils.isEmpty(name)) {
//未配置扩展名，自动生成，主要用于兼容java SPI的配置。
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)) {
//如果是自动激活的实现类，则加入到缓存
cacheActivateClass(clazz, names[0]);
for (String n : names) {
//存储Class到名字的映射关系
cacheName(clazz, n);
//存储名字到Class的映射关系
saveInExtensionClass(extensionClasses, clazz, n, overridden);
}
}
}
}
getExtension
接下来我们看下getExtension方法，该方法入参是配置文件的key，name是cat，如果name为true，返回getDefaultExtension()， 对于Holder只是用来存放对象，cachedInstances用来存放对象的缓存，缓存了 ExtensionLoader 加载的扩展名与扩展实现对象之间的映射关系；当holder中没有存在对象的时候，采用双重锁检查机制，通过createExtension创建扩展类，并放入Holder对象中；
@SuppressWarnings("unchecked")
public T getExtension(String name) {
return getExtension(name, true);
}
public T getExtension(String name, boolean wrap) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
if ("true".equals(name)) {
//获取默认扩展类实现
return getDefaultExtension();
}
//获取目标对象
final Holder<Object> holder = getOrCreateHolder(name);
Object instance = holder.get();
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
//创建扩展类
instance = createExtension(name, wrap);
holder.set(instance);
}
}
}
return (T) instance;
}
private Holder<Object> getOrCreateHolder(String name) {
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
//如果name对应的Holder对象为null 就创建一个空Holder对象
cachedInstances.putIfAbsent(name, new Holder<>());
holder = cachedInstances.get(name);
}
return holder;
}
createExtension
接下来我们看下createExtension，该方法完成了 SPI 配置文件的查找以及相应扩展实现类的实例化，同时还实现了自动装配以及自动 Wrapper 包装等功能。核心功能大致上可以分为5个步骤:
通过 getExtensionClasses 获取所有扩展类，然后根据扩展名从 cachedClasses 缓存中获取扩展实现类。如果 cachedClasses 未初始化，则会扫描前面介绍的三个 SPI 目录获取查找相应的 SPI 配置文件，然后加载其中的扩展实现类，最后将扩展名和扩展实现类的映射关系记录到 cachedClasses 缓存中； 根据扩展实现类从 EXTENSION_INSTANCES 缓存中查找相应的实例。如果没有查询到，通过反射创建扩展实现对象； 对扩展对象采用自动装配扩展实现对象中的属性，也就是我们说的IOC； 判断扩展对象是否是包装类，将扩展对象包裹进对应的 Wrapper 对象中； 如果扩展实现类实现了 Lifecycle 接口，在 initExtension() 方法中会调用 initialize() 方法进行初始化；
private T createExtension(String name, boolean wrap) {
//从配置文件中加载所有扩展类，形成配置项名称与配置类的映射关系
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null || unacceptableExceptions.contains(name)) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
//采用反射创建对应实例
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
//向对象中注入依赖的属性 IOC自动装配
injectExtension(instance);
if (wrap) {
//创建Wrapper扩展对象
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);
if (wrapper == null
|| (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
//将当前instance作为参数创建wrapper实例，然后向wrapper实例中注入属性值
//并将wrapper实例赋值给instance
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
}
}
//Lifecycle初始化
initExtension(instance);
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}
至此就完成类加载加载以及初始化的整个过程，此处主要理解Dubbo如何将类加载的整个过程，整个过程中使用策略模式、适配器模式应用都是值得我们学习的，其中createAdaptiveExtensionClass方法没有进行介绍，这部分我们放到@Adaptive注解的介绍。
injectExtension(Dubbo IOC)
injectExtension就是Dubbo IOC的体现，主要是通过 setter 方法实现依赖注入。步骤就是获取实例的所有方法，在遍历的过程中看看是否名字有 setter 字段。如果有就通过 ObjectFactory 获取依赖对象，然后通过反射调用 setter 方法将依赖设置到目标对象当中。简单来说，自动装配属性就是在加载一个扩展点的时候，将其依赖的扩展点一并加载，并进行装配。
private T injectExtension(T instance) {
//如果为空直接返回
if (objectFactory == null) {
return instance;
}
try {
//反射获取所有方法
for (Method method : instance.getClass().getMethods()) {
//如果是不是set方法跳过
if (!isSetter(method)) {
continue;
}
//如果有 @DisableInject 注解的化就不会进行注入
if (method.getAnnotation(DisableInject.class) != null) {
continue;
}
Class<?> pt = method.getParameterTypes()[0];
if (ReflectUtils.isPrimitives(pt)) {
continue;
}
try {
//根据setter方法的名称确定属性名称
String property = getSetterProperty(method);
//加载并实例化扩展实现
Object object = objectFactory.getExtension(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;
}
结束
从四月之后就比较少更新公众号，原因是处理一些生活上的事，完成了今年生活上一个重要的目标，从该篇文章开始恢复每周一更，后续文章分享的规划应该会从三个方面:
Java框架方面的内容，Dubbo源码以及Netty部分内容解读，Netty后续会做一个小小的项目； 准备刷刷算法相关内容，计划采用Go语言来刷算法； 云原生技术持续关注与学习，分享istio相关内容； 欢迎大家点点关注，点点赞!
标签：Dubbo,name,扩展,SPI,机制,null,type,加载 来源： https://www.cnblogs.com/wtzbk/p/16618487.html