The @Component annotation serves as a generic marker for any class requiring Spring container management. Applied to POJOs, service layers, or persistence entities, it triggers automatic instantiation and registration in the IoC container.

Conversely, @Bean declares a managed object within configuration classes. Placed on methods, it registers the return value as a bean, enabling precise control over instantiation, scoping, and dependencies.

Key Distinctions:

• Purpose: @Component identifies classes for auto-detection; @Bean defines objects from method outputs
• Application: @Component uses class-level scanning; @Bean employs method-level configuraton
• Control: @Component delegates creation to Spring; @Bean permits manual instantiation

// @Component usage
@Component
public class InventoryService { }

// @Bean usage
@Configuration
public class AppSetup {
    @Bean
    public InventoryService inventoryManager() {
        return new InventoryService();
    }
}

Proxy Implementation in Spring Boot

Spring Boot prefers CGLIB over JDK dynamic proxies due to:

• Interface Flexibility: Generates subclass proxies assignable to interfaces or concrete types
• Performance Gains: Bytecode manipulation typically outperforms reflection-based proxies
• Enhanced Control: Provides granular configuration options for complex scenarios

Creating Custom Starters

Implement a starter by:

1. Packaging reusable components and configurations
2. Including auto-configuration classes
3. Registering configurations via META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@AutoConfiguration
public class CustomAutoConfig {
    @Bean
    public FeatureModule featureProvider() {
        return new FeatureModule();
    }
}

Spring MVC Processing Flow

1. Client request reaches DispatcherServlet
2. Handler mapping identifies controller
3. Adapter executes controller method
4. Controller returns ModelAndView
5. View resolver processes template
6. Response rendered to client

Spring Framework Benefits

• Lightweight: Minimal footprint (~2MB core)
• IoC Container: Manages object lifecycle and dependencies
• AOP Support: Decouples cross-cutting concerns
• Declarative Transactions: Unified transaction management
• Integrated Ecosystem: Comprehansive toolset for enterprise apps

Convention Over Configuration

Defaults eliminate boilerplate:

• Starter POMs manage dependencies
• Embedded servers (Tomcat/Jetty)
• Auto-configuration via classpath scanning
• Standard property files (application.yml)

Thread-Safe Beans

Mitigate singleton risks by:

• Switching to prototype scope
• Eliminating mutable instance variables
• Using thread-local storage or concurrent collections
• Applying synchronization primitives

@Scope("prototype")
@Component
public class StatelessProcessor { }

Bean Registration Methods

1. Annotation scanning (@Component, @Service)
2. XML definitions (<bean> declarations)
3. Java configuration (@Bean methods)
4. Programmatic registration (BeanDefinitionRegistry)

Transaction Propagation Behaviors

Transaction Scopes

Spring manages single-resource transactions (ACID compliance). Distributed transactions require external solutions like Seata integrated via Spring interfaces.

Spring Cloud Overview

Microservice toolkit providing:

• Service discovery (Consul/Nacos)
• API gateway (Gateway/Zuul)
• Load balancing (LoadBalancer/Ribbon)
• Resilience patterns (Sentinel/Hystrix)
• Configuration server

Duplicate Bean Handling

• XML: Fails on duplicate IDs during parsing
• Multiple XMLs: Last definition wins
• Java Config: First @Bean method registered, subsequent duplicates ignored

IoC Container Workflow

Phase 1: Initialization

• Parse configuration metadata (XML/annotations)
• Generate BeanDefinition objects
• Store definitions in registry

Phase 2: Instantiation

• Create singleton instances (non-lazy)
• Resolve dependencies via DI
• Apply lifecycle callbacks

Bean retrieval via @Autowired or context.getBean().