#IoC 与 DI 原理

// 构造器注入（推荐）
public class OrderService {
    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

// Setter 注入
public class OrderService {
    private OrderRepository orderRepository;

    @Autowired
    public void setOrderRepository(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

// Spring 底层创建 Bean 的简化流程
public Object createBean(String beanName, BeanDefinition bd) {
    // 1. 根据 BeanDefinition 中的信息，确认使用哪个构造函数
    Constructor<?> constructorToUse = resolveConstructor(bd);

    // 2. 通过反射调用构造函数，实例化对象
    Object bean = constructorToUse.newInstance(constructorArgs);

    // 3. 通过反射注入属性（autowire）
    populateBean(bean, bd);

    // 4. 初始化 Bean（调用 init-method、BeanPostProcessor 等）
    initializeBean(bean, beanName);

    return bean;
}

// JDK 1.8 AbstractAutowireCapableBeanFactory.java
private BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 如果存在 Supplier，则使用 Supplier 创建
    if (mbd.getSupplier() != null) {
        return resolveBeanFromSupplier(mbd, beanName);
    }

    // 如果有工厂方法，则使用工厂方法创建
    if (mbd.hasFactoryMethod()) {
        return resolveFactoryMethod(mbd, args);
    }

    // 解析构造函数（用于构造器注入）
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(mbd, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == Constructor) {
        // 使用构造器自动装配
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // 使用默认构造函数
    return instantiateBean(beanName, mbd);
}

// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    Object bean;
    try {
        // 获取类对象
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

        // 如果是 CGLIB 代理类，则使用 CGLIB 创建
        if (mbd.hasBeanClass() && mbd.getEnforceMethodOverride()) {
            return instantiateWithMethodInjection(mbd, beanName);
        }

        // 普通的 Bean，使用 JDK 反射或 CGLIB 创建实例
        bean = getInstantiationStrategy().instantiate(mbd, beanName, this);
        BeanWrapper bw = new BeanWrapperImpl(bean);
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
}

// BeanFactory 懒加载示例
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
// 此时所有 Bean 都没有被创建
OrderService orderService = factory.getBean(OrderService.class); // 第一次调用时才创建

// ApplicationContext 预加载示例
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
// 容器启动时，所有 Bean 都已经被创建好了
OrderService orderService = ctx.getBean(OrderService.class); // 直接使用

// AbstractApplicationContext.java
public void refresh() throws BeansException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备 BeanFactory
        prepareBeanFactory(beanFactory);

        // 2. 允许子类注册 BeanDefinition（扩展点）
        postProcessBeanFactory(beanFactory);

        // 3. 调用所有 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactory);

        // 4. 注册 BeanPostProcessor
        registerBeanPostProcessors(beanFactory);

        // 5. 初始化消息源（国际化）
        initMessageSource();

        // 6. 初始化事件广播器
        initApplicationEventMulticaster();

        // 7. onRefresh 钩子（留给子类实现，如 Web 项目启动）
        onRefresh();

        // 8. 注册 ApplicationListener
        registerListeners();

        // 9. 实例化所有剩余的单例 Bean
        finishBeanFactoryInitialization(beanFactory);

        // 10. 发布 ContextRefreshedEvent
        finishRefresh();
    }
}

// 不用 Spring 的写法
public class OrderService {
    private OrderRepository orderRepository = new OrderRepository();
    private PaymentService paymentService = new PaymentService();
    private NotificationService notificationService = new NotificationService();
}

public class OrderService {
    // @Autowired byType，相同类型有多个 Bean 时需要 @Qualifier
    @Autowired
    @Qualifier("jdbcOrderRepository")
    private OrderRepository orderRepository;

    // @Resource byName，直接按字段名匹配 Bean
    @Resource
    private OrderRepository jdbcOrderRepository;

    // @Autowired 构造器注入（推荐）
    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

@Service
public class A {
    private B b;

    @Autowired
    public void setB(@Lazy B b) {
        this.b = b;
    }
}

@Configuration
public class DataSourceConfig {
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) { // 依赖 dataSource
        return new JdbcTemplate(dataSource);
    }
}

@Component
@Order(1) // 数值越小优先级越高
public class FirstInitializer implements ApplicationRunner { }

@Component
@Order(2)
public class SecondInitializer implements ApplicationRunner { }