BeanFactory认识

准备三个类

@Configuration
    static class Config{
        @Bean
        public Bean1 bean1(){
            return new Bean1();
        }
        @Bean
        public Bean2 bean2(){
            return new Bean2();
        }
    }

    static class Bean1{
        static {
            System.out.println("被初始化");
        }
        @Autowired
        private Bean2 bean2;

        public Bean2 getBean2() {
            return bean2;
        }

        public Bean1(){
            System.out.println("被实例化");
        }
    }
    static class Bean2{
        static {
            System.out.println("构造Bean2，被初始化");
        }
        public Bean2(){
            System.out.println("被实例化");
        }
    }

 得到BeanFactory的一个实现类

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

构造BeanDefinition并且注册Bean

//bean的定义(class,scope,初始化方法，销毁方法)
        //用bean定义构造器创建beanDefinition
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
        //注册beanDefinition,加名字
        beanFactory.registerBeanDefinition("config",beanDefinition);

打印容器里面的Bean信息 

for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }

 输出：

config

只有config 说明@Configuration和@Bean没有被解析

注解配置工具类，此方法作用，给beanFactory添加一些常用的后处理器

AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

 再次打印，多了以下几个处理器

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory

拿到BeanFactory后处理器，执行方法解析BeanFactory

beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).
                values().forEach((beanFactoryPostProcessor -> {beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);}));

再次打印，多了：

bean1
bean2

System.out.println(beanFactory.getBean(Bean1.class).getBean2());

结果为null，说明并没有依赖注入

执行Bean后处理器

//bean后处理器，针对Bean的生命周期各个阶段提供扩展，例如@Autowired @Resource
        beanFactory.getBeansOfType(BeanPostProcessor.class).
                values().forEach(beanFactory::addBeanPostProcessor);

 再次打印可以拿到bean2

 小结：

beanFactory不会做的事：

1.不会主动调用BeanFactory后处理器

2.不会主动添加Bean后处理器

3.不会主动初始化单例

4.不会解析${ },#{ }