Bean 生命周期与循环依赖

@Component
public class UserService {

    private final UserRepository userRepository;

    // √ 推荐：单一构造方法，Spring 自动选用，无需 @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@Component
public class OrderService {

    private final PaymentService paymentService;
    private final NotificationService notificationService;

    // √ 多构造方法时，用 @Autowired 指定
    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
        this.notificationService = null; // 可选依赖
    }

    // 其他构造方法不会被 Spring 使用
    public OrderService(PaymentService paymentService, NotificationService notificationService) {
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }
}

// AutowiredAnnotationBeanPostProcessor 实现了此接口
// 它在 postProcessMergedBeanDefinition() 中扫描 @Autowired、@Value 注解
// 将元信息缓存到 InjectionMetadata 中，供后续属性注入使用

@Component
public class OrderService {

    // 构造器注入（推荐）：强制依赖
    private final PaymentService paymentService;

    // Setter 注入：可选依赖
    private InventoryService inventoryService;

    // 字段注入（不推荐）：看似简单，实则隐藏问题
    // @Autowired
    // private UserService userService;

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

    @Autowired(required = false) // 可选依赖
    public void setInventoryService(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }
}

@Component
public class MyService implements ApplicationContextAware, EnvironmentAware {

    private ApplicationContext ctx;
    private Environment env;

    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.ctx = ctx;
    }

    @Override
    public void setEnvironment(Environment env) {
        this.env = env;
    }

    @PostConstruct
    public void init() {
        // 在 @PostConstruct 中，Aware 注入的字段已可用
        String activeProfile = env.getProperty("spring.profiles.active");
        System.out.println("当前环境: " + activeProfile);
    }
}

@Component
public class CacheService implements InitializingBean {

    private final CacheConfig cacheConfig;
    private Cache cache;

    public CacheService(CacheConfig cacheConfig) {
        this.cacheConfig = cacheConfig;
    }

    @PostConstruct
    public void postConstruct() {
        // 轻量校验：确保配置已注入
        Objects.requireNonNull(cacheConfig, "缓存配置不能为空");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 实际初始化：创建缓存实例
        this.cache = new Cache(cacheConfig);
    }
}

// AbstractAutoProxyCreator（AOP 代理创建的核心类）
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null) {
        // 包装缓存 key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 如果早期引用没有被代理过，才在此处创建代理
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

@Component
public class ResourceHolder implements DisposableBean {

    private Connection connection;

    @PreDestroy
    public void preDestroy() {
        // 第一批清理：释放业务资源
        System.out.println("释放业务资源");
    }

    @Override
    public void destroy() throws Exception {
        // 第二批清理：关闭底层连接
        if (connection != null) {
            connection.close();
        }
    }
}

@Configuration
public class AppConfig {

    // Spring Boot 默认会推断 close() / shutdown() 方法作为销毁方法
    // 可以用 destroyMethod = "" 禁用自动推断
    @Bean(destroyMethod = "customClose")
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

@Component
public class RpcServer implements SmartLifecycle {

    private volatile boolean running = false;

    @Override
    public void start() {
        // 启动 RPC 服务
        running = true;
        System.out.println("RPC 服务启动");
    }

    @Override
    public void stop() {
        // 优雅关闭 RPC 服务
        running = false;
        System.out.println("RPC 服务关闭");
    }

    @Override
    public boolean isRunning() {
        return running;
    }

    @Override
    public int getPhase() {
        // phase 值越小越先启动、越后关闭
        // 0 是默认值，Integer.MAX_VALUE 最后启动、最先关闭
        return 0;
    }

    @Override
    public boolean isAutoStartup() {
        return true; // 容器刷新时自动调用 start()
    }
}

@Component
public class WarmUpService implements SmartInitializingSingleton {

    @Override
    public void afterSingletonsInstantiated() {
        // 所有单例 Bean 都已初始化完毕
        // 适合做缓存预热、健康检查等
        System.out.println("所有 Bean 初始化完成，开始预热缓存");
    }
}

@Component
public class LifecycleDemo implements
        BeanNameAware, BeanFactoryAware, ApplicationContextAware,
        InitializingBean, DisposableBean {

    private static final Logger log = LoggerFactory.getLogger(LifecycleDemo.class);

    private String beanName;
    private ApplicationContext ctx;

    // ① 实例化
    public LifecycleDemo() {
        log.info("① 构造方法：实例化");
    }

    // ② 属性赋值
    @Autowired
    public void setDataSource(DataSource dataSource) {
        log.info("② 属性注入：DataSource");
    }

    // ③ Aware 回调
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        log.info("③ BeanNameAware: {}", name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        log.info("④ BeanFactoryAware");
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.ctx = ctx;
        log.info("⑤ ApplicationContextAware");
    }

    // ④ @PostConstruct（在 postProcessBeforeInitialization 中触发）
    @PostConstruct
    public void postConstruct() {
        log.info("⑥ @PostConstruct：所有依赖已注入，可安全使用");
    }

    // ⑤ InitializingBean
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("⑦ InitializingBean.afterPropertiesSet()");
    }

    // 业务方法
    public void doWork() {
        log.info("业务方法执行");
    }

    // ⑥ @PreDestroy
    @PreDestroy
    public void preDestroy() {
        log.info("⑧ @PreDestroy：准备销毁");
    }

    // ⑦ DisposableBean
    @Override
    public void destroy() throws Exception {
        log.info("⑨ DisposableBean.destroy()");
    }
}

① 构造方法：实例化
② 属性注入：DataSource
③ BeanNameAware: lifecycleDemo
④ BeanFactoryAware
⑤ ApplicationContextAware
⑥ @PostConstruct：所有依赖已注入，可安全使用
⑦ InitializingBean.afterPropertiesSet()
业务方法执行
⑧ @PreDestroy：准备销毁
⑨ DisposableBean.destroy()

@FunctionalInterface
public interface BeanPostProcessor {

    // 在初始化方法（@PostConstruct、afterPropertiesSet()）之前执行
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }

    // 在初始化方法之后执行
    //  AOP 代理就是在这里由 AbstractAutoProxyCreator 创建的
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }
}

