springboot自动装配

平时经常用springboot，可是对其自动装配功能却不甚了解。
为什么application上开启@EnableAutoConfiguration注解就可以将很多类注入bean呢。下面我们来引入实际案例。使用方面的东西还是很有用处的。在实际讲解之前咱们先回想一下在spring中如何把一个第三方类注册到spring的。

1. xml 标签
2. @Configuration 使用@Bean注解
3. 通过@Component、@Service、通过@Component等类上的注解
4. 使用@Import导入外部类
5. 实现ImportSelector接口，return中定义注册的类
6. 实现ImportBeanDefinitionRegitrar接口，实现reciterBeanDefinitions接口直接把对象塞到ioc中
7. 实现FactoryBean，getObject()方法、getObjectType()、isSingleton()，并使用2中的@Configuration 使用@Bean注解
   具体的使用例子看我另一篇博客Spring注解编程

springboot其实就是对spring的高度封装。
下面来引入一个场景。
我们有两个系统A系统和B系统，其中A系统提供工具类给B系统使用，且包路径不一样，注入spring比较麻烦，那么有什么优雅的办法将需要的类注入spring吗。可以使用注解 + @Import+@Conditional来模拟springboot自动装配
然后看springboot的应用，实际上就是对spring的使用。
首先我们有两个配置类，需要打包给B系统

@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(){
        return new RedisTemplate();
    }
}

@Configuration
public class SqlSessionFactory {

    @Bean
    public SqlSessionFactory sqlSessionFactory(){
        return new SqlSessionFactoryBuilder().build();
    }
}

只是两个简单例子，并不是实际就注入他们。
编写一个ImportSelector类，需要实现ImportSelector接口
return中添加需要在spring中注册的类

public class DefineImportSelector implements ImportSelector{
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        //package.class.classname
        return new String[]{SqlSessionFactory.class.getName(), RedisConfiguration.class.getName()};
    }
}

可以直接在application上添加@Import(DefineImportSelector.class)进行注入，或者由A系统声明注解的方式，隐式添加

注解声明

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(GpDefineImportSelector.class)
public @interface EnableConfiguration {
}

在类中使用

@EnableConfiguration
@SpringBootApplication
public class SpringBootDemoApplication {

	public static void main(String[] args) {
		ConfigurableApplicationContext ca=SpringApplication.run(SpringBootDemoApplication.class, args);
	}
}

不过这种方式也有缺点，就是必须手动添加导入的类还要添加@Import注解，很不优雅，那么还有更优雅的方式吗？是不是也发现了。自己使用springboot的时候什么都没使用啊。就引入了包，就直接可以注入使用了。那么咱们一起看一下springboot的实现方式，还说上面的SpringBootDemoApplication为入口，进入注解内部

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

发现这里使用了@EnableAutoConfiguration，启用了自动配置
继续跟踪

@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})

那么看一下里面的实现吧，只截取主要方法

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;
    private AutoConfigurationImportSelector.ConfigurationClassFilter configurationClassFilter;

    public AutoConfigurationImportSelector() {
    }

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

首先，AutoConfigurationImportSelector类实现了DeferredImportSelector接口，而DeferredImportSelector接口继承了ImportSelector。所以AutoConfigurationImportSelector类也实现了selectImports方法来进行注入

跟踪getAutoConfigurationEntry方法

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

继续看getCandidateConfigurations，主要方法就是在这里面

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

继续看SpringFactoriesLoader.loadFactoryNames

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

继续跟踪啊。别慌。到loadSpringFactories

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

发现其实是从META-INF/spring.factories加载的。所以为了辨别真假，咱们在项目中搜搜试试,以easypoi的包为例子

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.lenovo.thinkbridge.bootstarter.easypoi.EasyPoiAutoConfiguration

这是key和value的格式，key都是注解。value为对应的标记了@Configuration的java配置类。
看包内容就可以发现spring.factories文件

所以在使用@SpringCloudApplication注解后，spring会自动扫描这些配置文件进行bean装载

可是这样就行了吗。是否还记得，我们使用redisson的时候，还要配置ip，端口一些内容，这些我们也没有进行注入，直接就生效了。
下面我们来手写一个Starter更深入了解一下使用
首先创建一个配置类，就是在yml中进行配置的内容 prefix里面添加前缀，比如spring中的spring，设置默认值就是在yml中没有进行配置的时候直接使用默认

@ConfigurationProperties(prefix = "boot.redisson")
public class RedissonProperties {

    private String host="localhost";
    private int port=6379;
    private int timeout; //超时时间
    private boolean ssl;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public boolean isSsl() {
        return ssl;
    }

    public void setSsl(boolean ssl) {
        this.ssl = ssl;
    }
}

创建Configuration配置类，这里进行了判断。如果没有使用Redisson，是不进行bean装载的，添加 EnableConfigurationProperties，填写刚刚创建的属性类

@ConditionalOnClass(Redisson.class) //条件装配
@EnableConfigurationProperties(RedissonProperties.class)
@Configuration
public class RedissonAutoConfiguration {

    @Bean
    RedissonClient redissonClient(RedissonProperties redissonProperties){
        Config config=new Config();
        String prefix="redis://";
        if(redissonProperties.isSsl()){
            prefix="rediss://";
        }
        config.useSingleServer().
                setAddress(prefix+redissonProperties.getHost()+":"+redissonProperties.getPort()).
                setConnectTimeout(redissonProperties.getTimeout());

        return Redisson.create(config);
    }
}

以及配置META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.gupaoedu.redisson.RedissonAutoConfiguration

到这里还没有结束
在META-INF文件夹下面还要创建一个additional-spring-configuration-metadata.json文件，配置内容如下

{
  "properties": [
    {
      "name": "boot.redisson.host",
      "type": "java.lang.String",
      "description": "redis的服务器地址",
      "defaultValue": "localhost"
    },{
      "name": "boot.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务器的端口",
      "defaultValue": 6379
    }
  ]

}

然后将接口打包，在B服务中引用。yml中输入boot. 就可以在yml中自动提示啦。
这就是springboot自动装配原理