Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

Spring Overview

Spring is a lightweight Java development framework created by Rod Johnson to solve coupling problems in enterprise‑level applications. It provides a full‑stack, open‑source infrastructure that lets developers focus on business logic while Spring handles the underlying infrastructure.

The framework’s primary mission is to simplify Java development by reducing complexity.

Spring offers rich functionality for enterprise development, built on two core features: Dependency Injection (DI) and Aspect‑Oriented Programming (AOP).

Spring reduces Java development complexity through four key strategies:

Lightweight, POJO‑based, minimally invasive programming.

Loose coupling via dependency injection and interface‑based design.

Declarative programming based on aspects and conventions.

Reduced boilerplate code through aspects and templates.

Design Goals, Philosophy, and Core

Design goal: provide a one‑stop lightweight development platform.

Design philosophy: support POJO/JavaBean development, promote interface‑driven design, and fully support object‑oriented principles. The IoC container manages object relationships, enabling dependency inversion.

Core components: IoC container and AOP module. The IoC container manages POJOs and their dependencies; AOP dynamically enhances services without intrusion.

Advantages and Disadvantages

Advantages:

Decouples components, simplifying development.

Supports AOP for cross‑cutting concerns such as security and monitoring.

Declarative transaction management via configuration.

Facilitates unit testing with JUnit integration.

Integrates seamlessly with popular frameworks (e.g., Struts, Hibernate, MyBatis).

Reduces the difficulty of using complex Java EE APIs.

Disadvantages:

Perceived as large despite being lightweight.

Relies on reflection, which can affect performance.

Steeper learning curve for newcomers.

Application Scenarios

Typical use cases include Java EE enterprise applications such as SSH and SSM stacks.

Key values:

Non‑intrusive framework that minimizes application code dependence on the framework.

Provides a consistent programming model using POJOs, isolating the code from the runtime environment.

Promotes object‑oriented and interface‑driven design, improving reusability and testability.

Modules

Spring consists of roughly 20 modules organized into six groups: Core Container, AOP, Instrumentation, Data Access/Integration, Web, Messaging, and Test. The diagram below (image) shows the module structure for Spring 5.

spring‑core: basic components, including IoC and DI.

spring‑beans: BeanFactory implementation.

spring‑context: builds on core to provide a framework‑style object access.

spring‑jdbc: abstracts JDBC, simplifying database access.

spring‑aop: implements aspect‑oriented programming.

spring‑web: integrates web features such as file upload and servlet listeners.

spring‑test: supports unit and integration testing with JUnit or TestNG.

Design Patterns Used

Factory pattern – BeanFactory as a simple factory.

Singleton pattern – Beans are singleton by default.

Proxy pattern – AOP uses JDK dynamic proxies and CGLIB.

Template method – Used in classes like RestTemplate, JmsTemplate, JpaTemplate.

Observer pattern – ApplicationListener implements event notification.

Spring IoC (Inversion of Control)

What is the Spring IoC Container?

IoC transfers object creation and wiring responsibilities from application code to the container, which creates, assembles, and manages object lifecycles.

Purpose of IoC

Manages object creation and dependency maintenance.

Achieves loose coupling by letting the container handle concrete objects.

Handles class instantiation tasks such as proxy creation.

Advantages of IoC

Reduces boilerplate code.

Facilitates testing without needing singletons or JNDI lookups.

Enables loose coupling with minimal intrusion.

Supports eager and lazy initialization.

Implementation Mechanism

Spring implements IoC using the factory pattern combined with reflection.

Example:

interface Fruit {
    void eat();
}
class Apple implements Fruit {
    public void eat() { System.out.println("Apple"); }
}
class Orange implements Fruit {
    public void eat() { System.out.println("Orange"); }
}
class Factory {
    public static Fruit getInstance(String className) {
        Fruit f = null;
        try {
            f = (Fruit) Class.forName(className).newInstance();
        } catch (Exception e) { e.printStackTrace(); }
        return f;
    }
}
class Client {
    public static void main(String[] a) {
        Fruit f = Factory.getInstance("io.github.dunwu.spring.Apple");
        if (f != null) { f.eat(); }
    }
}

IoC Features

Dependency injection.

Dependency checking.

Autowiring.

Collection support.

Custom init and destroy methods.

Callback support via Spring interfaces.

BeanFactory vs. ApplicationContext

Both are core container interfaces; ApplicationContext extends BeanFactory, adding internationalization, resource loading, event publishing, and automatic bean post‑processor registration.

BeanFactory loads beans lazily (on first getBean call), which may hide configuration errors until runtime.

ApplicationContext pre‑loads all singleton beans at startup, allowing early detection of configuration issues but consuming more memory.

Container Design Details

Rod Johnson defined two interfaces: BeanFactory (low‑level container) and ApplicationContext (high‑level container). BeanFactory is essentially a map of bean names to instances, while ApplicationContext adds features such as resource access, message sources, and event handling.

ApplicationContext can be implemented via classes like FileSystemXmlApplicationContext, ClassPathXmlApplicationContext, and WebXmlApplicationContext.

Spring Beans

What Are Spring Beans?

Beans are the core Java objects managed by the Spring IoC container, created based on metadata defined in configuration files (XML, annotations, or Java config).

