@Configuration and @Bean in Spring Boot - Step-by-Step Execution

Concept Flow - @Configuration and @Bean

Start Application

↓

Scan for @Configuration

↓

Create Configuration Class Instance

↓

Call @Bean Methods

↓

Register Returned Objects as Beans

↓

Beans Ready for Injection

↓

Application Runs with Beans

Spring Boot starts by scanning for classes marked @Configuration, then calls methods marked @Bean to create and register objects for use in the app.

Execution Sample

Spring Boot

@Configuration
public class AppConfig {
  @Bean
  public Service service() {
    return new Service();
  }
}

Defines a configuration class that creates a Service bean for the application context.

Execution Table

Step	Action	Evaluation	Result
1	Start Spring Boot application	Scan classes	Find AppConfig with @Configuration
2	Create instance of AppConfig	Instantiate class	AppConfig object created
3	Call service() method	Execute @Bean method	New Service object created
4	Register Service object	Add to Spring context	Service bean available
5	Inject Service bean where needed	Dependency injection	Service ready to use
6	Application runs	Beans used in app	App works with Service bean

💡 All @Bean methods called and beans registered; application context ready.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
AppConfig instance	null	created	created	created	created
Service bean	null	null	created	registered	available

Key Moments - 3 Insights

Why does Spring call the @Bean method only once?

Spring calls the @Bean method once to create a single shared bean instance, as shown in step 3 and 4 of the execution_table.

What happens if @Configuration is missing?

Without @Configuration, Spring does not treat the class as a source of beans, so @Bean methods are not called automatically (see step 1 in execution_table).

How does Spring know to inject the Service bean?

Spring registers the Service object as a bean (step 4) and injects it where needed by matching type or name during dependency injection (step 5).

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the Service bean created?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Check the 'Action' and 'Result' columns in step 3 where the Service object is created.

According to variable_tracker, what is the state of the Service bean after Step 4?

A null

B registered

C created

D available

💡 Hint

Look at the 'Service bean' row and the column 'After Step 4' in variable_tracker.

If @Configuration annotation is removed, which step in execution_table would fail?

A Step 3

B Step 2

C Step 1

D Step 5

💡 Hint

Step 1 shows scanning for @Configuration; without it, Spring won't find the config class.

Concept Snapshot

@Configuration marks a class as a source of bean definitions.
@Bean marks methods that create beans.
Spring calls @Bean methods once to create and register beans.
Beans are managed and injected by Spring automatically.
Without @Configuration, @Bean methods are not processed.

Full Transcript

When a Spring Boot application starts, it scans for classes annotated with @Configuration. These classes are special because they tell Spring where to find bean definitions. Spring creates an instance of the configuration class and then calls each method marked with @Bean exactly once. Each @Bean method returns an object that Spring registers as a bean in its application context. These beans are then ready to be injected wherever needed in the application. If the @Configuration annotation is missing, Spring will not recognize the class as a configuration source, so the @Bean methods will not be called, and no beans will be registered from that class.

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