In Spring, the lifecycle of a bean can be managed, and you can hook into these lifecycle phases using annotations like @PostConstruct and @PreDestroy.

1. @PostConstruct:
   • This annotation is part of Jakarta annotations (not proprietary to Spring).
   • It is used to execute initialization logic after the bean’s properties have been set (i.e., after dependency injection is complete).
2. @PreDestroy:
   • This annotation is also part of Jakarta annotations.
   • It is used to define a clean-up method that Spring calls before the bean is destroyed, typically during application shutdown.

To use these annotations in a Spring-managed bean:

Example with a Spring Bean:

package org.kodejava.spring;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    public MyBean() {
        System.out.println("MyBean constructor called");
    }

    @PostConstruct
    public void init() {
        System.out.println("MyBean @PostConstruct called: Initialization logic here");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("MyBean @PreDestroy called: Cleanup logic here");
    }
}

Explanation:

1. Constructor: When the bean is instantiated by Spring, the constructor is called.
2. @PostConstruct (Initialization logic): Once the bean is instantiated and its dependencies are injected, this annotated method is invoked automatically.
3. @PreDestroy (Cleanup logic): Before the bean is destroyed (typically when the application context is being closed), this annotated method is invoked automatically.

Notes:

• Newer versions of Spring Boot automatically include this dependency.
• If you’re working on Spring Boot, your application supports these lifecycle callbacks out of the box.

Alternative for Lifecycle Management:

You can also achieve similar functionality using Spring’s InitializingBean and DisposableBean interfaces or by explicitly configuring init and destroy methods in the bean definitions.

package org.kodejava.spring;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class MyBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MyBean initializing using InitializingBean");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("MyBean destroying using DisposableBean");
    }
}

However, using @PostConstruct and @PreDestroy is generally preferred because they are more concise and not tightly coupled to Spring APIs.

---

Maven Dependencies

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.2.6</version>
    </dependency>
    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>