// BeanFactoryPostProcessor：修改 Bean 定义（实例化之前）
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinition bd = beanFactory.getBeanDefinition("myService");
        bd.setScope("prototype"); // 动态修改作用域
    }
}

// BeanPostProcessor：修改或替换 Bean 实例（实例化之后）
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 可以返回代理对象，替换原始 Bean
        return bean;
    }
}

// 示例：记录 Bean 初始化耗时
@Component
public class TimingBeanPostProcessor implements BeanPostProcessor, Ordered {

    private static final Logger log = LoggerFactory.getLogger(TimingBeanPostProcessor.class);
    private final ThreadLocal<Long> startTime = new ThreadLocal<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        startTime.set(System.currentTimeMillis());
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        long elapsed = System.currentTimeMillis() - startTime.get();
        startTime.remove();
        if (elapsed > 100) {
            log.warn("Bean [{}] 初始化耗时 {}ms，可能影响启动速度", beanName, elapsed);
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE; // 最后执行，确保计时覆盖完整初始化
    }
}

@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Component
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

@Component
public class ServiceA {
    private final ServiceB serviceB;
    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Component
public class ServiceB {
    private final ServiceA serviceA;
    @Autowired
    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

@Component
public class ServiceA {
    private ServiceB serviceB;
    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Component
public class ServiceB {
    private ServiceA serviceA;
    @Autowired
    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceService;
    }
}

@Component @Scope("prototype")
public class ServiceA {
    @Autowired private ServiceB serviceB;
}

@Component @Scope("prototype")
public class ServiceB {
    @Autowired private ServiceA serviceA;
}

// DefaultSingletonBeanRegistry 中的三级缓存

// 一级缓存：存放完全初始化好的 Bean（所有属性已注入、初始化回调已执行）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 二级缓存：存放早期暴露的 Bean（已实例化，但属性未注入、初始化未完成）
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 三级缓存：存放 ObjectFactory，调用时才决定返回原始对象还是代理对象
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

// DefaultSingletonBeanRegistry.java

// 获取单例 Bean（依次从一级 → 二级 → 三级缓存查找）
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 先从一级缓存获取（完全初始化好的 Bean）
    Object singletonObject = this.singletonObjects.get(beanName);

    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 2. 从二级缓存获取（早期暴露的 Bean）
            singletonObject = this.earlySingletonObjects.get(beanName);

            if (singletonObject == null && allowEarlyReference) {
                // 3. 从三级缓存获取（ObjectFactory）
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

                if (singletonFactory != null) {
                    // 调用工厂方法，决定返回原始对象还是代理对象
                    singletonObject = singletonFactory.getObject();
                    // 提升到二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级缓存移除
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }

    return singletonObject;
}

// Bean 实例化后，将 ObjectFactory 放入三级缓存
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

// Bean 完全初始化后，放入一级缓存，清除二、三级缓存
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

# application.yml
spring:
  main:
    allow-circular-references: true  # 不推荐，仅用于遗留项目过渡

// × 无法启动
@Service
public class ServiceA {
    private final ServiceB serviceB;
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Service
public class ServiceB {
    private final ServiceA serviceA;
    public ServiceB(ServiceA serviceA) {
        this.serviceService = serviceA;
    }
}

@Service
public class ServiceA {
    private final ServiceB serviceB;

