springboot 的starter原理及自定义starter

springboot 的starter原理及自定义starter

1. starter原理

1.1 @Enable*注解

• Spring-boot 中提供了大量的@Enable* 的注解，用来开启某些功能，其底层是依赖@Import来实现的
• Spring-boot 启动时会描述@ComponentScan下的包，只要不在其下的类都不能创建bean。扩写@ComponentScan代码不美观
• 也可以用@Import用解决第二点中提到的问题，但@Import(“类名”)需要记住要引入的类名
• 当我们作为组件的提供者时，可以用@Enable* 对@Import进行封装。用户只要记住一个注解就能开启相应的功能

1.1.1 示例

• 定义一个project:lab-starter，分别有两个子模块user-starter，user-comsumer

• user-starter中定义UserConfig，用于向ioc容器注入User

 package com.userLab.config;
 
 import com.userLab.pojo.User;
 import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Component;
 
 /**
  * 用户配置类
  *
  * @author 杨秋颐 wyuyangqy@163.com
  * @since 2021-12-14 22:38
  */
 @Component
 public class UserConfig {
 
     @Bean
     public User user(){
         return new User();
     }
 }

• user-starter中定义@EnableUser注解，用@Import(UserConfig.class)使用户启动配置生效

    package com.userLab.anno;
    
    import com.userLab.config.UserConfig;
    import org.springframework.context.annotation.Import;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 启动用户注解
     *
     * @author 杨秋颐 wyuyangqy@163.com
     * @since 2021-12-14 22:40
     */
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(UserConfig.class)//使UserConfig配置生效
    public @interface EnableUser {
    
    }

• 在user-comsumer模块中引入user-starter

     <dependency>
         <groupId>com.lab</groupId>
         <artifactId>user-starter</artifactId>
         <version>1.0-SNAPSHOT</version>
     </dependency>

• 在user-comsumer模块中编写springboot启动类

      package com.lab;
      
      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;
      import org.springframework.context.ConfigurableApplicationContext;
      
      /**
       * springboot启动类
       *
       * @author 杨秋颐 wyuyangqy@163.com
       * @since 2021-12-14 22:35
       */
      @SpringBootApplication
      //@EnableUser
      public class UserComsumerApplication {
          public static void main(String[] args) {
              ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
              Object user = context.getBean("user");
              System.out.println("user = " + user);
          }
      }

• 运行，没有用@EnableUser注解，报错。在ioc容器没有user类。使用@EnableUser，则在ioc容器找到user。因为启动类在com.lab包下，面UserConfig类在com.userLab下。spring默认扫描启动类所在包及其子包

1.2 @Import注解

• 查看@Import的源码

  /*
   * Copyright 2002-2016 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.springframework.context.annotation;
  
  import java.lang.annotation.Documented;
  import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;
  
  /**
   * 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();
  
  }

• 可知@Import()里可以使用bean,Configuration,ImportSelector,ImportBeanDefinitionRegistra。这就是@Import的四种用法

1.2.2 @Import四种用法

• 1. 导入bean，使用刚才的启动类，修改一下获取bean的方法

  package com.lab;
  
  import com.userLab.pojo.User;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.context.ConfigurableApplicationContext;
  import org.springframework.context.annotation.Import;
  
  /**
   * springboot启动类
   *
   * @author 杨秋颐 wyuyangqy@163.com
   * @since 2021-12-14 22:35
   */
  @SpringBootApplication
  //@EnableUser
  @Import(User.class)
  public class UserComsumerApplication {
      public static void main(String[] args) {
          ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
          //使用类型获取用户
          User user = context.getBean(User.class);
          System.out.println("user = " + user);
      }
  }

启动，能正常在ioc容器中获取到user

