public class TestBeanFactory {
    public static void main(String[] args) {
        //创建基础Spring容器
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //创建BeanDefinition
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
        //注册BeanDefinition
        beanFactory.registerBeanDefinition("config", beanDefinition);
        //遍历容器中所有的BeanDefinition
        System.out.println("=============");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //给BeanFactory添加后处理器 (bean工厂后处理器)
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
        //再次遍历容器中的BeanDefinition
        System.out.println("=============");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //根据类型获取bean并遍历 调用每个beanFactoryPostProcessor的postProcessBeanFactory方法
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor ->
                beanFactoryPostProcessor.postProcessBeanFactory(beanFactory)
        );
        //再次遍历容器中的BeanDefinition
        System.out.println("=============");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //此时发现并没有依赖注入, Bean1中的Bean2属性没有注入, 我们还需要Bean后处理器对依赖注入进行处理
//        System.out.println(beanFactory.getBean(Bean1.class).getBean2());
        //根据类型获取bean并遍历 调用每个BeanPostProcessor, 并让beanFactory添加这些beanPostProcessor
        //添加代码 : 输出postProcessor顺序, 并尝试改变顺序, 判断其对@Autowired @Resource注解注入的影响
        //postProcessor后处理器中有个order属性供DependencyComparator()判断, Autowired是最大值-2, Resource是最大值-3, 所以经过排序后, 采用了Resource注解注入
        beanFactory.getBeansOfType(BeanPostProcessor.class).values()
                .stream().sorted(beanFactory.getDependencyComparator()).forEach(beanPostProcessor -> {
                    System.out.println(">>>>>>>>>>" + beanPostProcessor);
                    beanFactory.addBeanPostProcessor(beanPostProcessor);
                });

        //此语句使得容器预先实例化所有的单例beanDefinition, 不加此行代码的话, bean定义都是懒加载, 即需要用到时候才加载
        beanFactory.preInstantiateSingletons();

        //再次尝试获取Bean2 此时必须把上面获取Bean1的代码注释掉, 因为获取bean必须在添加bean后处理器之后
        System.out.println("=============");
        System.out.println(beanFactory.getBean(Bean1.class).getBean2());

        //在Bean1中Inter变量中添加@Autowired注解, 观察注入的是Bean3还是Bean4
        System.out.println("=============");
        System.out.println(beanFactory.getBean(Bean1.class).getInter());
    }
}

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

    @Bean
    public Bean2 bean2() {
        return new Bean2();
    }

    @Bean
    public Bean3 bean3() {
        return new Bean3();
    }

    @Bean
    public Bean4 bean4() {
        return new Bean4();
    }
}

interface Inter {
}

class Bean1 {
    public static final Logger log = LoggerFactory.getLogger(Bean1.class);

    public Bean2 getBean2() {
        return bean2;
    }

    @Autowired
    private Bean2 bean2;

    @Autowired
    @Resource(name = "bean4")
    private Inter bean3;

    public Inter getInter() {
        return bean3;
    }

    public Bean1() {
        System.out.println("Bean1构造函数");
    }
}

class Bean2 {
    public static final Logger log = LoggerFactory.getLogger(Bean2.class);

    public Bean2() {
        System.out.println("Bean2构造函数");
    }
}

class Bean3 implements Inter {
    public static final Logger log = LoggerFactory.getLogger(Bean3.class);

    public Bean3() {
        System.out.println("Bean3构造函数");
    }
}

class Bean4 implements Inter {
    public static final Logger log = LoggerFactory.getLogger(Bean4.class);

    public Bean4() {
        System.out.println("Bean3构造函数");
    }
}