04.SpringBoot容器功能

SpringBoot容器

1.@Configuration

告诉SpringBoot这是配置文件

@Configuration(proxyBeanMethods = true)
public class MyConfig {
    @Bean//默认也是单实例的
    public User user1()
    {
        return  new User("ylc",22);
    }
}

里面包含默认值proxyBeanMethods参数

proxyBeanMethods:代理bean的方法

  • Full模式:proxyBeanMethods = true,通过方法调用依然指向原来的bean
  • Lite模式:proxyBeanMethods = false,直接返回新实例对象

组件依赖(有二次调用)必须使用Full模式默认。其他默认是否Lite模式

/*这是一个Springboot应用*/
@SpringBootApplication(scanBasePackages = "com.ylc")
public class MainApplication {
    public static void main(String[] args) {
        //返回IOC容器
       ConfigurableApplicationContext context = SpringApplication.run(MainApplication.class,args);

        //从容器中获取组件
        User user1 = context.getBean("user1", User.class);
        User user2 = context.getBean("user1", User.class);
        System.out.println(user1==user2);
    }
}

最后为结果为true

不需要创建新组件时使用Lite模式,创建新组件时使用Full模式保证取得的组件为ioc中同一组件

2.@Import

@Import(DBHelper.class)//给容器中自动创建出这类型的组件、默认组件的名字就是全类名

04.SpringBoot容器功能

3.@Condictional

条件装配:满足Conditional指定的条件才可以注入

04.SpringBoot容器功能

例如@ConditionalOnBean,在有某个bean的时候才会注入

如果注入b的时候需要依赖a那么它们直接就可以使用条件装配,这个发生在bean的注入之前

如果把该注解放在类上,不满足条件整个类里面包含的东西都不会注册到,存在先后顺序

4.@ImportResource

用于导入外部资源文件

@ImportResource("classpath:beans.xml")

5.@ConfigurationProperties

用于配置文件绑定

user.name="小明"
user.age=12

5.1@Component+@ConfigurationProperties

只有这个组件是容器中的组件,才能使用容器提供的@ConfigurationProperties功能

@Component
@ConfigurationProperties(prefix = "user")//user为配置文件的前缀名
public class User {
    public  String name;
    public  int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {
    }
}
@RestController
public class HelloWorldController {
    @Autowired
    User user;

    @RequestMapping("/GetUser")
    public User GetUser()
    {
        return  user;
    }
}

04.SpringBoot容器功能

5.2 @EnableConfigurationProperties+@ConfigurationProperties

@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
public class MyConfig {
}
@ConfigurationProperties(prefix = "mycar")
public class Car {
    public  String CarType;
    public  int Price;

    public Car(String carType, int price) {
        CarType = carType;
        Price = price;
    }

    public String getCarType() {
        return CarType;
    }

    public void setCarType(String carType) {
        CarType = carType;
    }

    public double getPrice() {
        return Price;
    }

    public void setPrice(int price) {
        Price = price;
    }

    public Car() {
    }
}

6.@SpringBootApplication

@SpringBootApplication是一个合成注解,实际由以下注解组成

04.SpringBoot容器功能

6.1 @SpringBootConfiguration

@SpringBootConfiguration包含@Configuration注解表明这是一个配置类

6.2 @EnableAutoConfiguration(重要)

自动载入应用程序所需的所有Bean

@EnableAutoConfiguration包含以下注解

04.SpringBoot容器功能

6.2.1@AutoConfigurationPackage

将指定包下的所有组件导入进来,默认MainApplication类所在的包下

里面包含@Import({Registrar.class})

利用Registrar给容器中导入一系列组件

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }
    }

metadata把注解源信息拿出来,然后通过getPackageNames获取包名,把包名封装到数组里面,最后注册信息

6.2.2 @Import({AutoConfigurationImportSelector.class})

给容器中导入一个组件

AutoConfigurationImportSelector类里面包含selectImports方法,String[]最后用于存储要导入的包

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

其中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);
    }
}

04.SpringBoot容器功能

//获取所有候选的配置

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;
}

其中loadFactoryNames方法,利用工厂加载得到的所有组件

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoader == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }

    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

loadSpringFactories这里搜索所有META-INF/spring.factories配置文件,将根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration作为查找的Key,获取对应的一组@Configuration类,存储再Map中

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
            Enumeration urls = classLoader.getResources("META-INF/spring.factories");
            }

从META-INF/spring.factories的位置来加载一个配置文件,默认扫描当前系统里面所有的信息

在spring-boot-autoconfigure-2.5.3.jar 包中的spring.factories文件中写死了SpringBoot启动要加载的所有配置

04.SpringBoot容器功能

虽然所有自动配置启动的时候默认全部加载

xxxxAutoConfiguration 按照条件装配规则(@Conditional),最终会按需配置

6.3 @ComponentScan

@ComponentScan的功能其实就是自动扫描并加载符合条件的组件(比如@Component和@Repository等)或者bean定义,最终将这些bean定义加载到IoC容器中

上一篇:idea配置tomcat:run启动


下一篇:DaiXT:如何在IDEA中一个窗口打开多个SpringCloud项目