IoC 与依赖注入：把对象的组装权交给容器

public interface PaymentService {

    String pay(String orderId);
}

import org.springframework.stereotype.Service;

@Service
public class AliPayService implements PaymentService {

    public AliPayService() {
        System.out.println("构造 AliPayService");
    }

    @Override
    public String pay(String orderId) {
        return "ali:" + orderId;
    }
}

import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
        System.out.println("构造 OrderService（依赖已注入：" + (paymentService != null) + "）");
    }

    public String createOrder(String orderId) {
        return paymentService.pay(orderId);
    }
}

构造 AliPayService
构造 OrderService（依赖已注入：true）

容器启动后的地图（简化视角）
  "orderService"  (OrderService 类型)     → 一个 OrderService 实例
  "aliPayService" (PaymentService 类型)   → 一个 AliPayService 实例
查找规则
  按类型：PaymentService 只有一个 → 构造器参数直接匹配给你
  按名字：类型有多个时，先按类型缩小范围，再按参数名或限定符挑

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ThirdPartyConfig {
    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper();   // 方法名即 Bean 名，返回值进地图，参数同样享受注入
    }
}

@Service
public class ReportService {
    private PdfGenerator pdfGenerator;

    @Autowired(required = false)   // setter 注入：真可选依赖；没有也不报错，值为 null
    public void setPdfGenerator(PdfGenerator pdfGenerator) {
        this.pdfGenerator = pdfGenerator;
    }
}

// 字段注入：被劝退，仅老代码常见
@Autowired
private PaymentService paymentService;

@Service
@Primary                      // 全项目默认：不指定时用它
public class AliPayService implements PaymentService {
    @Override
    public String pay(String orderId) { return "ali:" + orderId; }
}

@Service("wechatPay")         // Bean 名字：指名道姓时用它
public class WechatPayService implements PaymentService {
    @Override
    public String pay(String orderId) { return "wechat:" + orderId; }
}

// 使用处二选一
public OrderService(@Qualifier("wechatPay") PaymentService paymentService) { }

1 实例化        调构造器，对象只是半成品，依赖尚未注入
2 属性填充      按类型或名字注入依赖，@Autowired 的注值发生在这里
3 Aware 回调    BeanNameAware、ApplicationContextAware 等，把框架内部组件递给你
4 前后处理      BeanPostProcessor 前后处理：前置后走初始化，AOP 代理在后置生成
5 初始化        @PostConstruct 方法 → afterPropertiesSet → @Bean(initMethod=...) 依序执行
6 就绪          放入一级缓存，全应用共用
7 销毁          容器关闭时：@PreDestroy → destroy() → @Bean(destroyMethod=...) 依序执行

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LifecycleProbe {
    @Autowired
    private PaymentService paymentService;

    public LifecycleProbe() {
        System.out.println("1 构造器：paymentService = " + paymentService);
    }

    @PostConstruct
    public void ready() {
        System.out.println("5 初始化：paymentService = " + paymentService);
    }
    @PreDestroy
    public void bye() {
        System.out.println("7 销毁：容器关闭时触发");
    }
}

1 构造器：paymentService = null
5 初始化：paymentService = com.example.ioc.AliPayService@4f241060
7 销毁：容器关闭时触发

@Service
public class ReportFactory {
    private final Report report;      // 注入发生在 ReportFactory 创建那一刻

    public ReportFactory(Report report) {
        this.report = report;         // 从此永远持有同一个 Report
    }

    public Report newReport() {
        return report;                // 方法名叫 newReport，返回的却是同一个实例
    }
}

@Service
public class ReportFactory {
    private final ObjectProvider<Report> reports;   // 持有的是取件码，不是货

    public ReportFactory(ObjectProvider<Report> reports) {
        this.reports = reports;
    }
    public Report newReport() {
        return reports.getObject();     // 每次调用才真正找容器要，拿到崭新的 prototype
    }
}

@Service
public class OrderService {
    private final NotificationService notificationService;
    public OrderService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
}
@Service
public class NotificationService {
    private final OrderService orderService;
    public NotificationService(OrderService orderService) {
        this.orderService = orderService;
    }
}

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  orderService
↑     ↓
|  notificationService
└─────┘

Action:

Relying upon circular references is discouraged and they are prohibited by default.
As a last resort, it may be possible to break the cycle automatically by setting
spring.main.allow-circular-references to true.

getBean(orderService)：一级没有，orderService 进入「创建中」名单
  实例化（构造器跑完，得到半成品），「能拿到它早期引用」的工厂放入三级缓存
  属性填充：需要 notificationService → getBean(notificationService)
    同样实例化、工厂入三级缓存；它的属性填充需要 orderService
      orderService 在创建中名单里 → 三级缓存的工厂出马给出早期引用
      （需要 AOP 时顺手生成代理），引用升入二级缓存，三级工厂删除
    notificationService 完成初始化进一级缓存，orderService 随后拿到成品——环解开