spring通过注解注册bean的方式+spring生命周期

spring容器通过注解注册bean的方式

@ComponentScan + 组件标注注解 (@Component/@Service...)

@ComponentScan(value = "com.example.demo.annotation")

spring会将com.example.demo.annotation目录下标注了spring能识别的注解的类注册为bean
@ComponentScan 还可以指定排除和包含规则

excludeFilters: 指定排除规则，排除哪些组件
includeFilters: 指定只需要包含哪些组件,需要设置 useDefaultFilters = false
FilterType.ANNOTATION 基于注解过滤
FilterType.ASSIGNABLE_TYPE ：基于给定的类型过滤
...
FilterType.CUSTOM: 自定义规则过滤

@ComponentScan(value = "com.example.demo.annotation",
        /*excludeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
        },*/
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Configuration.class}),
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,classes = {TestController.class}),
                @ComponentScan.Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})
        },useDefaultFilters = false
)

其中CUSTOM自定义规则中的MyTypeFilter需要实现TypeFilter接口，举例如下

public class MyTypeFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        String className = metadataReader.getClassMetadata().getClassName();
        System.out.println("------>"+className);
        if (className.contains("er")){
            return true;
        }
        return false;
    }
}

@Bean (可以将第三方包中的类注册为bean)

@Bean
Person person() {
    return new Person("zhang");
}

@Import

@Import({Color.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})

导入一个普通类，容器会自动注册这个组件，组件的id默认是类的全类名
导入ImportSelector :返回需要注册的组件

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.example.demo.annotation.bean.Red"};
    }
}

导入ImportBeanDefinitionRegistrar类

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean b = registry.containsBeanDefinition("com.example.demo.annotation.bean.Color");
        boolean b1 = registry.containsBeanDefinition("com.example.demo.annotation.bean.Red");
        if (b && b1){
            registry.registerBeanDefinition("rainBow",new RootBeanDefinition(RainBow.class));
        }
    }
}

使用spring提供的 FactoryBean

public class ColorFactoryBean implements FactoryBean<Color> {
    @Override
    public Color getObject() throws Exception {
        return new Color();
    }

    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }
}

@Bean
ColorFactoryBean colorFactoryBean() {
    return new ColorFactoryBean();
}

applicationContext.getBean("colorFactoryBean") 默认获取到的是FactoryBean调用getObject方法返回的对象
要获取FactoryBean本身，需要在id前面加个& (&colorFactoryBean)

当满足某种条件时才注册bean,使用`@Conditional`

举例：在windows和linux上分别注册不同的bean

    @Conditional({WindowsConditional.class})
    @Bean("windows")
    Person person1() {
        return new Person("windows");
    }

    @Bean("linux")
    @Conditional({LinuxConditional.class})
    Person person2() {
        return new Person("linux");
    }

    public class WindowsConditional implements Condition {
        @Override
        public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
            Environment environment = conditionContext.getEnvironment();
            String property = environment.getProperty("os.name");
            return property.toLowerCase().contains("windows");
        }
    }

    public class LinuxConditional implements Condition {
        @Override
        public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
            Environment environment = conditionContext.getEnvironment();
            String property = environment.getProperty("os.name");
            return property.toLowerCase().contains("linux");
        }
    }

bean的生命周期

spring容器管理bean的生命周期：创建--》初始化--》销毁

我们可以自定义初始化和销毁方法，容器在bean进行到当前生命周期时来调用我们自定义的初始化和销毁方法

创建对象：
单实例：在容器启动时创建对象
多实例：在每次获取bean的时候创建对象

每个BeanPostProcessor的 postProcessBeforeInitialization 方法会在初始化之前执行
初始化：对象创建好，调用初始化方法
每个BeanPostProcessor的 postProcessAfterInitialization 方法会在初始化之后执行
销毁：
单实例：容器关闭时销毁
多实例：容器会帮助创建这个bean,但不会管理这个bean,所以容器不会调用销毁方法，可以手动调用销毁方法

指定初始化和销毁的方法：

在 @Bean注解指定(initMethod = "",destroyMethod = "")
通过让bean实现 InitializingBean（定义初始化逻辑）和 DisposableBean（定义销毁时逻辑）
使用JSR250: @PostConstruct （定义初始化逻辑） @PreDestroy（在容器销毁bean之前通知进行清理工作）

bean的后置处理器 BeanPostProcessor,其有如下两个方法，在bean的初始化前后做一些处理：

postProcessBeforeInitialization：在初始化之前工作
postProcessAfterInitialization：在初始化之后工作

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    private final ApplicationContext applicationContext;

    public MyBeanPostProcessor(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization--->"+beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization--->"+beanName);
        return bean;
    }
}

如果自定义组件想要使用spring容器底层的组件（ApplicationContext，BeanFactory,***）,自定义组件可以实现 ***Aware,
在创建bean的时候，相关BeanPostProcessor会调用接口规定的方法注入相关组件

例如：

如果自定义bean 实现了ApplicationContextAware 接口，在ApplicationContextAwareProcessor中会调用ApplicationContextAware的
setApplicationContext方法，注入ApplicationContext组件