@PostConstruct and @PreDestroy in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark a method that runs after the bean is created.

Spring Boot

public class MyService {
    [1]
    public void init() {
        System.out.println("Bean initialized");
    }
}

Drag options to blanks, or click blank then click option'

A@Service

B@PreDestroy

C@Autowired

D@PostConstruct

Attempts:

3 left

💡 Hint

Common Mistakes

Using @PreDestroy instead of @PostConstruct

Forgetting to import the annotation

Placing the annotation on the class instead of the method

The @PostConstruct annotation marks a method to be run after the bean is created and dependencies are injected.

2fill in blank

medium

Complete the code to mark a method that runs before the bean is destroyed.

Spring Boot

public class MyService {
    [1]
    public void cleanup() {
        System.out.println("Bean is being destroyed");
    }
}

Drag options to blanks, or click blank then click option'

A@PreDestroy

B@PostConstruct

C@Bean

D@Component

Attempts:

3 left

💡 Hint

Common Mistakes

Using @PostConstruct instead of @PreDestroy

Not having a method with void return type

Placing the annotation on a static method

The @PreDestroy annotation marks a method to be run just before the bean is destroyed, useful for cleanup.

3fill in blank

hard

Fix the error in the code by choosing the correct annotation for the method that runs after bean creation.

Spring Boot

public class ResourceLoader {
    public void load() {
        System.out.println("Loading resources");
    }

    [1]
    public void init() {
        load();
    }
}

Drag options to blanks, or click blank then click option'

A@Autowired

B@PreDestroy

C@PostConstruct

D@Service

Attempts:

3 left

💡 Hint

Common Mistakes

Using @PreDestroy which runs before bean destruction

Missing the annotation causing the method not to run automatically

The init() method should be annotated with @PostConstruct to run after the bean is created.

4fill in blank

hard

Fill both blanks to correctly annotate methods for initialization and cleanup in a Spring bean.

Spring Boot

public class ConnectionManager {
    [1]
    public void start() {
        System.out.println("Connection started");
    }

    [2]
    public void stop() {
        System.out.println("Connection stopped");
    }
}

Drag options to blanks, or click blank then click option'

A@PostConstruct

B@Autowired

C@PreDestroy

D@Component

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the annotations between methods

Using @Autowired instead of lifecycle annotations

The start() method uses @PostConstruct to run after bean creation, and stop() uses @PreDestroy to run before destruction.

5fill in blank

hard

Fill all three blanks to create a Spring bean with proper lifecycle methods for initialization and destruction.

Spring Boot

import jakarta.annotation.[1];
import jakarta.annotation.[2];

public class CacheService {

    [3]
    public void setup() {
        System.out.println("Cache setup complete");
    }

    @PreDestroy
    public void clear() {
        System.out.println("Cache cleared");
    }
}

Drag options to blanks, or click blank then click option'

APostConstruct

BPreDestroy

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Importing wrong packages

Forgetting to annotate setup() with @PostConstruct

Using @Component as an annotation for methods

The imports must include PostConstruct and PreDestroy. The setup() method is annotated with @PostConstruct to run after bean creation.

Practice

1. What is the main purpose of the @PostConstruct annotation in a Spring Boot application?

easy

A. To run a method immediately after the bean is created and dependencies are injected

B. To mark a method that should run before the bean is destroyed

C. To define a method that runs only when the application starts

D. To schedule a method to run repeatedly at fixed intervals

Solution

1. Step 1: Understand the role of @PostConstruct

   @PostConstruct is used to run initialization code after the Spring bean is fully created and dependencies are set.

2. Step 2: Compare with other lifecycle annotations

   @PreDestroy runs before bean removal, and scheduling annotations run repeatedly, so they don't match @PostConstruct's purpose.

3. Final Answer:

   To run a method immediately after the bean is created and dependencies are injected -> Option A

4. Quick Check:

   @PostConstruct = run after bean creation [OK]

Hint: Remember: PostConstruct runs right after bean setup [OK]

Common Mistakes:

• Confusing @PostConstruct with @PreDestroy
• Thinking @PostConstruct runs before bean creation
• Assuming it schedules repeated tasks

2. Which of the following is the correct way to use @PreDestroy in a Spring Boot bean?

easy

A. Place @PreDestroy on a static method to run after application shutdown

B. Annotate a method with @PreDestroy to run cleanup code before bean destruction

C. Use @PreDestroy on a constructor to initialize resources

D. Annotate the class with @PreDestroy to mark it for destruction

Solution

1. Step 1: Identify correct usage of @PreDestroy

   @PreDestroy is placed on a method to run cleanup code before the bean is destroyed.

2. Step 2: Eliminate incorrect options

   @PreDestroy cannot annotate a class or constructor, and static methods are not lifecycle callbacks.

3. Final Answer:

   Annotate a method with @PreDestroy to run cleanup code before bean destruction -> Option B

