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;
    }