一、组件注册

1、@Scope设置组件作用域

prototype：多例，ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象。
singleton：单例（默认值），ioc容器启动会调用方法创建对象方到容器中。每次获取就是直接从容器中拿。
request：同一次请求创建一个实例
session：同一个session创建一个实例

@Configuration
@ComponentScan("spring.module.annotation")
public class MainConfig {
    @Bean
    @Scope(value = "prototype")
    public Person person(){
        return new Person(1,"张三");
    }
}

2、@Lazy懒加载

单例bean：默认ioc容器启动的时候创建对象
懒加载bean：ioc容器启动不创建对象。第一次使用（获取）bean时候创建对象，只创建一次

@Configuration
@ComponentScan("spring.module.annotation")
public class MainConfig {
    @Bean
    @Lazy
    public Person person(){
        return new Person(1,"张三");
    }
}

3、@Conditional按照条件加载bean

注释在方法：windows系统加载李雷，linux系统加载韩梅梅
注释在类上：满足条件整个类才会配置加载bean

@Configuration
@ComponentScan("spring.module.annotation")
public class MainConfig {
    @Conditional({WindowsCondition.class})
    @Bean("lilei")
    public Person person01(){
        return new Person(10,"李雷");
    }
    @Conditional({LinuxCondition.class})
    @Bean("hanmeimei")
    public Person person02(){
        return new Person(20,"韩梅梅");
    }
}

加载条件

//判断是否linux系统
public class LinuxCondition implements Condition {
    /**
     *ConditionContext：判断条件能使用的上下文
     *AnnotatedTypeMetadata：注释信息
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1、获取ioc使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2.获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3.获取当前环境信息
        Environment environment = context.getEnvironment();
        //4.获取bean定义的注册类(注册、移除、获取查看等)
        BeanDefinitionRegistry registry = context.getRegistry();
        //linux返回true，否则返回false
        String property = environment.getProperty("os.name");
        return property.contains("linux") ? true : false;
    }
}

//判断是否windows系统
public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //linux返回true，否则返回false
        String property = context.getEnvironment().getProperty("os.name");
        return property.contains("Windows") ? true : false;
    }
}

4、@Import为容器添加组件

传统方式：包扫描+组件标注注解（@Controller等）
@Bean：导入第三方包里面的组件

1）@Import

容器中自动注册组件，id默认全类名

@Configuration
@ComponentScan("spring.module.annotation")
@Import({Red.class, Blue.class})
public class MainConfig {
}

打印ioc容器中所有组件

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
        for (String beanName : context.getBeanDefinitionNames()) {
            System.out.println(beanName);
        }
    }
}

结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
spring.module.annotation.entity.Red
spring.module.annotation.entity.Blue

2）@ImprotSelector

返回多个组件的全类名数组

@Configuration
@ComponentScan("spring.module.annotation")
@Import({MyImportSelector.class})
public class MainConfig {
}

自定义逻辑返回需要导入的组件

public class MyImportSelector implements ImportSelector {
    /**
     * 返回值：导入容器的组件数组，id为全类名
     *AnnotationMetadata：标注此注解的类上面的所有注解信息
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"spring.module.annotation.entity.Black", "spring.module.annotation.entity.Yellow"};
    }
}

三个注解信息分别为：@Configuration、@ComponentScan、@Import
在这里插入图片描述

结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
spring.module.annotation.entity.Black
spring.module.annotation.entity.Yellow

3）@ImprotBeanDefinitionRegistrar

手动注册bean到容器中

@Configuration
@ComponentScan("spring.module.annotation")
@Import({MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
public class MainConfig {
}

自定义手工注册

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * AnnotationMetadata：此注解类的所有注解信息
     * BeanDefinitionRegistry：BeanDefinition注册类
     *      通过BeanDefinitionRegistry.registerBeanDefinition手工注册bean
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        boolean exist = registry.containsBeanDefinition("spring.module.annotation.entity.Black");
        //如果存在Black的bean，则会注册White的bean
        if(exist){
            //指定bean名
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(White.class);
            registry.registerBeanDefinition("white",rootBeanDefinition);
        }

    }
}

结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
spring.module.annotation.entity.Black
spring.module.annotation.entity.Yellow
white