Bean Loading Architecture

Bean Loading Architecture describes how Spring Boot discovers, creates, configures, injects, initializes, proxies, and manages beans inside the IoC container.

Spring Boot enhances Spring’s Container with:

• Smart bean detection
• Lazy loading
• Conditional auto-configuration
• AOP proxying
• Scope management
• Early bean references
• Singleton caching
• Post-processing pipeline

What is Bean Loading in Spring Boot?

Bean Loading is the internal process Spring uses to convert classes → bean definitions → actual objects, and then manage their entire lifecycle.

Spring Boot automates and optimizes this process via:

• Auto-configuration
• Component scanning
• Conditional annotations
• Bean post-processors
• Embedded server initialization
• Property binding

➡ This makes bean creation predictable, powerful, and extendable.

Phases of Bean Loading Architecture

The Phases of Bean Loading Architecture explain how Spring Boot discovers, creates, and wires beans inside the IoC container before the application becomes ready.

1. Bean Definition Phase (Blueprint Creation)

Spring first identifies which classes should become beans.

Sources include:

• @Component, @Service, @Repository, @Controller
• @Configuration + @Bean
• Auto-configuration classes
• XML (legacy)
• Conditional beans (@ConditionalOnClass, etc.)

Spring converts them into BeanDefinition objects containing:

• Bean class
• Scope
• Constructor parameters
• Dependencies
• Init/destroy methods
• Proxy requirement
• Lazy/eager strategy

Example: Component scanning

@Component
public class MyService {
    public void serve() {
        System.out.println("Service running");
    }
}

➡ Spring creates a BeanDefinition for MyService.

2. BeanDefinition Registry (Stores Bean Blueprints)

All BeanDefinitions are stored in:

👉 BeanDefinitionRegistry

This acts as Spring’s internal “bean metadata database.”

No beans are created yet.

Example: Conceptually, Spring has a “map” like:

BeanDefinitionRegistry:
  "myService" -> BeanDefinition(MyService.class, scope=singleton)

3. BeanFactoryPostProcessor Phase

Before beans are created, Spring modifies BeanDefinitions.

Examples:

• ConfigurationClassPostProcessor → processes @Configuration
• PropertySourcesPlaceholderConfigurer → resolves ${}
• Auto-configuration processors → add/modify bean definitions

Example: Using property placeholder

@Value("${app.name}")
private String appName;

➡ Resolved by PropertySourcesPlaceholderConfigurer.

4. Bean Post-Processor Registration Phase

Spring loads and registers all BeanPostProcessors, which run during bean creation.

Used for:

• @Autowired resolution
• @Qualifier logic
• AOP proxy creation
• @PostConstruct and @PreDestroy
• Validation handling
• Custom modifications around bean creation

Example: Custom BeanPostProcessor

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String name) {
        System.out.println("Before init: " + name);
        return bean;
    }
}

5. Bean Instantiation Phase (Object Creation)

Spring now begins creating actual objects for each bean.

Internally Spring uses:

• Constructor reflection
• CGLIB subclassing (for AOP & proxies)
• Constructor injection prioritization

Example:

MyService myService = new MyService(); // internally done by Spring

➡ Bean objects come to life at this stage.

6. Dependency Injection Phase

Once instantiated, Spring injects dependencies via:

• Constructor injection
• Setter injection
• Field injection (@Autowired)
• Method injection

Spring resolves:

• Circular dependencies (singleton only)
• @Qualifier
• @Primary
• Optional/required dependencies

Example

@Service
public class UserService {
    @Autowired
    private MyService myService;

    public void process() {
        myService.serve(); // dependency injected
    }
}

7. Initialization Phase

Spring executes bean lifecycle callbacks:

• @PostConstruct
• InitializingBean.afterPropertiesSet()
• Custom init-method (from @Bean(initMethod="..."))

Example:

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

8. BeanPostProcessor (After Initialization) Phase

Now Spring applies post-initialization logic, such as:

• AOP proxy creation
• Transaction proxy wrapping
• Security proxies
• Custom bean enhancements

Example: AOP proxy

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.*.*(..))")
    public void log() {
        System.out.println("Method called");
    }
}

➡ Spring wraps beans with proxies if required.

9. Bean Storage (Singleton Cache / Scope Management)

Spring stores and manages beans differently based on their scope:

Singleton Scope

• Stored in the SingletonBeanRegistry (singleton cache).
• One instance per container → reused across the application.

Prototype Scope

• A new bean instance is created every time it is requested.
• Not stored in the singleton cache.

Request / Session / Application Scope

