SmartInitializingSingleton

SmartInitializingSingleton在所有单例Bean实例化完成后执行回调。

接口定义

public interface SmartInitializingSingleton {
    void afterSingletonsInstantiated();
}

调用时机

┌─────────────────────────────────────┐
│  所有单例Bean实例化                   │
├─────────────────────────────────────┤
│  所有单例Bean初始化完成               │
├─────────────────────────────────────┤
│  SmartInitializingSingleton回调      │
│  (afterSingletonsInstantiated)      │
├─────────────────────────────────────┤
│  ApplicationContext刷新完成          │
│  (发布ContextRefreshedEvent)        │
└─────────────────────────────────────┘

与@PostConstruct不同，此接口确保所有Bean都已就绪。

实现示例

@Component
public class CacheInitializer implements SmartInitializingSingleton {

    @Autowired
    private List<CacheProvider> cacheProviders;

    @Override
    public void afterSingletonsInstantiated() {
        // 所有Bean已就绪，此时初始化缓存
        for (CacheProvider provider : cacheProviders) {
            provider.initialize();
        }
        System.out.println("缓存系统初始化完成");
    }
}

与其他初始化方式对比

使用场景

多Bean依赖的初始化

@Component
public class RouteRegistry implements SmartInitializingSingleton {

    @Autowired
    private List<Controller> controllers;

    private Map<String, Controller> routeMap = new HashMap<>();

    @Override
    public void afterSingletonsInstantiated() {
        // 所有Controller已就绪，构建路由表
        for (Controller controller : controllers) {
            String path = controller.getPath();
            routeMap.put(path, controller);
        }
        System.out.println("路由表构建完成，共 " + routeMap.size() + " 条路由");
    }

    public Controller getController(String path) {
        return routeMap.get(path);
    }
}

系统启动检查

@Component
public class SystemHealthChecker implements SmartInitializingSingleton {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private MessageQueue messageQueue;

    @Override
    public void afterSingletonsInstantiated() {
        // 所有组件已就绪，执行健康检查
        checkDatabase();
        checkRedis();
        checkMessageQueue();
        System.out.println("系统健康检查完成");
    }

    private void checkDatabase() {
        try {
            dataSource.getConnection().close();
            System.out.println("数据库连接正常");
        } catch (Exception e) {
            throw new RuntimeException("数据库连接失败", e);
        }
    }
}

批量Bean处理

@Component
public class PluginLoader implements SmartInitializingSingleton {

    @Autowired
    private Map<String, Plugin> plugins;

    @Override
    public void afterSingletonsInstantiated() {
        // 所有插件Bean已加载，执行注册
        plugins.forEach((name, plugin) -> {
            plugin.register();
            System.out.println("插件注册: " + name);
        });
    }
}

SmartLifecycle对比

@Component
public class MySmartLifecycle implements SmartLifecycle {

    private boolean running = false;

    @Override
    public void start() {
        running = true;
        System.out.println("生命周期启动");
    }

    @Override
    public void stop() {
        running = false;
        System.out.println("生命周期停止");
    }

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

    @Override
    public int getPhase() {
        return 0;  // 控制启动顺序
    }
}

要点总结

• afterSingletonsInstantiated在所有单例Bean就绪后调用
• 适合需要等待其他Bean初始化的场景
• 与@PostConstruct时机不同，保证全局Bean可用
• 无生命周期概念，只执行一次
• SmartLifecycle提供完整生命周期控制