Enterprise Java development requires handling cross-cutting concerns (transactions, security, logging) alongside business logic. Without a framework, these concerns get scattered across the codebase (cross-cutting) and tangled with business code, making applications hard to develop, test, and maintain.
Spring is a lightweight, modular Java application framework centered on Inversion of Control (IoC) and Dependency Injection (DI). It provides infrastructure for managing objects (beans), wiring dependencies, and integrating with enterprise services (transactions, persistence, messaging, web) through a consistent programming model.
- Bean container: Spring’s IoC container (ApplicationContext) manages object creation, wiring, and lifecycle
- Configuration metadata: Beans are defined via XML, annotations, or Java config (
@Configuration) - Dependency Injection: The container injects dependencies into beans at construction time, eliminating
newcalls - Aspect-Oriented Programming: Spring AOP weaves cross-cutting concerns (transactions, security) into beans without modifying business code
- Modular architecture: Spring is organized into modules: Core, MVC, Data, Security, Cloud, Boot — use what you need
- Lightweight: No application server required; runs in any JVM with a servlet container (Tomcat)
- POJO-based: Business objects are plain Java objects with no Spring coupling (except annotations)
- Non-invasive: Application code doesn’t extend Spring classes or implement Spring interfaces
- Modular: Choose only the modules your application needs
- Testable: DI makes unit testing trivial — mock dependencies can be injected in tests
- Integration: First-class support for Hibernate, JPA, JDBC, JMS, JTA, JNDI
- Built from: Spring IoC Container — Core of Spring, manages beans and DI
- Builds into: Spring MVC — Web framework built on Spring Core
- Builds into: Spring Boot — Auto-configuration on top of Spring Framework
- Builds into: Spring Security — Security built on Spring AOP and DI
- Related: Component Architecture & SOA — Both Spring and EJB address component-based enterprise development
- Contrasts with: EJB Session Bean — Spring beans are lighter, no EJB container needed
- Configuration hell: Too many XML/annotation configurations can become as hard to manage as the problems Spring solves
- Circular dependencies: Bean A depends on B which depends on A causes container startup failure; use setter injection or @Lazy
- Proxy limitations: Spring AOP (JDK dynamic proxies) only intercepts public method calls on Spring-managed beans
- Over-autowiring: Auto-wiring everything makes dependency graphs implicit and hard to trace