starter自动转配流程以及@Import注解使用

本文主要内容包括三个部分，第一部分主要介绍@Import注解的三种使用方法，第二部分主要介绍自定义starter的两种形式，第三部分主要介绍Springboot自动装配Bean的大致流程，第四部分主要介绍一些starter的一些基本知识。

1:三种使用方法

1.1:导入普通类

1.1.1:直接导入

新建一个测试类TestA.java

public class TestA {
    public String funA(){
        return "TestA";
    }
}

在创建一个配置类

@Import(TestA.class)
public class Config {
}

测试

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        TestA testA = context.getBean(TestA.class);
        System.out.println(testA.funA());
    }
}

1.1.2：导入带有@Configuration的配置类

再见一个测试类TestB.java

public class TestB {
    public String funB(){
        return "TestB";
    }
}

在创建一个配置类创建一个配置类ConfigOther.class

@Configuration
public class ConfigOther {
    @Bean
    public TestB testB(){
        return new TestB();
    }
}

修改Config.java

@Import({TestA.class, ConfigOther.class})
public class Config {
}

测试

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        TestA testA = context.getBean(TestA.class);
        System.out.println(testA.funA());
        TestB testB = context.getBean(TestB.class);
        System.out.println(testB.funB());
    }
}

1.2:通过ImportSelector导入

创建TestC.class

public class TestC {
    public String funC(){
        return "TestC";
    }
}

创建ClassConfig并实现org.springframework.context.annotation.ImportSelector接口

@Configuration
public class ClassConfig implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{TestC.class.getName()};
    }
}

修改Config.class

@Import({TestA.class, ConfigOther.class,ClassConfig.class})
public class Config {
}

测试

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        TestA testA = context.getBean(TestA.class);
        System.out.println(testA.funA());
        TestB testB = context.getBean(TestB.class);
        System.out.println(testB.funB());
        TestC testC = context.getBean(TestC.class);
        System.out.println(testC.funC());
    }
}

1.3通过 ImportBeanDefinitionRegistrar 方式导入的类

创建测试类TestD.class

public class TestD {
    public String funD(){
        return "TestD";
    }
}

创建CustomImportBeanDefinitionRegistrar.class并实现org.springframework.context.annotation.ImportBeanDefinitionRegistrar接口

public class CustomImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry);
        RootBeanDefinition testD = new RootBeanDefinition(TestD.class);
        registry.registerBeanDefinition("testD", testD);
    }
}

修改Config.class

@Import({TestA.class, ConfigOther.class,ClassConfig.class,CustomImportBeanDefinitionRegistrar.class})
public class Config {
}

测试

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        TestA testA = context.getBean(TestA.class);
        System.out.println(testA.funA());
        TestB testB = context.getBean(TestB.class);
        System.out.println(testB.funB());
        TestC testC = context.getBean(TestC.class);
        System.out.println(testC.funC());
        TestD testD = context.getBean(TestD.class);
        System.out.println(testD.funD());
    }
}

至此@Import的使用已完毕，下面我们看一下starter是如何实现自动配置的。

自定义starter的时候有两种方式，

第一种是引入了依赖之后需要在启动类上加上@EnableXXX注解的方式，

第二种是在META-INF中加入spring.factories文件然后引入需要配置的类这种就什么也不需要配置了。

2:自定义starter的方式

第一种:采用@EnableXXX注解的形式自定义starter

新建一个注解@EnableAppConfig

@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
@Import(ClassConfig.class)
public @interface EnableAppConfig {
}

然后使用该starter的时候只需在pom.xml文件中加入依赖，在启动类上加上@EnableAppConfig，bean就会自动装配了

第二种:使用spring.factories文件形式自定义starter

在META-INF中加入spring.factories文件添加一下内容

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.liekkas.sql.testimport.Config

在Config.class类上加上@Configuration注解

@Import({TestA.class, ConfigOther.class,ClassConfig.class,CustomImportBeanDefinitionRegistrar.class})
@Configuration
public class Config {
}

然后使用该starter的时候只需要在pom.xml文件中加入依赖bean就会自动装配了。

两种形式自定义starter无本质区别，只是采用@EnableXXX注解的形式需要在启动类上加注解，而如果配置了spring.factories文件则只需要引入依赖就可以了。当然本文只是大致介绍了如何自定义starter的简单使用，如有复杂的逻辑配置等需求请参考https://www.cnblogs.com/wkynf/p/14256565.html

3:Springboot是如何自动配置Bean的

查看org.springframework.boot.autoconfigure.AutoConfigurationImportSelector的selectImports方法可知道

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
   }
   //获取所有需要自动装配的Bean的全限定名
   AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
   return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#getAutoConfigurationEntry获取所有的配置类的全限定类名

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
   }
   AnnotationAttributes attributes = getAttributes(annotationMetadata);
   //获取所有的Spring.factories里面的内容
   List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
   configurations = removeDuplicates(configurations);
   Set<String> exclusions = getExclusions(annotationMetadata, attributes);
   checkExcludedClasses(configurations, exclusions);
   configurations.removeAll(exclusions);
   configurations = getConfigurationClassFilter().filter(configurations);
   fireAutoConfigurationImportEvents(configurations, exclusions);
   return new AutoConfigurationEntry(configurations, exclusions);
}

获取到所有需要加载的Bean的全限定类名之后就可以放到Spring的容器中了。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
   List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
         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;
}

SpringBoot使用了SPI机制可以读取所有classpath路径下的spring.factories文件的内容，然后根据我们@Import注解中的内容把Bean加入Spring的容器中。至于如何解析@Import注解的内容应该就是工作量的事情了，当我们把Springboot自动装配Bean的答题逻辑了解清楚了之后，其他的就是内容的实现了，如有需要了解具体逻辑的同学，请自行参考Springboot的代码。

4:starter的一些注意事项

starter主要分为两种，一种是官方定义的starter，另一种是非官方的starter比如我们自定义的starter。

一些命名的注意事项，一般官方的命名为spring-boot-starter-xxx，而非官方的starter命名为xxx-spring-boot-starter

官方定义starter可以参考redis的starter，非官方的可以参考mybatis的starter，仔细观察就会发现官方的starter中没有spring.factories文件,而非官方的starter中有spring.factories文件，就是因为官方的starter中的spring.factories文件内容已经被内置到Springboot项目中了，所以不需要spring.factories文件了，而非官方的就需要我们自定义配置了。

posted @ 2021-05-22 22:34 Philosophy 阅读(364) 评论(0) 编辑收藏举报

刷新页面返回顶部

Loading

Philosophy