Web Scopes (Request / Session / Application)

Available only in web applications.

Bean lifetime depends on the web scope:

• Request: new instance for each HTTP request
• Session: one instance per user session
• Application: one instance per servlet context

Example: Singleton vs Prototype

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

➡ Spring creates a new instance each time.

10. Destroy Phase (Application Shutdown)

Spring gracefully destroys beans:

• Calls @PreDestroy
• Executes destroy-method
• Invokes DisposableBean.destroy()

Example:

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

Internal Components Involved in Bean Loading

These are the core systems that drive the bean loading and initialization process inside Spring.

1. BeanDefinitionLoader

Responsible for reading and registering metadata from multiple sources:

• @Configuration classes
• Component scanning (@Component, @Service, etc.)
• Auto-configuration classes
• XML configuration (if used)

Example (conceptual):

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

➡ BeanDefinitionLoader reads this configuration and creates a BeanDefinition for myService.

2. DefaultListableBeanFactory

This is the main engine of the IoC container:

• Creates and manages bean instances
• Handles constructor and field injection
• Resolves bean scopes
• Applies BeanPostProcessors
• Detects & resolves circular dependencies
• Stores all singleton beans in the cache

Example (conceptual):

MyService service = beanFactory.getBean(MyService.class);

It is the central implementation behind all BeanFactory operations.

3. AutowireCapableBeanFactory

Specialized for injecting dependencies and preparing beans:

• Selects constructors for injection
• Performs autowiring (constructor, setter, field)
• Resolves dependencies dynamically
• Calls lifecycle callbacks (@PostConstruct, InitializingBean, etc.)

Example:

@Autowired
private MyService myService;

4. BeanPostProcessor Chain

A chain of processors applied to every bean:

• AutowiredAnnotationBeanPostProcessor
• CommonAnnotationBeanPostProcessor
• AOP proxy creators
• Validation processors
• Custom user-defined post-processors

Example:

@Component
public class CustomProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String name) {
        System.out.println("Processed: " + name);
        return bean;
    }
}

Used to modify or wrap beans before and after initialization.

5. AOP Proxy System

Analyzes AOP-related annotations such as:

• @Transactional
• @Async
• @Cacheable

If needed, wraps the bean inside a proxy using:

• JDK Dynamic Proxy
• CGLIB Proxy

Enables cross-cutting features like transactions, caching, and async execution.

Example:

@Transactional
public void performTransaction() { ... }

➡ Spring creates a proxy for the bean using the AOP Proxy System.

Bean Loading: Complete Internal Lifecycle

1. Scan Components (@Component, @Service, @Configuration etc.) - Spring detects candidate classes for beans using annotations or configuration.

2. Create BeanDefinitions (blueprints) - Spring converts detected classes into metadata objects describing how to create and manage beans.

3. Register BeanDefinitions in BeanFactory - BeanDefinitions are stored in the container, ready for instantiation.

4. Run BeanFactoryPostProcessors (Auto-configuration magic here) - Spring modifies bean definitions before creating beans (e.g., resolving placeholders, auto-config tweaks).

5. Register BeanPostProcessors - Middleware is registered to intercept beans before and after initialization.

6. Instantiate Bean (new keyword / CGLIB) - Spring creates actual bean objects using constructors or CGLIB proxies.

7. Inject Dependencies (@Autowired, @Value) - Spring resolves and injects dependencies into the bean fields, constructors, or setters.

8. Apply BeanPostProcessors (AOP proxies created here) - Beans are processed by post-processors, often wrapped with proxies for AOP features.

9. Initialize Bean (@PostConstruct) - Initialization callbacks are executed to prepare the bean for use.

10. Add to Singleton Cache (bean ready) - Fully initialized singleton beans are stored for reuse across the application.

11. Destroy Bean on Shutdown (@PreDestroy) - Spring calls cleanup methods and releases resources when the application shuts down.

Why Bean Loading Architecture Matters

It enables:

• Clean separation of configuration
• Powerful DI system
• Automatic bean lifecycle management
• Auto-configuration support
• AOP behavior
• Flexible scope support
• High-level abstraction for enterprise apps

Without this architecture, Spring Boot would not be able to offer:

• Auto-configured DataSources
• Embedded servers
• Repository generation
• REST controller mapping
• Security filter chains
• Scheduled tasks
• Cloud-native features

➡ Bean Loading is the foundation of Spring Boot’s magic.

Conclusion

Bean Loading Architecture is Spring’s internal engine that discovers components, registers metadata, creates bean objects, injects dependencies, applies AOP, initializes them, and manages their lifecycle.