Bean concept in Spring in Spring Boot - Performance & Optimization

Performance: Bean concept in Spring

MEDIUM IMPACT

This concept affects application startup time and memory usage by managing object creation and lifecycle.

Managing object creation and lifecycle in a Spring application

Spring Boot

@Component
public class Service {
  private final Repository repo;

  public Service(Repository repo) {
    this.repo = repo;
  }
}

@Component
public class Repository {}

Spring container manages single instances (singleton scope by default), optimizing memory and startup.

📈 Performance GainReduces memory footprint and improves startup efficiency by reusing beans

Managing object creation and lifecycle in a Spring application

Spring Boot

public class Service {
  private final Repository repo = new Repository();
  // manual new object creation without Spring
}

Manually creating objects bypasses Spring's container, causing duplicated instances and no lifecycle management.

📉 Performance CostIncreases memory usage and startup time due to unmanaged objects

Performance Comparison

Pattern	Bean Creation	Memory Usage	Startup Time	Verdict
Manual object creation	Multiple unmanaged instances	High due to duplicates	Longer due to no container optimization	[X] Bad
Spring-managed singleton beans	Single shared instance	Optimized minimal usage	Faster due to container control	[OK] Good
Eager loading many beans	All beans created at startup	Moderate to high	Slower startup	[!] OK
Lazy initialization beans	Created on demand	Lower initial memory	Faster startup	[OK] Good

Rendering Pipeline

Spring's bean lifecycle affects application initialization, where beans are created, wired, and initialized before serving requests.

→Bean Creation

→Dependency Injection

→Initialization

⚠️ BottleneckBean Creation stage can delay startup if many beans are eagerly created

Optimization Tips

1Use Spring-managed singleton beans to minimize memory and startup time.

2Enable lazy initialization to defer bean creation and speed up startup.

3Avoid manual object creation to prevent memory bloat and lifecycle issues.

Performance Quiz - 3 Questions

What is the main performance benefit of using Spring-managed singleton beans?

A They reduce memory usage by sharing instances

B They increase startup time by creating many objects

C They disable dependency injection

D They force manual object creation

DevTools: Spring Boot Actuator and Java VisualVM

How to check: Use Actuator endpoints to check bean counts and VisualVM to monitor memory and CPU during startup

What to look for: Look for high memory usage or long startup times indicating inefficient bean management

Practice

1. What is a Bean in the Spring framework?

easy

A. A type of Java exception

B. A database connection

C. An object managed by the Spring container

D. A user interface component

Solution

1. Step 1: Understand Spring's role

   Spring manages objects to help organize and connect parts of an application.

2. Step 2: Define what a Bean is

   A Bean is any object that Spring creates and manages in its container.

3. Final Answer:

   An object managed by the Spring container -> Option C

4. Quick Check:

   Bean = Managed object [OK]

Hint: Beans are Spring-managed objects, not UI or exceptions [OK]

Common Mistakes:

• Confusing beans with database connections
• Thinking beans are UI elements
• Assuming beans are exceptions

2. Which annotation is used to declare a class as a Spring Bean?

easy

A. @Qualifier

B. @Component

C. @Autowired

D. @RequestMapping

Solution

1. Step 1: Identify annotations for beans

   @Component marks a class as a Spring-managed bean.

2. Step 2: Differentiate from other annotations

   @Qualifier specifies which bean to inject, @Autowired injects beans, @RequestMapping maps web requests.

3. Final Answer:

   @Component -> Option B

4. Quick Check:

   @Component = Bean declaration [OK]

Hint: Use @Component to declare beans; others serve different roles [OK]

Common Mistakes:

• Confusing @Autowired with bean declaration
• Using @RequestMapping for beans
• Thinking @Qualifier declares beans

3. Given the code below, what will be printed (assuming the @Autowired field and System.out.println are inside a Spring-managed class)?

@Component
public class MyBean {
  public String greet() { return "Hello Spring"; }
}

@Autowired
MyBean myBean;

System.out.println(myBean.greet());

medium

A. Hello Spring

B. null

C. Compilation error

D. No output

Solution

1. Step 1: Understand @Component and @Autowired

   @Component creates the bean, @Autowired injects it into the field.

2. Step 2: Check method call output

   Calling greet() returns "Hello Spring", so it prints that string.

3. Final Answer:

   Hello Spring -> Option A

4. Quick Check:

   Injected bean method returns greeting [OK]

Hint: Autowired injects bean; method returns greeting string [OK]

Common Mistakes:

• Assuming null because of missing initialization
• Thinking it causes compile error
• Expecting no output without System.out.println

4. What is wrong with this Spring bean declaration?

@Component
public class MyService {
  @Autowired
  private MyRepository repo;

  public void doWork() {
    repo.save();
  }
}

Assuming MyRepository is not annotated as a bean.

medium

A. No @Autowired on MyService class

B. Missing @Service annotation on MyService

C. Method doWork() should return a value

D. MyRepository is not a Spring bean, so injection fails

Solution

1. Step 1: Check bean injection requirements

   Spring can only inject beans that are managed by the container.

2. Step 2: Identify missing bean annotation

   MyRepository lacks @Component or similar, so Spring cannot inject it.

3. Final Answer:

   MyRepository is not a Spring bean, so injection fails -> Option D

4. Quick Check:

   Injection requires bean annotation [OK]

Hint: Injected classes must be beans too [OK]

Common Mistakes:

• Thinking @Service is mandatory for injection
• Assuming method must return value
• Confusing @Autowired placement

5. You want to create a bean that returns a customized object. Which method correctly defines a bean using Java configuration?

hard

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

B. @Component
public MyBean myBean() {
return new MyBean("custom");
}

C. public MyBean myBean() {
return new MyBean("custom");
}

D. @Autowired
public MyBean myBean() {
return new MyBean("custom");
}

Solution

1. Step 1: Understand @Bean usage

   @Bean annotation on a method inside a @Configuration class defines a bean returned by that method.

2. Step 2: Differentiate from other annotations

   @Component is for classes, not methods; @Autowired injects dependencies, not defines beans.

3. Final Answer:

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

4. Quick Check:

   @Bean method returns custom bean [OK]

Hint: Use @Bean on methods inside @Configuration classes [OK]

Common Mistakes:

• Using @Component on methods instead of classes
• Omitting @Bean annotation
• Confusing @Autowired with bean creation