Spring @Bean initMethod and destroyMethod Attributes

In this tutorial, we will explore how to use the initMethod and destroyMethod attributes of the @Bean annotation in Spring to specify initialization and destruction methods. These attributes allow us to define methods that will be called after bean properties have been set and before the bean is destroyed, without implementing the InitializingBean or DisposableBean interfaces.

Introduction

The @Bean annotation in Spring provides a way to declare a bean along with its initialization and destruction methods. This is useful for performing custom logic during bean initialization and cleanup.

Why Use initMethod and destroyMethod?

initMethod: Allows you to specify a method to be called after the bean has been instantiated and its properties have been set.
destroyMethod: Allows you to specify a method to be called before the bean is destroyed, providing a way to release resources or perform other cleanup tasks.

Project Setup

Step 1: Create a Spring Boot Project

Using Spring Initializr:
- Go to Spring Initializr.
- Select the following options:
  - Project: Maven Project
  - Language: Java
  - Spring Boot: 3.3.0
- Add dependencies:
  - Spring Web
- Click on Generate to download the project.
Import the project into your favorite IDE (Eclipse, IntelliJ, etc.).

Step 2: Create Bean Class with Initialization and Destruction Methods

Create a class MyBean with custom initialization and destruction methods.

MyBean.java

package net.javaguides.spring.lifecycle;

public class MyBean {

    public void customInit() {
        // Custom initialization logic
        System.out.println("MyBean: customInit method called");
    }

    public void customDestroy() {
        // Custom cleanup logic
        System.out.println("MyBean: customDestroy method called");
    }
}

Step 3: Create Configuration Class with @Bean Annotation

Create a configuration class to define the bean using the @Bean annotation with initMethod and destroyMethod attributes.

AppConfig.java

package net.javaguides.spring.lifecycle;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public MyBean myBean() {
        return new MyBean();
    }
}

Step 4: Create the Main Application Class

Create a main class to run your Spring Boot application.

SpringLifecycleApplication.java

package net.javaguides.spring.lifecycle;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

@SpringBootApplication
public class SpringLifecycleApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class);

        context.close();
    }
}

Step 5: Run the Application

Run the SpringLifecycleApplication class as a Java application. You should see the following output in the console:

MyBean: customInit method called

Step 6: Shut Down the Application

When you shut down the application (e.g., by stopping the Spring Boot application in your IDE), you should see the following output in the console:

MyBean: customDestroy method called

Explanation

MyBean: Contains custom initialization and destruction methods customInit and customDestroy.
AppConfig: Defines a bean using the @Bean annotation with initMethod and destroyMethod attributes to specify the initialization and destruction methods.
SpringLifecycleApplication: Runs the Spring Boot application and closes the context to trigger the destruction of the bean.

Best Practices

Method Naming: Use meaningful names for initialization and destruction methods to make the code more readable and maintainable.
Annotations: While initMethod and destroyMethod attributes are useful, consider using @PostConstruct and @PreDestroy annotations for a more concise and modern approach.

Conclusion

In this tutorial, we have learned how to use the initMethod and destroyMethod attributes of the @Bean annotation in Spring for managing bean lifecycle events. We have seen how to create a simple Spring Boot application to demonstrate their usage and discussed best practices for their use.

This approach ensures that your beans are properly initialized and cleaned up, making your application more robust and maintainable.

Java Guides

Search This Blog