@Configuration and @Bean in Spring Boot - Mini Project: Build & Apply

Using @Configuration and @Bean in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that needs a custom service bean to provide greetings. You want to configure this bean using Spring's @Configuration and @Bean annotations.

🎯 Goal: Create a Spring Boot configuration class that defines a bean of type GreetingService. This bean will be used to provide greeting messages in the application.

📋 What You'll Learn

Create a class annotated with @Configuration

Define a method annotated with @Bean that returns a GreetingService instance

The GreetingService class should have a method getGreeting() returning a greeting string

Use the bean method to return a new GreetingService object

💡 Why This Matters

🌍 Real World

Spring Boot applications use @Configuration and @Bean to manage and configure components and services cleanly and flexibly.

💼 Career

Understanding how to define and use beans with @Configuration and @Bean is essential for backend Java developers working with Spring Boot.

1

Create the GreetingService class

Create a public class called GreetingService with a public method getGreeting() that returns the string "Hello, Spring!".

Spring Boot

# Create the GreetingService class with getGreeting() method
// Your code here

Hint

Define a simple class with a method that returns a fixed greeting string.

2

Create a configuration class with @Configuration

Create a public class called AppConfig and annotate it with @Configuration.

Spring Boot

public class GreetingService {
    public String getGreeting() {
        return "Hello, Spring!";
    }
}

// Create AppConfig class annotated with @Configuration
// Your code here

Hint

Use @Configuration annotation from Spring to mark the class as a configuration.

3

Define a @Bean method returning GreetingService

Inside the AppConfig class, create a public method called greetingService() annotated with @Bean that returns a new instance of GreetingService.

Spring Boot

import org.springframework.context.annotation.Configuration;

public class GreetingService {
    public String getGreeting() {
        return "Hello, Spring!";
    }
}

@Configuration
public class AppConfig {
    // Add @Bean method greetingService() here
    // Your code here
}

Hint

Use @Bean annotation on a method that returns a new GreetingService object.

4

Use the GreetingService bean in a component

Create a public class called GreetingPrinter with a private final GreetingService field. Add a constructor that accepts a GreetingService parameter and assigns it to the field. Add a public method printGreeting() that returns the result of greetingService.getGreeting().

Spring Boot

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

public class GreetingService {
    public String getGreeting() {
        return "Hello, Spring!";
    }
}

@Configuration
public class AppConfig {
    @Bean
    public GreetingService greetingService() {
        return new GreetingService();
    }
}

// Create GreetingPrinter class with constructor injection and printGreeting() method
// Your code here

Hint

Create a class that uses the GreetingService bean by constructor injection and calls its method.

Practice

1. What is the main purpose of the @Configuration annotation in Spring Boot?

easy

A. To enable automatic component scanning

B. To mark a method that returns a bean instance

C. To mark a class as a source of bean definitions for the application context

D. To configure database connections automatically

Solution

1. Step 1: Understand the role of @Configuration

   @Configuration tells Spring that this class contains methods to create beans.

2. Step 2: Differentiate from other annotations

   @Bean marks methods, not classes; component scanning is done by @ComponentScan; database config is separate.

3. Final Answer:

   To mark a class as a source of bean definitions for the application context -> Option C

4. Quick Check:

   @Configuration = class for beans [OK]

Hint: Remember: @Configuration is for classes, @Bean is for methods [OK]

Common Mistakes:

• Confusing @Configuration with @Bean
• Thinking @Configuration enables scanning
• Assuming it configures databases automatically

2. Which of the following is the correct way to define a bean method inside a @Configuration class?

easy

A. @Bean public MyBean myBean() { return new MyBean(); }

B. @Configuration public MyBean myBean() { return new MyBean(); }

C. public void createBean() { return new MyBean(); }

D. @Component public MyBean myBean() { return new MyBean(); }

Solution

1. Step 1: Check method signature for bean creation

   Bean methods must be annotated with @Bean and return the bean object.

2. Step 2: Verify syntax correctness

   @Bean public MyBean myBean() { return new MyBean(); } correctly uses @Bean and returns a new instance.

3. Final Answer:

   @Bean public MyBean myBean() { return new MyBean(); } -> Option A

4. Quick Check:

   @Bean + return bean instance = correct method [OK]

Hint: Bean methods need @Bean and must return the object [OK]

Common Mistakes:

• Missing @Bean annotation
• Using void return type
• Using @Configuration on methods

3. Given the following code, what will be the output when retrieving the bean named "service" from the Spring context?

@Configuration
public class AppConfig {
  @Bean
  public String service() {
    return "MyService";
  }
}

medium

A. "service"

B. "MyService"

C. An exception is thrown

D. null

Solution

1. Step 1: Identify the bean method and its return value

   The method named service returns the string "MyService" and is annotated with @Bean.

2. Step 2: Understand bean retrieval by name

   Spring registers this bean with the name "service" and returns the method's return value when requested.

3. Final Answer:

   "MyService" -> Option B

4. Quick Check:

   Bean name returns method's return value [OK]

Hint: Bean name matches method name; returns method's return value [OK]

Common Mistakes:

• Expecting bean name as output instead of return value
• Thinking Spring returns null if no explicit name
• Assuming exception without error in code

4. Identify the error in the following Spring configuration code:

@Configuration
public class Config {
  @Bean
  public void createBean() {
    // no return statement
  }
}

medium

A. Method must return an object, not void

B. Missing @Configuration annotation

C. Method name cannot be createBean

D. No error, code is correct

Solution

1. Step 1: Check method return type for @Bean

   Bean methods must return the bean object; void return type is invalid.

2. Step 2: Confirm annotations and method name

   @Configuration is present; method name can be anything; error is only return type.

3. Final Answer:

   Method must return an object, not void -> Option A

4. Quick Check:

   @Bean method needs return value, not void [OK]

Hint: Bean methods must return an object, never void [OK]

Common Mistakes:

• Using void return type for @Bean methods
• Confusing method name restrictions
• Missing @Configuration annotation (not in this case)

5. You want to create two beans of the same type but with different configurations using @Bean methods inside a @Configuration class. How can you ensure Spring distinguishes between them when injecting?

hard

A. Define both beans in separate @Configuration classes only

B. Use @Primary on both methods

C. Use the same method name but different return types

D. Use different method names for each @Bean method

Solution

1. Step 1: Understand bean naming in Spring

   By default, Spring uses the @Bean method name as the bean name to distinguish beans.

2. Step 2: Differentiate beans of same type

   Using different method names creates distinct bean names, allowing injection by name or qualifier.

3. Final Answer:

   Use different method names for each @Bean method -> Option D

4. Quick Check:

   Different method names = different bean names [OK]

Hint: Different method names create distinct bean names automatically [OK]

Common Mistakes:

• Using @Primary on both beans (conflicts)
• Same method name with different return types (not allowed)
• Thinking beans must be in separate classes