反射：Spring IoCDI 最底层的“发动机”（2026年4月更新）

// 传统开发方式：紧耦合噩梦
public class OrderService {
    // 硬编码依赖——直接 new 具体实现类
    private PaymentService paymentService = new AlipayService();
    private Logger logger = new FileLogger("/var/log/order.log");
    
    public void processOrder() {
        logger.log("开始处理订单");
        paymentService.pay();  // 只能使用支付宝支付
        // 想换成微信支付？—— 改代码，重编译，重部署
    }
}

1. Spring容器启动，扫描所有带 @Component/@Service 等注解的类
2. 解析依赖关系，发现 OrderService 需要 PaymentService
3. 容器先创建 PaymentService 实例（存入容器）
4. 再创建 OrderService 实例，并通过构造器/Setter/字段将 PaymentService 注入进去
5. 返回完整的、依赖就绪的 OrderService 对象

// 接口
public interface PaymentService {
    void pay(double amount);
}

// 实现类
public class AlipayService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

// 业务类——手动管理依赖
public class OrderService {
    private PaymentService paymentService;
    
    public OrderService() {
        // 硬编码创建依赖——想换成微信支付？改代码！
        this.paymentService = new AlipayService();
    }
    
    public void checkout(double amount) {
        paymentService.pay(amount);
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();  // 依赖已经写死在内部
        orderService.checkout(100.0);
    }
}

// 接口与实现（不变）
public interface PaymentService {
    void pay(double amount);
}

@Service  // ① 交给Spring容器管理
public class AlipayService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

// 业务类——声明依赖，不负责创建
@Service
public class OrderService {
    private final PaymentService paymentService;
    
    // ② 构造器注入：Spring容器自动传入依赖
    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    
    public void checkout(double amount) {
        paymentService.pay(amount);
    }
}

// Spring Boot启动类
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        // ③ 从容器中获取OrderService，所有依赖已自动注入完毕
        OrderService orderService = context.getBean(OrderService.class);
        orderService.checkout(100.0);
        context.close();
    }
}

步骤1：加载配置（XML/注解/JavaConfig）→ 解析出类的全限定名
步骤2：将配置信息封装为 BeanDefinition（Bean的“说明书”）
步骤3：通过反射技术实例化对象，放入容器（Map结构）
步骤4：通过反射调用构造器/Setter方法，完成依赖注入

// 模拟Spring IoC容器的核心代码
public class SimpleIocContainer {
    // 容器本质：一个Map，key=bean名称，value=对象实例
    private Map<String, Object> container = new ConcurrentHashMap<>();
    
    // 模拟注册Bean的过程
    public void registerBean(String beanName, String className) throws Exception {
        // ① 获取类的字节码对象
        Class<?> clazz = Class.forName(className);
        // ② 通过反射调用无参构造器创建实例
        Object instance = clazz.getDeclaredConstructor().newInstance();
        // ③ 存入容器
        container.put(beanName, instance);
        System.out.println("Bean [" + beanName + "] 已注册到容器");
    }
    
    // 模拟获取Bean的过程
    public Object getBean(String beanName) {
        return container.get(beanName);
    }
    
    // 模拟依赖注入：通过反射为对象属性赋值
    public void injectDependencies(Object target) throws Exception {
        Field[] fields = target.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                // 从容器中获取依赖对象，通过反射注入
                Object dependency = container.get(field.getType().getSimpleName());
                field.setAccessible(true);  // 突破private限制
                field.set(target, dependency);
            }
        }
    }
}