Bean lifecycle overview in Spring Boot - Mini Project: Build & Apply

Bean lifecycle overview

📖 Scenario: You are building a simple Spring Boot application that manages a bean representing a user service. You want to understand how Spring creates, initializes, and destroys beans during the application lifecycle.

🎯 Goal: Create a Spring Boot bean called UserService and demonstrate the bean lifecycle by adding initialization and destruction methods.

📋 What You'll Learn

Create a bean class named UserService

Add a method annotated with @PostConstruct for initialization

Add a method annotated with @PreDestroy for cleanup

Configure the bean in the Spring context using @Component

Create a main Spring Boot application class to run the context

💡 Why This Matters

🌍 Real World

Understanding bean lifecycle helps you manage resources like database connections or caches properly in real Spring applications.

💼 Career

Spring Boot is widely used in enterprise Java development; knowing bean lifecycle is essential for building robust and maintainable applications.

1

Create the UserService bean class

Create a class named UserService in package com.example.demo and annotate it with @Component.

Spring Boot

@Component
public class UserService {
    // Your code here
}

Hint

Use @Component to tell Spring this is a bean.

2

Add initialization method with @PostConstruct

Inside UserService, add a method named init annotated with @PostConstruct that prints "UserService initialized".

Spring Boot

package com.example.demo;

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

@Component
public class UserService {
    // Your code here
}

Hint

Use @PostConstruct to run code after bean creation.

3

Add destruction method with @PreDestroy

Inside UserService, add a method named cleanup annotated with @PreDestroy that prints "UserService destroyed".

Spring Boot

package com.example.demo;

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

@Component
public class UserService {
    @PostConstruct
    public void init() {
        System.out.println("UserService initialized");
    }
    // Your code here
}

Hint

Use @PreDestroy to run code before bean destruction.

4

Create main Spring Boot application class

Create a class named DemoApplication in package com.example.demo with @SpringBootApplication annotation and a main method that runs SpringApplication.run(DemoApplication.class, args).

Spring Boot

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    // Your code here
}

Hint

This class starts the Spring Boot application.

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