Master Spring Boot Lifecycle: Init & Destroy Callbacks Explained

1. Introduction

Spring provides the InitializingBean and DisposableBean interfaces, which trigger afterPropertiesSet() and destroy() methods during bean initialization and destruction, respectively.

Beyond these, beans can implement the Lifecycle interface to participate in container‑driven start‑up and shutdown processes.

JSR‑250 annotations @PostConstruct and @PreDestroy are considered best practice for receiving lifecycle callbacks without coupling to Spring‑specific interfaces.

2. Initialization Callback

InitializingBean defines a single method that is called after Spring has populated bean properties: void afterPropertiesSet() throws Exception; Example:

public class PersonService implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("PersonService通过InitializingBean接口初始化...");
    }
}

Note: The official recommendation is to avoid InitializingBean because it tightly couples the bean to Spring. Prefer one of the following:

@PostConstruct annotation

Setting initMethod on @Bean Example using @PostConstruct:

public class PersonService {
    @PostConstruct
    private void init() {
        System.out.println("@PostConstruct init...");
    }
}

Example using initMethod:

@Bean(initMethod = "init")
public PersonService personService(){
    return new PersonService();
}

Note: The method referenced by initMethod must have no parameters but may return a value.

For time‑consuming initialization, the recommended approaches are implementing SmartInitializingSingleton or listening to ContextRefreshedEvent.

If a bean implements InitializingBean and also defines an @PostConstruct method and an initMethod, the execution order is:

@PostConstruct method InitializingBean.afterPropertiesSet() Custom

initMethod

3. Destruction Callback

Implementing DisposableBean provides a destroy() method that is invoked when the container shuts down: void destroy() throws Exception; Example:

public class PersonService implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean ... ");
    }
}

The destroy() method is called when ApplicationContext.close() is invoked.

Note: Like InitializingBean, DisposableBean is discouraged due to strong coupling. Preferred alternatives are:

@PreDestroy annotation

Specifying destroyMethod on @Bean Example using @PreDestroy:

public class PersonService {
    @PreDestroy
    private void destroy(){
        System.out.println("@PreDestroy ... ");
    }
}

Example using destroyMethod:

@Configuration
public class AppConfig {
    @Bean(destroyMethod = "destroy")
    public PersonService personService(){
        return new PersonService();
    }
}

Another option is implementing AutoCloseable:

public class PersonService implements AutoCloseable {
    @Override
    public void close(){
        System.out.println("释放资源");
        // TODO
    }
}

Spring also supports inferred destroy methods by specifying destroyMethod = "(inferred)" on a bean; the container will call a method named close or shutdown if present, provided the bean does not implement DisposableBean.