2、SpringBoot2组件添加注解与自动配置原理

本文链接：https://blog.csdn.net/qq_36831305/article/details/128960722

1、组件添加

（1）@Configuration + @Bean

通过配置类往容器中添加组件,@Bean用于配置类的方法上

/**
* 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
* 2、配置类本身也是组件
* 3、proxyBeanMethods：代理bean的方法
*      Full(proxyBeanMethods = true)【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
*      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
*      组件依赖必须使用Full模式默认。其他默认是否Lite模式
*/
@Configuration //告诉SpringBoot这是一个配置类 == 配置文件 需被容器扫描到
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例 Pet tomcatPet会从容器中取得注入
    public User user01(Pet tomcatPet){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件 如果是Lite模式 会创建新的对象
        zhangsan.setPet(tomcatPet());
        //当为full模式返回true  lite模式返回false
        System.out.println(tomcatPet() ==tomcatPet);
        return zhangsan;
    }


    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

(2) @Component、@Controller、@Service、@Repository、@RestController

都是往容器中添加组件

@RestController //将实体类注册到IOC容器中 需被容器扫描到
public class HelloWordController {
}

(3) @ComponentScan

用于指定扫描包

@Configuration
@ComponentScan(basePackages="com.qww") //指定spring容器扫描的包路径  同时可指定扫描的class类 
public class MyConfig {
}

(4) @Import

往容器中导入组件，有如下三种方式

@Import(User.class) //给容器中自动创建出User组件、默认组件的名字就是全类名
@Configuration(proxyBeanMethods = false)
public class MyConfig {
}

@Import(MyImportSelector.class)
@Configuration(proxyBeanMethods = false)
public class MyConfig {
}

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.qww.bean.User"}; //将返回的全类名创建组件，默认组件名字是全类名
    }
}

@Import(MyImportBeanDefinitionRegistrar.class)
@Configuration(proxyBeanMethods = false)
public class MyConfig {
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(User.class);
        //注册一个bean指定bean名字（id）
        beanDefinitionRegistry.registerBeanDefinition("user",rootBeanDefinition);
    }
}

(5) @Conditional

条件注解，当条件生效时往容器中注入组件

//@ConditionalOnBean(name = "tom")  //当存在bean tom时配置生效
@OnMissingBean(name = "tom")  //当不存在bean tom时配置生效
@Configuration(proxyBeanMethods = false)
public class MyConfig {
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/c4949a05b7974fd0a6aed7f879cdab88.png

(6) @ImportResource

启动加载原始的spring配置文件

@ImportResource("classpath:beans.xml") //加载原始的配置文件
@Configuration(proxyBeanMethods = false)
public class MyConfig {
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="user" class="com.qww.bean.User">
    </bean>
</beans>

(7) @ConfigurationProperties

属性绑定，根据yaml中配置的属性值赋予实体类对应的属性，有如下两种开启方式

@Data
@Component //放到容器中
@ConfigurationProperties(prefix = "test") //匹配配置文件前缀为test的属性
public class PropertiesTest {
    private String name;
    private String sex;
}

@Configuration
@EnableConfigurationProperties(PropertiesTest.class) // 开启PropertiesTest的属性绑定
public class MyConfig {
}

@Data
@ConfigurationProperties(prefix = "test") //匹配配置文件前缀为test的属性
public class PropertiesTest {
    private String name;
    private String sex;
}

2、SpringBoot自动配置

SpringBoot从META-INF/spring.factories位置来加载一个文件，并根据加载全部的xxxxAutoConfiguration，根据xxxxAutoConfiguration的条件注解是否开启

（1） @SpringBootApplication

@SpringBootApplication //启动类 完成自动配置
public class MainApplication {
    public static void main(String[] args) {
       SpringApplication.run(MainApplication.class, args);
    }
}

//@SpringBootApplication 注解相当于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

（2）@SpringBootConfiguration + @ComponentScan

@SpringBootConfiguration //作用等同  告诉这是一个配置类 作用同@Configuration
@ComponentScan //扫描包  进行扫描过滤  默认扫描主启动类所在包及其子包

（3）@EnableAutoConfiguration

@AutoConfigurationPackage //自动配置扫描包
@Import({AutoConfigurationImportSelector.class}) //进行自动配置

(4) @AutoConfigurationPackage

@AutoConfigurationPackage 扫描 @Entity、@MapperScan 等第三方依赖的注解；
@ComponentScan 扫描 @Controller、@Service、@Component、@Respository 这些常见注解。所以这两个注解扫描的对象是不一样的。

@Import({Registrar.class})
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		//获取包路径并注册
        AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
    }
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
    }
}

(5) AutoConfigurationImportSelector

/**
* 从META-INF/spring.factories位置来加载一个文件。
*     默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
*     spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
*/
SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

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

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();
			// 省略........
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

/**
* 所有场景的自动配置启动的时候默认全部加载。xxxxAutoConfiguration
* 按照条件装配规则（@Conditional），最终会按需配置
*/
@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration {
}