同胞兄弟,ImportSelector接口与DeferredImportSelector接口的区别

一、前言

上一篇博客【Spring源码解析 011 Spring处理Imports注解】知道,在使用@Import注解来注册bean的时候,Import注解的值可以是ImportSelector或者DeferredImportSelector的实现类spring容器会实例化这个实现类,并执行其selectImports方法

这篇博客的问题是:ImportSelector和DeferredImportSelector的区别在哪里,我们自定义Imort逻辑的时候该选择哪个呢?本文通过分析相关的spring源码来查找答案;

本文接口:

  1. ImportSelector和DeferredImportSelector的区别;
  2. 分析spring源码中对这两个接口的处理;

二、ImportSelector和DeferredImportSelector的区别

  1. DeferredImportSelector接口是ImportSelector接口的一个扩展;
  2. ImportSelector实例的selectImports方法的执行时机,是在@Configguration注解中的其他逻辑被处理之前,所谓的其他逻辑,包括对@ImportResource、@Bean这些注解的处理(注意,这里只是对@Bean修饰的方法的处理,并不是立即调用@Bean修饰的方法,这个区别很重要!);
  3. DeferredImportSelector实例的selectImports方法的执行时机,是在@Configguration注解中的其他逻辑被处理完毕之后,所谓的其他逻辑,包括对@ImportResource、@Bean这些注解的处理;
  4. DeferredImportSelector的实现类可以用Order注解,或者实现Ordered接口来对selectImports的执行顺序排序;

三、分析spring源码中对这两个接口的处理

3.1 ConfigurationClassParser类的方法parse()

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        this.deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();
        //检查每个bean的定义
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    //对于每个有注解的类,都执行方法parse(AnnotationMetadata metadata, String beanName)
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());   // parse方法,两个参数
                }
                else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());   // parse方法,两个参数
                }
                else {
                    parse(bd.getBeanClassName(), holder.getBeanName());   // parse方法,两个参数
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Exception ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            }
        }

        //最后再处理DeferredImportSelector的实现类   要进去看看
        processDeferredImportSelectors();
    }

由以上代码可以大致看出DeferredImportSelector的实现类被最后放在processDeferredImportSelectors方法中处理,那么前面的parse(AnnotationMetadata metadata, String beanName)做了些什么呢?继续看;

3.2 parse()方法调用processConfigurationClass()方法

展开方法parse(AnnotationMetadata metadata, String beanName)里面,是执行processConfigurationClass方法;

3.3 processConfigurationClass()方法调用doProcessConfigurationClass()方法

再展开processConfigurationClass方法,看到核心逻辑是调用doProcessConfigurationClass方法,展开看看:

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
        //为了聚焦Import相关处理,此处略去部分不相关代码,不在这里展示了
        ...
        ...
        // 处理@Import注解  1、 要进去里面看具体逻辑 processImports()
        processImports(configClass, sourceClass, getImports(sourceClass), true);

        // 处理@ImportResource注解
        if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
            AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
            String[] resources = importResource.getStringArray("value");
            Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            for (String resource : resources) {
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }

        // 处理@Bean注解,注意是处理注解,不是执行@Bean修饰的方法
        Set<MethodMetadata> beanMethods = sourceClass.getMetadata().getAnnotatedMethods(Bean.class.getName());
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // 处理Configuration类的父类,外面在调用doProcessConfigurationClass方法的时有迭代处理,确保所有父类的注解都会被处理
        if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
                this.knownSuperclasses.put(superclass, configClass);
                // Superclass found, return its annotation metadata and recurse
                return sourceClass.getSuperClass();
            }
        }

        // 再也没有父类了,返回null表示当前Configuration处理完毕
        return null;
    }

根据doProcessConfigurationClass(),可以梳理出下图中的逻辑:

在这里插入图片描述

现在需要再看看processImports和processDeferredImportSelectors这两个方法的具体代码;

3.4 源码解析:processImports()

