Java生命周期管理API有了吗

本文目录导读：

1. Jakarta EE (原Java EE) 的 @PostConstruct/@PreDestroy
2. Spring Framework 的多种生命周期接口
3. Java 9+ 的 AutoCloseable 结合 try-with-resources
4. Micronaut / Quarkus 等现代框架
5. Java 21 虚拟线程 + 结构化的并发

Java 的生命周期管理API确实已经有了，并且已经比较成熟，这通常指的不是单个的API，而是一个设计模式和框架层面的约定，主要在以下几个层面实现：

Jakarta EE (原Java EE) 的 @PostConstruct/@PreDestroy

这是最经典、最广泛支持的生命周期管理API。

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import jakarta.ejb.Singleton;
import jakarta.ejb.Startup;
@Singleton
@Startup
public class ApplicationInitializer {
    @PostConstruct
    public void init() {
        System.out.println("Bean 初始化完成，开始加载配置...");
        // 执行初始化逻辑
    }
    @PreDestroy
    public void cleanup() {
        System.out.println("应用关闭，清理资源...");
        // 执行清理逻辑
    }
}

适用场景： Jakarta EE容器（如WildFly, Payara, TomEE）

Spring Framework 的多种生命周期接口

Spring 提供了非常完善的Bean生命周期管理方案：

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
@Component
public class LifecycleBean implements InitializingBean, DisposableBean {
    // 方式1：实现接口
    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean: 属性设置完成后调用");
    }
    @Override
    public void destroy() {
        System.out.println("DisposableBean: Bean销毁前调用");
    }
    // 方式2：注解方式（推荐）
    @PostConstruct
    public void initMethod() {
        System.out.println("@PostConstruct: 构造方法后，依赖注入完成后调用");
    }
    @PreDestroy
    public void preDestroyMethod() {
        System.out.println("@PreDestroy: Bean销毁前调用");
    }
    // 方式3：配置方法名（XML或@Bean的initMethod/destroyMethod）
    public void customInit() { /* ... */ }
    public void customDestroy() { /* ... */ }
}

Spring Boot 2.5+ 还引入了 SmartLifecycle：

@Component
public class MySmartLifecycle implements SmartLifecycle {
    private boolean running = false;
    @Override
    public void start() {
        System.out.println("SmartLifecycle: 启动...");
        running = true;
    }
    @Override
    public void stop() {
        System.out.println("SmartLifecycle: 停止...");
        running = false;
    }
    @Override
    public boolean isRunning() {
        return running;
    }
    @Override
    public int getPhase() {
        return 0; // 控制启动/停止顺序
    }
}

Java 9+ 的 AutoCloseable 结合 try-with-resources

虽然不是严格意义上的"容器生命周期管理"，但这是Java语言内置的资源生命周期管理API：

public class ResourceManager implements AutoCloseable {
    public ResourceManager() {
        System.out.println("资源分配...");
    }
    @Override
    public void close() {
        System.out.println("资源释放（即使发生异常也会执行）...");
    }
    public void doWork() {
        System.out.println("执行任务...");
    }
    public static void main(String[] args) {
        // try-with-resources 确保自动关闭
        try (ResourceManager rm = new ResourceManager()) {
            rm.doWork();
        }
        // 离开try块时自动调用close()
    }
}

Micronaut / Quarkus 等现代框架

新一代Java框架也提供了生命周期管理：

// Micronaut
import jakarta.annotation.PostConstruct;
import jakarta.inject.Singleton;
@Singleton
public class MicronautService {
    @PostConstruct
    void init() {
        System.out.println("Micronaut: Bean初始化");
    }
    @javax.annotation.PreDestroy
    void cleanup() {
        System.out.println("Micronaut: Bean销毁");
    }
}

// Quarkus （支持CDI）
import jakarta.enterprise.context.ApplicationScoped;
import io.quarkus.runtime.Startup;
import io.quarkus.runtime.Shutdown;
@ApplicationScoped
@Startup
public class QuarkusAppLifecycle {
    void onStart(@Observes StartupEvent ev) {
        System.out.println("Quarkus: 应用启动完成");
    }
    void onStop(@Observes ShutdownEvent ev) {
        System.out.println("Quarkus: 应用关闭");
    }
}

Java 21 虚拟线程 + 结构化的并发

Java 21 引入了结构化的并发，也提供了生命周期管理概念：

import java.util.concurrent.StructuredTaskScope;
public class StructuredConcurrencyExample {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope<Void>()) {
            scope.fork(() -> {
                System.out.println("子任务启动");
                // 业务逻辑
                return null;
            });
            // 所有fork的任务完成后自动清理
            scope.join();
        }
        // 离开try块时，所有子任务自动取消/清理
    }
}

对于99%的Java开发者来说，@PostConstruct 和 @PreDestroy 就是最标准、最通用的生命周期管理API，它们被 Jakarta EE 规范标准化，并被几乎所有主流Java框架（Spring、Micronaut、Quarkus、TomEE等）支持。