• 2. 导入配置类，同样使用刚才的启动类

 package com.lab;
 
 import com.userLab.config.UserConfig;
 import com.userLab.pojo.User;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Import;
 
 /**
  * springboot启动类
  *
  * @author 杨秋颐 wyuyangqy@163.com
  * @since 2021-12-14 22:35
  */
 @SpringBootApplication
 //@EnableUser
 @Import(UserConfig.class)
 public class UserComsumerApplication {
     public static void main(String[] args) {
         ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
         //使用类型获取用户
         User user = context.getBean(User.class);
         System.out.println("user = " + user);
     }
 }

启动，能正常在ioc容器中获取到user

• 3. 导入，ImportSelector子类，与导入bean不同的是：ImportSelector子类是批量。查看ImportSelector接口

    /*
     * Copyright 2002-2013 the original author or authors.
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      https://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package org.springframework.context.annotation;
    
    import org.springframework.core.type.AnnotationMetadata;
    
    /**
     * 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>{@code ImportSelector} implementations 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.
        * 入参：注解元对象
        * 返回的是一系列类名，都会被实例化到ioc容器
        */
       String[] selectImports(AnnotationMetadata importingClassMetadata);
    
    }

 示例：

• 编写一个类实现ImportSelector

       package com.userLab.config;
       
       import org.springframework.context.annotation.ImportSelector;
       import org.springframework.core.type.AnnotationMetadata;
       
       /**
        * 实例化配置类
        *
        * @author 杨秋颐 wyuyangqy@163.com
        * @since 2021-12-15 11:03
        */
       public class BeanImportSelector implements ImportSelector {
           @Override
           public String[] selectImports(AnnotationMetadata importingClassMetadata) {
               // 实例化用户、角色类
               return new String[]{"com.userLab.pojo.User","com.userLab.pojo.Role"};
           }
       }

• 使用刚才的启动类测试

       package com.lab;
       
       import com.userLab.config.BeanImportSelector;
       import com.userLab.config.UserConfig;
       import com.userLab.pojo.Role;
       import com.userLab.pojo.User;
       import org.springframework.boot.SpringApplication;
       import org.springframework.boot.autoconfigure.SpringBootApplication;
       import org.springframework.context.ConfigurableApplicationContext;
       import org.springframework.context.annotation.Import;
       
       /**
        * springboot启动类
        *
        * @author 杨秋颐 wyuyangqy@163.com
        * @since 2021-12-14 22:35
        */
       @SpringBootApplication
       //@EnableUser
       @Import(BeanImportSelector.class)
       public class UserComsumerApplication {
           public static void main(String[] args) {
               ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
               //使用类型获取用户
               User user = context.getBean(User.class);
               System.out.println("user = " + user);
               //使用类型获取角色
               Role role = context.getBean(Role.class);
               System.out.println("role = " + role);
           }
       }

   启动，正常获取到ioc中的用户类及角色类

• 4. 导入ImportBeanDefinitionRegistrar 子类，通过注册器把bean放入到容器中
  • 编写一个ImportBeanDefinitionRegistrar的实现类

            package com.userLab.config;
            
            import com.userLab.pojo.Role;
            import com.userLab.pojo.User;
            import org.springframework.beans.factory.support.AbstractBeanDefinition;
            import org.springframework.beans.factory.support.BeanDefinitionBuilder;
            import org.springframework.beans.factory.support.BeanDefinitionRegistry;
            import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
            import org.springframework.core.type.AnnotationMetadata;
            
            /**
             * 对象实例化注册器
             *
             * @author 杨秋颐 wyuyangqy@163.com
             * @since 2021-12-15 11:17
             */
            public class BeanImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
                @Override
                public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
                    // 能过BeanDefinitionBuilder 获取 beanDefinition
                    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(User.class).getBeanDefinition();
                    // 把user 注册到ioc容器中
                    registry.registerBeanDefinition("user",beanDefinition);
            
                    beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Role.class).getBeanDefinition();
                    // 把role 注册到ioc容器中
                    registry.registerBeanDefinition("role",beanDefinition);
                }
            }