先看processImports方法:

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
            Collection<SourceClass> importCandidates, boolean checkForCircularImports) throws IOException {

        if (importCandidates.isEmpty()) {
            return;
        }

        if (checkForCircularImports && this.importStack.contains(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
        }
        else {
            this.importStack.push(configClass);
            try {
                for (SourceClass candidate : importCandidates) {
                    //如果是ImportSelector接口的实现类,就在此处理
                    if (candidate.isAssignable(ImportSelector.class)) {
                        // Candidate class is an ImportSelector -> delegate to it to determine imports
                        Class<?> candidateClass = candidate.loadClass();
                        //实例化这些ImportSelector的实现类
                        ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                        //如果这实现类还实现了BeanFactoryAware、EnvironmentAware这些接口,就要先执行这些接口中声明的方法
                        invokeAwareMethods(selector);
                        //如果这个实现类也实现了DeferredImportSelector接口,就被加入到集合deferredImportSelectors中
                        if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
                            this.deferredImportSelectors.add(
                                    new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
                        }
                        else {
                            //注意,这一行是关键代码!!!执行实现类的selectImports方法
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                            processImports(configClass, currentSourceClass, importSourceClasses, false);
                        }
                    }
                    //此处略去的和ImportSelector不相关的逻辑代码
                    ...
                    ...
                    ...
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Exception ex) {
                throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" +
                        configClass.getMetadata().getClassName() + "]", ex);
            }
            finally {
                this.importStack.pop();
            }
        }
    }

以上代码有两个关键点:(因为)
第一、当前被处理的类,如果实现了DeferredImportSelector接口,就被加入到集合deferredImportSelectors中,还没有处理;
第二、当前被处理的类,如果没有实现DeferredImportSelector接口,但是实现了ImportSelector接口,就立即处理,就被执行selectImports方法;

金手指1:因为DeferredImportSelector接口是ImportSelector接口的子接口,所有判断逻辑在ImportSelector接口的if判断的里面
(1)当前被处理的类,如果实现了DeferredImportSelector接口,就被加入到集合deferredImportSelectors中,还没有处理;
(2)当前被处理的类,如果没有实现DeferredImportSelector接口,但是实现了ImportSelector接口,就立即处理,就被执行selectImports方法;
金手指2:processImports()方法中执行selectImports()方法的位置,找到selectImports()方法执行的位置就好了。
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
ImportBeanDefinitionRegistrar的处理
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
普通类
在这里插入图片描述

3.5 源码解析:processDeferredImportSelectors()

接下来看看processDeferredImportSelectors方法的源码,提前推测应该是处理集合deferredImportSelectors中的所有类,这些类都实现了DeferredImportSelector接口:

private void processDeferredImportSelectors() {
        List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
        this.deferredImportSelectors = null;
        //按照Order注解或者Ordered接口进行排序
        Collections.sort(deferredImports, DEFERRED_IMPORT_COMPARATOR);

        for (DeferredImportSelectorHolder deferredImport : deferredImports) {
            ConfigurationClass configClass = deferredImport.getConfigurationClass();
            try {
                //此处是关键代码,执行DeferredImportSelector实现类的selectImports方法
                String[] imports = deferredImport.getImportSelector().selectImports(configClass.getMetadata());
                processImports(configClass, asSourceClass(configClass), asSourceClasses(imports), false);
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Exception ex) {
                throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" +
                        configClass.getMetadata().getClassName() + "]", ex);
            }
        }
    }

至此,源码分析完毕了,从代码可以很清晰的看出ImportSelector与DeferredImportSelector的区别,就是selectImports方法执行时机有差别,这个差别期间,spring容器对此Configguration类做了些其他的逻辑:包括对@ImportResource、@Bean这些注解的处理(注意,这里只是对@Bean修饰的方法的处理,并不是立即调用@Bean修饰的方法,这个区别很重要!);

四、面试金手指(ImportSelector和DeferredImportSelector的区别)

  1. DeferredImportSelector接口是ImportSelector接口的一个扩展;
  2. ImportSelector实例的selectImports方法的执行时机,是在@Configguration注解中的其他逻辑被处理之前,所谓的其他逻辑,包括对@ImportResource、@Bean这些注解的处理(注意,这里只是对@Bean修饰的方法的处理,并不是立即调用@Bean修饰的方法,这个区别很重要!);
  3. DeferredImportSelector实例的selectImports方法的执行时机,是在@Configguration注解中的其他逻辑被处理完毕之后,所谓的其他逻辑,包括对@ImportResource、@Bean这些注解的处理;
  4. DeferredImportSelector的实现类可以用Order注解,或者实现Ordered接口来对selectImports的执行顺序排序;

根据doProcessConfigurationClass(),可以梳理出下图中的逻辑:

在这里插入图片描述

ImportSelector与DeferredImportSelector的区别,就是selectImports方法执行时机有差别,这个差别期间,spring容器对此Configguration类做了些其他的逻辑:包括对@ImportResource、@Bean这些注解的处理(注意,这里只是对@Bean修饰的方法的处理,并不是立即调用@Bean修饰的方法,这个区别很重要!);

五、小结

ImportSelector接口与DeferredImportSelector接口的区别,好了。

天天打码,天天进步!!!

相关推荐
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页
实付 29.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值