Bean lifecycle overview in Spring Boot

Introduction

Beans are objects managed by Spring. Understanding their lifecycle helps you control how and when they are created, used, and destroyed.

When you want to customize how your objects start and stop in a Spring app

When you need to run some code right after a bean is created or before it is destroyed

When you want to manage resources like database connections safely

When you want to understand how Spring manages your app components behind the scenes

Syntax

Spring Boot

public class MyBean {

    // Initialization method
    public void init() {
        // code to run after bean creation
    }

    // Destruction method
    public void destroy() {
        // code to run before bean destruction
    }
}

The init method runs after the bean is created and dependencies are set.

The destroy method runs before the bean is removed from the container.

Examples

Using @PostConstruct and @PreDestroy annotations to mark init and destroy methods.

Spring Boot

@Component
public class MyBean {

    @PostConstruct
    public void init() {
        System.out.println("Bean is initialized");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Bean is being destroyed");
    }
}

Implementing Spring interfaces to handle lifecycle callbacks.

Spring Boot

@Component
public class MyBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean is initialized");
    }

    @Override
    public void destroy() {
        System.out.println("Bean is being destroyed");
    }
}

Specifying init and destroy methods directly in the @Bean annotation.

Spring Boot

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

public class MyBean {
    public void init() {
        System.out.println("Bean initialized");
    }
    public void cleanup() {
        System.out.println("Bean destroyed");
    }
}

Sample Program

This Spring component prints messages when it is created and before it is destroyed, showing the bean lifecycle in action.

Spring Boot

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

@Component
public class SimpleBean {

    @PostConstruct
    public void init() {
        System.out.println("SimpleBean initialized");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("SimpleBean destroyed");
    }
}

Important Notes

Beans are created when the Spring container starts and destroyed when it shuts down.

Use @PostConstruct and @PreDestroy for simple lifecycle methods.

For prototype-scoped beans, Spring does not manage destruction automatically.

Summary

Spring beans have a lifecycle: creation, initialization, use, and destruction.

You can add code to run at init and destroy phases using annotations or interfaces.

Understanding this helps manage resources and app behavior cleanly.

Practice

1. Which of the following best describes the lifecycle of a Spring bean?

easy

A. Creation, initialization, use, and destruction

B. Compilation, execution, and garbage collection

C. Declaration, inheritance, and polymorphism

D. Loading, linking, and running

Solution

1. Step 1: Understand Spring bean lifecycle phases

   Spring beans go through creation, initialization, usage, and destruction phases during their lifecycle.

2. Step 2: Compare options with lifecycle phases

   Only Creation, initialization, use, and destruction correctly lists these phases. Other options describe unrelated programming concepts.

3. Final Answer:

   Creation, initialization, use, and destruction -> Option A

4. Quick Check:

   Bean lifecycle = Creation, init, use, destroy [OK]

Hint: Remember bean lifecycle phases: create, init, use, destroy [OK]

Common Mistakes:

• Confusing bean lifecycle with Java program lifecycle
• Mixing bean lifecycle with object-oriented concepts
• Thinking lifecycle only involves creation and destruction

2. Which annotation is used in Spring to run a method after a bean's properties have been set?

easy

A. @PostConstruct

B. @PreDestroy

C. @Autowired

D. @Bean

Solution

1. Step 1: Identify annotation for post-initialization

   @PostConstruct is the annotation used to mark a method to run after bean properties are set.

2. Step 2: Eliminate other annotations

   @PreDestroy runs before destruction, @Autowired injects dependencies, and @Bean defines a bean method.

3. Final Answer:

   @PostConstruct -> Option A

4. Quick Check:

   @PostConstruct runs after properties set [OK]

Hint: PostConstruct runs after init, PreDestroy before destroy [OK]

Common Mistakes:

• Confusing @PreDestroy with @PostConstruct
• Using @Autowired for lifecycle methods
• Thinking @Bean runs after initialization

3. Given this Spring bean code snippet, what will be printed when the bean is initialized?

@Component
public class MyBean {
  @PostConstruct
  public void init() {
    System.out.println("Bean initialized");
  }
}

medium

A. Bean destroyed

B. No output

C. Bean initialized

D. Compilation error

Solution

1. Step 1: Understand @PostConstruct behavior

   The method annotated with @PostConstruct runs after the bean is created and properties set, printing "Bean initialized".

2. Step 2: Check output possibilities

   Since the method prints a message on init, output will be "Bean initialized". No errors or destruction messages occur here.

3. Final Answer:

   Bean initialized -> Option C

4. Quick Check:

   @PostConstruct prints "Bean initialized" [OK]

Hint: PostConstruct method runs once after bean creation [OK]

Common Mistakes:

• Expecting output on bean destruction instead
• Thinking no output occurs without explicit call
• Confusing syntax causing compilation errors

4. What is wrong with this Spring bean code if the cleanup() method is never called?

@Component
public class MyBean {
  public void cleanup() {
    System.out.println("Cleaning up");
  }
}

medium

A. cleanup method should be static

B. Missing @PreDestroy annotation on cleanup method

C. Missing @PostConstruct annotation on cleanup method

D. cleanup method must return a value

Solution

1. Step 1: Identify lifecycle annotation for destruction

   The cleanup method should be annotated with @PreDestroy to run before bean destruction.

2. Step 2: Check other options for correctness

   @PostConstruct is for initialization, static or return value are not required for lifecycle methods.

3. Final Answer:

   Missing @PreDestroy annotation on cleanup method -> Option B

4. Quick Check:

   @PreDestroy needed to run cleanup before destroy [OK]

Hint: Use @PreDestroy to run code before bean destruction [OK]

Common Mistakes:

• Using @PostConstruct instead of @PreDestroy for cleanup
• Making cleanup static unnecessarily
• Expecting cleanup to run without annotation

5. You want to ensure a Spring bean runs a method both after initialization and before destruction. Which combination correctly achieves this?

hard

A. Implement InitializingBean interface only

B. Annotate the same method with both @PostConstruct and @PreDestroy

C. Use @Autowired on init method and @PreDestroy on destroy method

D. Annotate one method with @PostConstruct and another with @PreDestroy

Solution

1. Step 1: Understand lifecycle annotations usage

   @PostConstruct runs after initialization, @PreDestroy runs before destruction; they must be on separate methods.

2. Step 2: Evaluate other options

   Annotating the same method with both annotations is invalid. @Autowired is for injection, not lifecycle. Implementing InitializingBean interface only handles post-initialization but not destruction.

3. Final Answer:

   Annotate one method with @PostConstruct and another with @PreDestroy -> Option D

4. Quick Check:

   Separate methods with @PostConstruct and @PreDestroy [OK]

Hint: Use separate methods for init (@PostConstruct) and destroy (@PreDestroy) [OK]

Common Mistakes:

• Trying to use one method for both init and destroy
• Confusing @Autowired with lifecycle annotations
• Using InitializingBean interface only