Spring Boot Beans

In Spring Boot, a bean is an object that is instantiated, configured, and managed by the Spring IoC container. Beans form the core of any Spring Boot application, enabling dependency injection (DI), loose coupling, and modular design.

What is a Spring Boot Bean?

A Spring Boot bean is:

• Any object managed by the Spring IoC container.
• Created automatically by Spring using annotations or manually through configuration.
• The foundation for DI, allowing Spring to inject dependencies automatically instead of creating objects manually using new.

Ways to create a bean:

• Using stereotype annotations: @Component, @Service, @Repository, @Controller, @RestController
• Using @Bean methods in @Configuration classes
• Auto-configuration beans provided by Spring Boot starters

Example:

@Service
public class UserService {
    public void createUser() {
        System.out.println("User created");
    }
}

Here, UserService is a Spring-managed bean that can be injected into other components.

Bean Scopes in Spring Boot

Bean scopes define the lifecycle and visibility of a bean.

Example – Singleton Bean:

@Component
@Scope("singleton")
public class MySingletonBean { }

Default scope is Singleton, which is ideal for shared services.

How Beans Are Created

In Spring Boot, beans are created and managed automatically by the Spring IoC container. Bean creation happens during application startup and follows a well-defined process.

1. Component Scanning (Automatic Bean Creation)

Spring Boot scans packages starting from the main class annotated with @SpringBootApplication.

It detects classes annotated with:

• @Component
• @Service
• @Repository
• @Controller
• @RestController

Example:

@Service
publicclassUserService {
}

➡️ Spring automatically creates a UserService bean.

2. Java Configuration using @Bean

Beans can be explicitly defined inside a @Configuration class.

Used when:

• You want more control
• You are configuring third-party classes

Example:

@Configuration
publicclassAppConfig {

@Bean
public RestTemplaterestTemplate() {
returnnewRestTemplate();
    }
}

➡️ Spring registers RestTemplate as a bean.

3. Auto-Configuration (Spring Boot Magic)

Spring Boot automatically creates beans based on:

• Classpath dependencies
• Existing beans
• Configuration properties

Examples:

• DataSource
• EntityManagerFactory
• DispatcherServlet

Powered by:

• @EnableAutoConfiguration
• spring.factories
• AutoConfiguration.imports

➡️ No manual configuration needed.

4. Conditional Bean Creation

Beans are created only if certain conditions are met.

Common conditions:

• @ConditionalOnClass
• @ConditionalOnMissingBean
• @ConditionalOnProperty

Example:

@Bean
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
public FeatureServicefeatureService() {
returnnewFeatureService();
}

5. Profile-Based Bean Creation

Beans can be loaded for specific environments.

Example:

@Service
@Profile("dev")
publicclassDevMailService {
}

➡️ Bean created only when spring.profiles.active=dev.

6. Lazy Bean Creation

Beans are created only when requested, not at startup.

@Component
@Lazy
publicclassReportService {
}

7. FactoryBean (Advanced)

Used when bean creation logic is complex.

@Component
publicclassMyFactoryimplementsFactoryBean<MyObject> {
public MyObjectgetObject() {
returnnewMyObject();
    }
}

Bean Creation Flow

ApplicationStarts
        ↓
ComponentScan / @Bean /Auto-Config
        ↓
BeanDefinitionsRegistered
        ↓
BeanInstantiation
        ↓
DependencyInjection
        ↓
Initialization (@PostConstruct)
        ↓
BeanReadyforUse

Dependency Injection (DI)

Spring Boot automatically injects dependencies into beans. DI types include:

Constructor Injection

@Service
public class OrderService {
    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Setter Injection

@Service
public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Field Injection

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;
}

Best Practice: Prefer constructor injection for mandatory dependencies to improve testability and immutability.

Bean Lifecycle in Spring Boot

Spring manages the full lifecycle of a bean:

1. Bean Definition – Spring reads metadata and registers the bean.
2. Bean Instantiation – Bean object is created.
3. Dependency Injection – Dependencies are injected.
4. Aware Interfaces – Bean can access Spring context using BeanNameAware, ApplicationContextAware.
5. BeanPostProcessor (Before Initialization) – Pre-initialization processing.
6. Initialization – Custom initialization via @PostConstruct or InitializingBean.
7. BeanPostProcessor (After Initialization) – Post-initialization processing.
8. Bean Ready for Use – Bean is fully initialized.
9. Destruction – Cleanup via @PreDestroy or DisposableBean.

Example:

@Component
public class MyBean {

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

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

Lazy vs Eager Beans

• Eager Beans (Default) – Created at container startup.
• Lazy Beans – Created only when first needed, reducing startup time for large applications.

@Component
@Lazy
public class LazyBean { }

Conditional Beans

Beans can be created conditionally based on properties or environment:

@Bean
@ConditionalOnProperty(name="feature.enabled", havingValue="true")
public FeatureService featureService() {
    return new FeatureService();
}

Auto-Wired Collections

Spring can inject all beans of a type into a collection:

@Autowired
private List<NotificationService> notificationServices;

This allows handling multiple implementations of a service interface.

Real-World Examples

Service Bean

@Service
public class EmailService implements NotificationService {
    public void notifyUser(String user) {
        System.out.println("Email sent to " + user);
    }
}

Controller Bean

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public String getUser(@PathVariable String id) {
        return "User ID: " + id;
    }
}

Best Practices

1. Use stereotype annotations for automatic scanning.
2. Prefer constructor injection for mandatory dependencies.
3. Keep beans stateless whenever possible.
4. Use @PostConstruct / @PreDestroy for initialization and cleanup.
5. Use singleton beans for shared resources.
6. Use prototype or request-scoped beans only when necessary.
7. Avoid circular dependencies; solve with @Lazy, events, or proper refactoring.
8. Use @ComponentScan wisely to avoid scanning unnecessary packages.

Conclusion

• Bean = Spring-managed object
• Spring handles creation, injection, lifecycle, and destruction
• Use @Component, @Service, @Repository, @Controller, @RestController for automatic scanning
• Use @Bean in @Configuration classes for manual definition
• Understand scopes, lifecycle, DI types, and conditional beans for building scalable and maintainable Spring Boot applications