@import注解_Spring源码解析之@Import注解源码解析

Spring 3.0之前，创建Bean可以通过xml配置文件与扫描特定包下面的类来将类注入到Spring IOC容器内。而在Spring 3.0之后提供了JavaConfig的方式，也就是将IOC容器里Bean的元信息以java代码的方式进行描述。我们可以通过@Configuration与@Bean这两个注解配合使用来将原来配置在xml文件里的bean通过java代码的方式进行描述

@Import注解提供了@Bean注解的功能，同时还有xml配置文件里标签组织多个分散的xml文件的功能，当然在这里是组织多个分散的@Configuration

先看一下@Import注解的源码：

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Import {    /**{@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}or regular component classes to import.Class>[] value();}

从源码里可以看出@Import可以配合 Configuration ,ImportSelector, ImportBeanDefinitionRegistrar 来使用，下面的or表示也可以把Import当成普通的Bean使用 @Import只允许放到类上面，不能放到方法上。下面我们来看具体的使用方式

普通使用方法

这种方式可以直接把类加入到Spring IOC容器

@Configuration@Import(value={UserServiceImpl.class})public class Config {}

但是这种方式有一些问题，那就是只能使用类的无参构造方法来创建bean，对于有参数的构造方法就无能为力了

结合ImportBeanDefinitionRegistrar接口

ImportBeanDefinitionRegistrar接口的源码如下：

public interface ImportBeanDefinitionRegistrar {    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);     }

可以看到这个接口唯一的方法是有两个参数的

AnnotationMetadata：通过这个参数可以拿到类的元数据信息 BeanDefinitionRegistry：通过这个参数可以操作IOC容器 我们可以使用一个类来实现这个接口

public class UserServiceBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {      public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,BeanDefinitionRegistry registry) {        BeanDefinitionBuilder userService = BeanDefinitionBuilder.rootBeanDefinition(UserServiceImpl.class);        registry.registerBeanDefinition("userService", userService.getBeanDefinition());    }}

可以看到我们在这个方法里面做一些特殊操作什么的都是可以的，相比较于普通的方式可是灵活了很多

接着我们在@Import注解引入的地方只需要修改为引入UserServiceBeanDefinitionRegistrar就可以了

@Configuration@Import(value={UserServiceBeanDefinitionRegistrar.class})public class Config {}

结合ImportSelector接口

相比较与实现ImportBeanDefinitionRegistrar接口之后直接操作Bean容器来说，使用ImportSelector会更加优雅一些，只需要返回需要注入类的全限定名就可以了

ImportSelector接口的源码如下：

public interface ImportSelector {    String[] selectImports(AnnotationMetadata importingClassMetadata);}

public class UserServiceImportSelect implements ImportSelector{    public String[] selectImports(AnnotationMetadata importingClassMetadata) {               return new String[]{UserServiceImpl.class.getName()};    }}

@Configuration()@Import(value={UserServiceImportSelect.class})public class Config {}

相比较三种方式来说可以看到最后这种才是最优雅的方式

源码解析

首先我们就以第三种比较优雅的方式出发，使用Call Hierarchy看一下ImportSelector接口的selectImports方法调用链关系：

看过之前Spring源码解析文章的同学都知道，refresh方法是用来初始化容器上下文的。跟着这个调用链走下来到中间有一个类是ConfigurationClassPostProcessor，根据类名我们就可以猜到这个类应该是处理配置类(也就是标注@Configuration)的。那么从这开始看吧

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {    List configCandidates = new ArrayList();    String[] candidateNames = registry.getBeanDefinitionNames();    for (String beanName : candidateNames) {        BeanDefinition beanDef = registry.getBeanDefinition(beanName);             if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {            if (logger.isDebugEnabled()) {                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);            }        }       //查看是否是配置类        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));        }    }    //如果没有配置类就直接返回    if (configCandidates.isEmpty()) {        return;    }        //对这些配置类根据Order排序    Collections.sort(configCandidates, new Comparator() {        @Override        public int compare(BeanDefinitionHolder bd1, BeanDefinitionHolder bd2) {            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());            return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;        }    });        SingletonBeanRegistry sbr = null;    if (registry instanceof SingletonBeanRegistry) {        sbr = (SingletonBeanRegistry) registry;        if (!this.localBeanNameGeneratorSet && sbr.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);            this.componentScanBeanNameGenerator = generator;            this.importBeanNameGenerator = generator;        }    }             //创建配置类的解析类    ConfigurationClassParser parser = new ConfigurationClassParser(            this.metadataReaderFactory, this.problemReporter, this.environment,            this.resourceLoader, this.componentScanBeanNameGenerator, registry);        Set candidates = new LinkedHashSet(configCandidates);    Set alreadyParsed = new HashSet(configCandidates.size());    do {       //ConfigurationClassParser的parse方法进行解析，重点哈        parser.parse(candidates);        parser.validate();        Set configClasses = new LinkedHashSet(parser.getConfigurationClasses());        configClasses.removeAll(alreadyParsed);            // Read the model and create bean definitions based on its content        if (this.reader == null) {            this.reader = new ConfigurationClassBeanDefinitionReader(                    registry, this.sourceExtractor, this.resourceLoader, this.environment,                    this.importBeanNameGenerator, parser.getImportRegistry());        }        this.reader.loadBeanDefinitions(configClasses);        alreadyParsed.addAll(configClasses);            candidates.clear();        if (registry.getBeanDefinitionCount() > candidateNames.length) {            String[] newCandidateNames = registry.getBeanDefinitionNames();            Set oldCandidateNames = new HashSet(Arrays.asList(candidateNames));            Set alreadyParsedClasses = new HashSet();            for (ConfigurationClass configurationClass : alreadyParsed) {                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());            }            for (String candidateName : newCandidateNames) {                if (!oldCandidateNames.contains(candidateName)) {                    BeanDefinition bd = registry.getBeanDefinition(candidateName);                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {                        candidates.add(new BeanDefinitionHolder(bd, candidateName));                    }                }            }            candidateNames = newCandidateNames;        }    }    while (!candidates.isEmpty());        if (sbr != null) {        if (!sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());        }    }        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();    }}

现在该进入ConfigurationClassParser类了

public void parse(Set configCandidates) {    this.deferredImportSelectors = new LinkedList();        for (BeanDefinitionHolder holder : configCandidates) {        BeanDefinition bd = holder.getBeanDefinition();        try {            if (bd instanceof AnnotatedBeanDefinition) {                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());            }            else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());            }            else {                parse(bd.getBeanClassName(), holder.getBeanName());            }        }        catch (BeanDefinitionStoreException ex) {            throw ex;        }        catch (Throwable ex) {            throw new BeanDefinitionStoreException(                    "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);        }    }        processDeferredImportSelectors();}

//下面三种方法用于处理不同的BeanDefinition 类型，但最终都是使用的processConfigurationClass方法

protected final void parse(String className, String beanName) throws IOException {    MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);    processConfigurationClass(new ConfigurationClass(reader, beanName));}protected final void parse(Class> clazz, String beanName) throws IOException {    processConfigurationClass(new ConfigurationClass(clazz, beanName));}protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {    processConfigurationClass(new ConfigurationClass(metadata, beanName));}

可以看到配置类可能会是三种形式的存在，这三种形式的Bean在操作上有着部分不一样，但是大部分又是一样，所以Spring用这种模式来处理。不得不感叹人家设计的真好

接着往下看

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {        return;    }    ConfigurationClass existingClass = this.configurationClasses.get(configClass);    //在这里处理Configuration重复import    //如果同一个配置类被处理两次，两次都属于被import的则合并导入类，返回。如果配置类不是被导入的，则移除旧使用新的配置类    if (existingClass != null) {        if (configClass.isImported()) {            if (existingClass.isImported()) {                existingClass.mergeImportedBy(configClass);            }            return;        }        else {            this.configurationClasses.remove(configClass);            for (Iterator it = this.knownSuperclasses.values().iterator(); it.hasNext();) {                if (configClass.equals(it.next())) {                    it.remove();                }            }        }    }        SourceClass sourceClass = asSourceClass(configClass);    do {      //接着往下看吧        sourceClass = doProcessConfigurationClass(configClass, sourceClass);    }    while (sourceClass != null);        this.configurationClasses.put(configClass, configClass);}

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)        throws IOException {    // 处理递归类    processMemberClasses(configClass, sourceClass);        // 处理@PropertySource注解    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(            sourceClass.getMetadata(), PropertySources.class,            org.springframework.context.annotation.PropertySource.class)) {        if (this.environment instanceof ConfigurableEnvironment) {            processPropertySource(propertySource);        }        else {            logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +                    "]. Reason: Environment must implement ConfigurableEnvironment");        }    }        // 处理 @ComponentScan 注解    Set componentScans = AnnotationConfigUtils.attributesForRepeatable(            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);    if (!componentScans.isEmpty() &&            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {        for (AnnotationAttributes componentScan : componentScans) {            // The config class is annotated with @ComponentScan -> perform the scan immediately            Set scannedBeanDefinitions =                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());            // Check the set of scanned definitions for any further config classes and parse recursively if needed            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();                if (bdCand == null) {                    bdCand = holder.getBeanDefinition();                }                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {                    parse(bdCand.getBeanClassName(), holder.getBeanName());                }            }        }    }    //处理Import注解，这个是咱们的菜    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("locations");        Class extends BeanDefinitionReader> readerClass = importResource.getClass("reader");        for (String resource : resources) {            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);            configClass.addImportedResource(resolvedResource, readerClass);        }    }        //处理包含@Bean注解的方法    Set beanMethods = retrieveBeanMethodMetadata(sourceClass);    for (MethodMetadata methodMetadata : beanMethods) {        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));    }        // 处理普通方法    processInterfaces(configClass, sourceClass);       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();        }    }        return null;}

看到这里好像突然发现了新大陆呀，原来我们经常见的@Bean、@ImportResource 、@Import、@ComponentScan、@PropertySource都是在这里处理的呀

咱们的重点还是放在@Import上，对其他几个注解感兴趣的同学可以自行研究一下

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,        Collection importCandidates, boolean checkForCircularImports) {    if (importCandidates.isEmpty()) {        return;    }        if (checkForCircularImports && isChainedImportOnStack(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)) {                    Class> candidateClass = candidate.loadClass();                    ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);                    ParserStrategyUtils.invokeAwareMethods(                            selector, this.environment, this.resourceLoader, this.registry);                    if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {                        this.deferredImportSelectors.add(                                new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));                    }                    else {                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());                        Collection importSourceClasses = asSourceClasses(importClassNames);                        processImports(configClass, currentSourceClass, importSourceClasses, false);                    }                }                //如果实现了ImportBeanDefinitionRegistrar接口                else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {                    Class> candidateClass = candidate.loadClass();                    ImportBeanDefinitionRegistrar registrar =                            BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);                    ParserStrategyUtils.invokeAwareMethods(                            registrar, this.environment, this.resourceLoader, this.registry);                    configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());                }                else {                     //将import当成Configuration来使用就是我们的第一种应用的方式                    this.importStack.registerImport(                            currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());                    processConfigurationClass(candidate.asConfigClass(configClass));                }            }        }        catch (BeanDefinitionStoreException ex) {            throw ex;        }        catch (Throwable ex) {            throw new BeanDefinitionStoreException(                    "Failed to process import candidates for configuration class [" +                    configClass.getMetadata().getClassName() + "]", ex);        }        finally {            this.importStack.pop();        }    }}

至此@import 源码阅读完毕