Springboot @Import 详解

/**

  * indicates one or more {@link configuration @configuration} classes to import.

  *

  * <p>provides functionality equivalent to the {@code <import/>} element in spring xml.

  * allows for importing {@code @configuration} classes, {@link importselector} and

  * {@link importbeandefinitionregistrar} implementations, as well as regular component

  * classes (as of 4.2; analogous to {@link annotationconfigapplicationcontext#register}).

  *

  * <p>{@code @bean} definitions declared in imported {@code @configuration} classes should be

  * accessed by using {@link org.springframework.beans.factory.annotation.autowired @autowired}

  * injection. either the bean itself can be autowired, or the configuration class instance

  * declaring the bean can be autowired. the latter approach allows for explicit, ide-friendly

  * navigation between {@code @configuration} class methods.

  *

  * <p>may be declared at the class level or as a meta-annotation.

  *

  * <p>if xml or other non-{@code @configuration} bean definition resources need to be

  * imported, use the {@link importresource @importresource} annotation instead.

  *

  * @author chris beams

  * @author juergen hoeller

  * @since 3.0

  * @see configuration

  * @see importselector

  * @see importresource

  */

@target (elementtype.type)

@retention (retentionpolicy.runtime)

@documented

public @interface import {

   /**

    * {@link configuration}, {@link importselector}, {@link importbeandefinitionregistrar}

    * or regular component classes to import.

    */

   class <?>[] value();

}

/**

  * interface to be implemented by types that determine which @{@link configuration}

  * class(es) should be imported based on a given selection criteria, usually one or more

  * annotation attributes.

  *

  * <p>an {@link importselector} may implement any of the following

  * {@link org.springframework.beans.factory.aware aware} interfaces, and their respective

  * methods will be called prior to {@link #selectimports}:

  * <ul>

  * <li>{@link org.springframework.context.environmentaware environmentaware}</li>

  * <li>{@link org.springframework.beans.factory.beanfactoryaware beanfactoryaware}</li>

  * <li>{@link org.springframework.beans.factory.beanclassloaderaware beanclassloaderaware}</li>

  * <li>{@link org.springframework.context.resourceloaderaware resourceloaderaware}</li>

  * </ul>

  *

  * <p>importselectors are usually processed in the same way as regular {@code @import}

  * annotations, however, it is also possible to defer selection of imports until all

  * {@code @configuration} classes have been processed (see {@link deferredimportselector}

  * for details).

  *

  * @author chris beams

  * @since 3.1

  * @see deferredimportselector

  * @see import

  * @see importbeandefinitionregistrar

  * @see configuration

  */

public interface importselector {

   /**

    * select and return the names of which class(es) should be imported based on

    * the {@link annotationmetadata} of the importing @{@link configuration} class.

    */

   string[] selectimports(annotationmetadata importingclassmetadata);

}

// parse each @configuration class

     configurationclassparser parser = new configurationclassparser(

         this .metadatareaderfactory, this .problemreporter, this .environment,

         this .resourceloader, this 测试数据ponentscanbeannamegenerator, registry);

// process any @import annotations

     processimports(configclass, sourceclass, getimports(sourceclass), true );

private void processimports(configurationclass configclass, sourceclass currentsourceclass,

       collection<sourceclass> 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) {

           if (candidate.isassignable(importselector. class )) {

             // candidate class is an importselector -> delegate to it to determine imports

             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<sourceclass> importsourceclasses = assourceclasses(importclassnames);

               processimports(configclass, currentsourceclass, importsourceclasses, false );

             }

           }

           else if (candidate.isassignable(importbeandefinitionregistrar. class )) {

             // candidate class is an importbeandefinitionregistrar ->

             // delegate to it to register additional bean definitions

             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 {

             // candidate class not an importselector or importbeandefinitionregistrar ->

             // process it as an @configuration class

             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();

       }

     }

   }