    // @Lazy 让 Spring 注入一个代理对象，而不是立即创建真实 Bean
    public ServiceA(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

// × 循环依赖
@Service
public class OrderService {
    @Autowired private UserService userService;
    public void createOrder() { /* 需要 userService */ }
}

@Service
public class UserService {
    @Autowired private OrderService orderService;
    public void getUserOrders() { /* 需要 orderService */ }
}

// √ 提取查询逻辑到第三方服务
@Service
public class OrderQueryService {
    public List<Order> queryByUserId(Long userId) { /* ... */ }
}

@Service
public class OrderService {
    private final OrderQueryService orderQueryService;
    public OrderService(OrderQueryService orderQueryService) {
        this.orderQueryService = orderQueryService;
    }
    public void createOrder() { /* ... */ }
}

@Service
public class UserService {
    private final OrderQueryService orderQueryService;
    public UserService(OrderQueryService orderQueryService) {
        this.orderQueryService = orderQueryService;
    }
    public void getUserOrders() {
        orderQueryService.queryByUserId(userId);
    }
}

// × 循环依赖：OrderService 直接依赖 NotificationService
@Service
public class OrderService {
    @Autowired private NotificationService notificationService;
    public void createOrder() {
        // 创建订单...
        notificationService.sendNotification(); // 直接调用
    }
}

// √ 事件驱动：通过 ApplicationEvent 解耦
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder() {
        // 创建订单...
        publisher.publishEvent(new OrderCreatedEvent(order));
    }
}

@Component
public class NotificationEventListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 发送通知，无需反向依赖 OrderService
    }
}

@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Component
public class ServiceB {
    @Async  // @Async 通过 BeanPostProcessor 创建代理
    public void asyncMethod() { /* ... */ }

    @Autowired
    private ServiceA serviceA;
}

@Component
public class ServiceA {
    @Autowired
    @Lazy  // 延迟加载，打破循环
    private ServiceB serviceB;
}

@Service
public class BadService {

    @Autowired
    private UserRepository userRepository;

    // × 构造方法中依赖还未注入
    public BadService() {
        User user = userRepository.findById(1L); // NullPointerException!
    }

    // × @PostConstruct 中做耗时操作
    @PostConstruct
    public void init() {
        List<User> users = userRepository.findAll(); // 影响启动速度
        remoteService.call(); // 可能导致启动失败
    }
}

@Service
public class GoodService {

    private final UserRepository userRepository;

    // √ 构造器注入，依赖在构造时就已确定
    public GoodService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @PostConstruct
    public void init() {
        // √ 只做轻量校验，不做重 IO
        Objects.requireNonNull(userRepository, "UserRepository 不能为空");
    }

    // √ 延迟到首次使用时初始化
    private volatile boolean warmedUp = false;

    public User getUser(Long id) {
        if (!warmedUp) {
            synchronized (this) {
                if (!warmedUp) {
                    warmUpCache(); // 首次使用时预热
                    warmedUp = true;
                }
            }
        }
        return userRepository.findById(id).orElse(null);
    }
}

@Service
public class OrderService {

    @Transactional
    public void createOrder() { /* ... */ }

    public void invokeSelf() {
        // × this 是原始对象，不走代理，事务不生效
        this.createOrder();
    }
}

@Service
public class OrderService {

    // 方案一：注入自身代理
    @Autowired
    @Lazy // 必须 @Lazy，否则循环依赖
    private OrderService self;

    @Transactional
    public void createOrder() { /* ... */ }

    public void invokeSelf() {
        self.createOrder(); // √ 走代理，事务生效
    }
}

// 方案二：通过 AopContext 获取当前代理（需开启 exposeProxy）
@SpringBootApplication
@EnableAspectJAutoProxy(exposeProxy = true)
public class Application { }

@Service
public class OrderService {

    @Transactional
    public void createOrder() { /* ... */ }

    public void invokeSelf() {
        // √ 通过 AopContext 获取当前代理对象
        ((OrderService) AopContext.currentProxy()).createOrder();
    }
}

@Service
public class PaymentService {
    private final PaymentGateway gateway;
    private final RiskService riskService;

    // × 多个构造方法、无 @Autowired、无无参构造 → 启动失败
    public PaymentService(PaymentGateway gateway) {
        this.gateway = gateway;
        this.riskService = null;
    }

    public PaymentService(PaymentGateway gateway, RiskService riskService) {
        this.gateway = gateway;
        this.riskService = riskService;
    }
}

@Service
public class PaymentService {
    private final PaymentGateway gateway;
    private final RiskService riskService;

    // √ 用 @Autowired 指定要使用的构造方法
    @Autowired
    public PaymentService(PaymentGateway gateway,
                          @Autowired(required = false) RiskService riskService) {
        this.gateway = gateway;
        this.riskService = riskService;
    }
}

# application.yml
logging:
  level:
    org.springframework.beans.factory: DEBUG
    org.springframework.context.annotation: DEBUG

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

@Component
public class DebugBeanPostProcessor implements BeanPostProcessor, Ordered {

    private static final Logger log = LoggerFactory.getLogger(DebugBeanPostProcessor.class);

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        log.debug("[BeforeInit] {} -> {}", beanName, bean.getClass().getSimpleName());
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        log.debug("[AfterInit] {} -> {}", beanName, bean.getClass().getSimpleName());
        return bean;
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // 最先执行，确保记录完整链路
    }
}