Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained

Java developers frequently encounter the Spring framework, which has become a standard for enterprise‑level applications. From early SSH/SSM to modern Spring MVC, Spring Boot, and Spring Cloud, Spring continuously simplifies Java development by providing a lightweight, full‑stack solution.

Spring Overview

Spring is a lightweight Java development framework created by Rod Johnson to reduce coupling between business‑logic and other layers in enterprise applications. It offers a full‑stack, non‑intrusive container that manages the infrastructure so developers can focus on application logic.

The framework’s core responsibilities are Inversion of Control (IoC), Dependency Injection (DI), and Aspect‑Oriented Programming (AOP).

Key Design Strategies

POJO‑based lightweight programming with minimal intrusion.

Loose coupling through DI and interface‑based design.

Declarative programming using aspects and conventions.

Reduction of boilerplate code via templates and aspects.

Core Concepts

IoC (Inversion of Control) – Instead of objects creating their dependencies with new, the Spring container creates and injects them, shifting control from the application code to the container. This simplifies object management and improves testability.

DI (Dependency Injection) – Spring injects required dependencies via setter methods, constructors, or interfaces, allowing beans to obtain collaborators without manual instantiation.

AOP (Aspect‑Oriented Programming) – AOP separates cross‑cutting concerns (e.g., logging, security, transactions) from core business logic by defining reusable aspects that are woven into target objects at runtime.

Design Goals and Philosophy

Provide a one‑stop lightweight platform for Java applications.

Support POJO/JavaBean development, promote interface‑driven design, and enable full OO practices.

Manage object relationships through an IoC container, achieving decoupling via dependency inversion.

Advantages and Disadvantages

Decouples components, simplifies development, and integrates many popular frameworks.

Offers declarative transaction management and extensive testing support.

Reduces the difficulty of using complex Java EE APIs.

Drawbacks include a perception of being large, reliance on reflection (which can affect performance), and a steep learning curve for newcomers.

Spring Modules (Spring 5)

The framework consists of roughly 20 modules grouped into six core areas: Core Container, AOP, Instrumentation, Data Access/Integration, Web, Messaging, and Test. Key modules include:

spring‑core : Provides IoC and DI fundamentals.

spring‑beans : Supplies the BeanFactory for bean management.

spring‑context : Builds on core to offer a richer object‑access API.

spring‑jdbc : Abstracts JDBC, simplifying database access.

spring‑aop : Implements aspect‑oriented programming.

spring‑web : Adds web‑specific features such as file upload and MVC support.

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

Design Patterns Used by Spring

Factory Pattern – BeanFactory implements a simple factory.

Singleton Pattern – Beans are singleton by default.

Proxy Pattern – AOP relies on JDK dynamic proxies and CGLIB.

Template Method – Classes like RestTemplate, JmsTemplate, JpaTemplate.

Observer Pattern – ApplicationListener implements a publish‑subscribe model.

Bean Creation and Lifecycle

The entry point for bean creation is ConfigurableListableBeanFactory#createBean. The lifecycle is illustrated in the following diagram:

Circular Dependency Resolution

Spring handles circular dependencies using three cache levels:

Level 1 – singletonObjects (fully initialized singletons).

Level 2 – earlySingletonObjects (early exposed singletons).

Level 3 – singletonFactories (singleton factories for early exposure).

During bean population, Spring checks for circular references and may expose a bean early to allow dependent beans to obtain a reference before full initialization.

IoC Implementation Details

IoC is realized through the BeanFactory which creates objects via the factory pattern, allowing developers to obtain beans without directly invoking constructors.

AOP Implementation Details

AOP is implemented using two main approaches:

Dynamic proxy – Intercepts method calls via java.lang.reflect.Proxy.

Static weaving – Uses AspectJ or similar bytecode manipulation at compile time.

Spring’s JdkDynamicAopProxy builds a proxy class, determines applicable advisors, and creates an interceptor chain that is invoked before the target method.

Common Spring Annotations

Spring provides a rich set of annotations for component scanning, dependency injection, web MVC, caching, lifecycle callbacks, and more. Frequently used annotations include:

@Controller, @RestController, @Service, @Autowired, @RequestMapping, @RequestParam, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, @Required, @Qualifier

Examples:

1 @Controller
2 public class TestController {
3     @RequestMapping("/test")
4     public String test(Map<String,Object> map) {
5         return "hello";
6     }
7 }

1 @RestController
2 public class TestController {
3     @RequestMapping("/test")
4     public String test(Map<String,Object> map) {
5         return "hello";
6     }
7 }

Other annotations such as @Autowired, @RequestParam, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, @Required, and @Qualifier are described with their typical usage and configuration requirements.

Conclusion

Spring’s design centers on IoC, DI, and AOP to reduce boilerplate, improve modularity, and enable flexible, testable Java applications. Understanding its core concepts, module structure, design patterns, and annotation‑driven configuration is essential for modern Java backend development.