4. Quick Check:

   @PreDestroy = method cleanup before bean removal [OK]

Hint: Use @PreDestroy only on instance methods for cleanup [OK]

Common Mistakes:

• Annotating the class instead of a method
• Using @PreDestroy on constructors
• Marking static methods with @PreDestroy

3. Consider the following Spring Boot bean code snippet:

public class MyBean {

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

    @PreDestroy
    public void cleanup() {
        System.out.println("Bean is about to be destroyed");
    }

}

What will be printed when the application context starts and then shuts down?

medium

A. Bean is about to be destroyedBean is initialized

B. Only Bean is initialized

C. Bean is initializedBean is about to be destroyed

D. Only Bean is about to be destroyed

Solution

1. Step 1: Understand @PostConstruct behavior on startup

   The init() method runs after bean creation, printing "Bean is initialized" when the app context starts.

2. Step 2: Understand @PreDestroy behavior on shutdown

   The cleanup() method runs before bean destruction, printing "Bean is about to be destroyed" when the app context shuts down.

3. Final Answer:

   Bean is initialized
   Bean is about to be destroyed -> Option C

4. Quick Check:

   Startup prints init, shutdown prints cleanup [OK]

Hint: PostConstruct runs on start, PreDestroy runs on shutdown [OK]

Common Mistakes:

• Mixing order of printed messages
• Expecting only one message to print
• Thinking @PreDestroy runs on startup

4. Given this Spring Boot bean code:

public class ResourceBean {

    @PostConstruct
    public void setup() {
        System.out.println("Setup resources");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Cleanup resources");
    }

    public void start() {
        System.out.println("Start method called");
    }

}

When running the application, the developer notices that "Cleanup resources" is never printed on shutdown. What is the most likely cause?

medium

A. The @PostConstruct method prevents @PreDestroy from running

B. The @PreDestroy method must be static to run correctly

C. The cleanup() method must be called manually to run

D. The bean is not managed by Spring, so lifecycle annotations are ignored

Solution

1. Step 1: Check if bean is managed by Spring

   @PostConstruct and @PreDestroy only work if Spring manages the bean lifecycle (e.g., via @Component or @Bean).

2. Step 2: Understand why cleanup isn't called

   If the bean is created manually (new keyword), Spring won't call lifecycle methods, so cleanup() won't run automatically.

3. Final Answer:

   The bean is not managed by Spring, so lifecycle annotations are ignored -> Option D

4. Quick Check:

   Lifecycle annotations need Spring-managed beans [OK]

Hint: Lifecycle methods run only on Spring-managed beans [OK]

Common Mistakes:

• Thinking @PreDestroy must be static
• Assuming @PostConstruct blocks @PreDestroy
• Believing cleanup() runs without Spring management

5. You want to ensure a Spring Boot bean opens a database connection after creation and closes it before destruction. Which code snippet correctly uses @PostConstruct and @PreDestroy to achieve this?

hard

A. public class DbBean {

private Connection conn;

@PostConstruct
public void open() {
conn = DriverManager.getConnection("url");
System.out.println("Connection opened");
}

@PreDestroy
public void close() {
conn.close();
System.out.println("Connection closed");
}

}

B. public class DbBean {

private Connection conn;

public void open() {
conn = DriverManager.getConnection("url");
System.out.println("Connection opened");
}

public void close() {
conn.close();
System.out.println("Connection closed");
}

}

C. public class DbBean {

private Connection conn;

@PreDestroy
public void open() {
conn = DriverManager.getConnection("url");
System.out.println("Connection opened");
}

@PostConstruct
public void close() {
conn.close();
System.out.println("Connection closed");
}

}

D. public class DbBean {

private Connection conn;

@PostConstruct
public void open() {
System.out.println("Connection opened");
}

@PreDestroy
public void close() {
System.out.println("Connection closed");
}

}

Solution

1. Step 1: Identify correct lifecycle method usage

   @PostConstruct should open the connection after bean creation; @PreDestroy should close it before destruction.

2. Step 2: Check code correctness

   public class DbBean { private Connection conn; @PostConstruct public void open() { conn = DriverManager.getConnection("url"); System.out.println("Connection opened"); } @PreDestroy public void close() { conn.close(); System.out.println("Connection closed"); } } correctly uses @PostConstruct to open and @PreDestroy to close the connection with proper method calls.

3. Final Answer:

   public class DbBean { private Connection conn; @PostConstruct public void open() { conn = DriverManager.getConnection("url"); System.out.println("Connection opened"); } @PreDestroy public void close() { conn.close(); System.out.println("Connection closed"); } } -> Option A

4. Quick Check:

   Open after creation, close before destruction [OK]

Hint: Open in @PostConstruct, close in @PreDestroy for resource management [OK]

Common Mistakes:

• Swapping @PostConstruct and @PreDestroy methods
• Not calling connection methods inside lifecycle methods
• Missing lifecycle annotations on resource methods