• 使用启动类测试

            package com.lab;
            
            import com.userLab.config.BeanImportBeanDefinitionRegistrar;
            import com.userLab.config.BeanImportSelector;
            import com.userLab.config.UserConfig;
            import com.userLab.pojo.Role;
            import com.userLab.pojo.User;
            import org.springframework.boot.SpringApplication;
            import org.springframework.boot.autoconfigure.SpringBootApplication;
            import org.springframework.context.ConfigurableApplicationContext;
            import org.springframework.context.annotation.Import;
            
            /**
             * springboot启动类
             *
             * @author 杨秋颐 wyuyangqy@163.com
             * @since 2021-12-14 22:35
             */
            @SpringBootApplication
            //@EnableUser
            @Import(BeanImportBeanDefinitionRegistrar.class)
            public class UserComsumerApplication {
                public static void main(String[] args) {
                    ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
                    //使用类型获取用户
                    User user = context.getBean(User.class);
                    System.out.println("user = " + user);
                    //使用类型获取角色
                    Role role = context.getBean(Role.class);
                    System.out.println("role = " + role);
                }
            }

启动，正常获取到ioc中的用户类及角色类

1.3 @EnableAutoConfigure注解

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

可见用@@Import({AutoConfigurationImportSelector.class})，点击进入AutoConfigurationImportSelector.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.Aware;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.context.annotation.DeferredImportSelector.Group;
import org.springframework.context.annotation.DeferredImportSelector.Group.Entry;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    private static final AutoConfigurationImportSelector.AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationImportSelector.AutoConfigurationEntry();
    private static final String[] NO_IMPORTS = new String[0];
    private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
    private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
    private ConfigurableListableBeanFactory beanFactory;
    private Environment environment;
    private ClassLoader beanClassLoader;
    private ResourceLoader resourceLoader;

    public AutoConfigurationImportSelector() {
    }

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
          
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
          // 重点看下面这个方法
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
}

往后的方法跟进不在贴源码 getAutoConfigurationEntry -> getCandidateConfigurations -> loadFactoryNames -> getCandidateConfigurations -> loadSpringFactories -> classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :

而public static final String FACTORIES_RESOURCE_LOCATION = “META-INF/spring.factories”;

也就是说我们可以在META-INF/spring.factories配置文件中定义大量的自动配置类

• 我们可以在spring-boot-autoconfigure包中的 META-INF/spring.factories 看到spring已经整合了大量的自动配置
• 这些配置里又结合了Condition（可见《springboot Condition 详解》），用于决策是否加载对应的实体配置

1.4 spring.factories配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

能过以上key去定义相应的自动配置，多个时，以逗号隔开

2. 自定义starter

• 还是用刚才的例子，区别：我们这次不用在启动类上加任何@Enable注解，在我们引入自定义starter包时自动，创建用户类放入到容器中

2.1 代码实现

• 在user-starter的resources下添加META-INF文件夹

• 在META-INF下添加spring.factories文件

  # Auto Configure
  org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.userLab.config.UserConfig
  

• 在user-comsumer工程中，去掉启动类中之前添加的引入UserConfig的注解

  package com.lab;
  
  import com.userLab.pojo.Role;
  import com.userLab.pojo.User;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.context.ConfigurableApplicationContext;
  
  /**
   * springboot启动类
   *
   * @author 杨秋颐 wyuyangqy@163.com
   * @since 2021-12-14 22:35
   */
  @SpringBootApplication
  public class UserComsumerApplication {
      public static void main(String[] args) {
          ConfigurableApplicationContext context = SpringApplication.run(UserComsumerApplication.class, args);
          //使用类型获取用户
          User user = context.getBean(User.class);
          System.out.println("user = " + user);
          //使用类型获取角色
          Role role = context.getBean(Role.class);
          System.out.println("role = " + role);
      }
  }

启动，可见user自动注入到了ioc中，而role（没配置）没有

正常starter各级定义

• 定义 一个starter包，用于引入其它包，什么都不做（类似parent，用来做starter包里引入的包的版本管理，确保引入的包版本为最佳兼容）。其中引入了 我们另外定义 XXX-autoconfig
• XXX-autoconfig包内定义了spring.factories及自动配置类