Bean Definition Contents

A bean definition includes all metadata required by the container to instantiate the bean, manage its lifecycle, and resolve its dependencies.

Configuration Methods

XML configuration files.

Annotation‑based configuration.

Java‑based configuration.

Bean Scopes

singleton – one instance per container.

prototype – a new instance each request.

request – one instance per HTTP request (web context only).

session – one instance per HTTP session (web context only).

global‑session – one instance per global HTTP session (web context only).

Singleton is the default; prototype should be used cautiously due to performance overhead.

Thread Safety

Singleton beans are not inherently thread‑safe; stateless beans are generally safe, but stateful beans require developer‑managed synchronization or a prototype scope.

Bean Lifecycle

The lifecycle includes instantiation, property population, Aware callbacks (BeanNameAware, BeanFactoryAware, ApplicationContextAware), BeanPostProcessor pre‑initialization, InitializingBean/init‑method execution, post‑initialization processing, usage, and finally DisposableBean/destroy‑method invocation.

Bean Assembly and Autowiring

Assembly refers to wiring beans together based on declared dependencies. Autowiring can be configured per bean or globally using the autowire attribute with modes: no, byName, byType, constructor, autodetect.

Autowired Annotation Process

When @Autowired is used, Spring registers AutowiredAnnotationBeanPostProcessor. It first looks for a unique bean of the required type; if multiple candidates exist, it falls back to name matching; if none are found, an exception is thrown unless required=false is set.

Limitations of Autowiring

Requires explicit configuration for ambiguous cases.

Cannot inject primitive types or simple strings directly.

Less precise than explicit wiring; explicit configuration is recommended when possible.

Inner Beans

Inner beans are anonymous beans used only as properties of another bean, typically with prototype scope.

Injecting Collections

Spring supports injecting List, Set, Map, and Properties collections via dedicated XML elements.

Spring Annotations

Java‑Based Annotation Configuration

Annotations such as @Configuration and @Bean allow most configuration to be expressed in Java code instead of XML.

@Configuration
public class StudentConfig {
    @Bean
    public StudentBean myStudent() {
        return new StudentBean();
    }
}

Enabling Annotation‑Based Injection

Annotation injection is disabled by default; add <context:annotation-config/> to XML to enable it.

Stereotype Annotations

@Component

– generic component. @Controller – Spring MVC controller. @Service – service‑layer component. @Repository – DAO component with exception translation.

@Required

Marks a bean property as mandatory; missing configuration triggers BeanInitializationException.

@Autowired

Injects dependencies by type (or by name if multiple candidates). Can be applied to fields, constructors, or setter methods. The required attribute controls mandatory injection.

@Resource vs. @Autowired

@Autowired

defaults to type‑based injection; @Resource defaults to name‑based injection, falling back to type if no name match is found.

@Qualifier

Used with @Autowired to disambiguate which bean should be injected when multiple candidates of the same type exist.

@RequestMapping

Maps HTTP requests to controller classes or methods, specifying URL patterns and HTTP methods.

Spring Data Access

ORM Integration

Spring provides modules to integrate popular ORM tools such as Hibernate, JPA, JDO, and iBATIS, offering unified transaction management across them.

JDBC Support

Spring’s JdbcTemplate and related classes simplify resource handling and error processing, allowing developers to focus on SQL statements.

DAO Support

Spring’s DAO abstraction unifies exception handling and reduces boilerplate, making it easier to switch between persistence technologies.

Transaction Management

Spring supports programmatic and declarative transaction management. Declarative transactions, configured via annotations or XML, separate transaction concerns from business logic.

Propagation behaviors include REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED.

Isolation levels follow the standard JDBC levels: DEFAULT, READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, and SERIALIZABLE, each with its own consistency guarantees.

Spring Aspect‑Oriented Programming (AOP)

What Is AOP?

AOP complements OOP by modularizing cross‑cutting concerns (e.g., logging, security, transactions) into reusable aspects.

Spring AOP vs. AspectJ

AspectJ provides compile‑time (static) weaving, while Spring AOP uses runtime (dynamic) proxies. Spring AOP supports method‑level join points only.

Proxy Types

JDK dynamic proxies – interface‑based.

CGLIB proxies – subclass‑based, used when no interfaces are present.

Core AOP Concepts

Aspect – combination of advice and pointcut.

Join point – a method execution point.

Advice – action taken at a join point (before, after, after‑returning, after‑throwing, around).

Pointcut – expression that selects join points.

Introduction – adds new methods or fields to existing classes.

Target object – the bean being advised.

Weaving – the process of applying aspects to target objects.

Advice Types and Execution Order

Before – runs before the method.

After – runs after the method regardless of outcome.

After‑returning – runs after successful completion.

After‑throwing – runs when an exception is thrown.

Around – wraps the method execution, allowing code before and after.

When no exception occurs, the order is: around‑before → before → target method → around‑after → after → after‑returning. If an exception occurs, after‑throwing is invoked instead of after‑returning.

Aspect Declaration Styles

XML‑based schema configuration.

Annotation‑based using @Aspect (Java 5 style).

Automatic Proxy Creators

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

Metadata auto‑proxying