Spring Framework Architecture: Core Modules and Package Structure

Spring Core Principles

Delegates object management responsibilities to the Spring container.

Enables the extension of object capabilities through aspects, allowing cross-cutting concerns to be modularized.

The Spring framework employs a layered architecture comprising approximately 20 distinct modules, categorized as follows:

The foundation consists of four primary modules:

spring-core: Contains fundamental utility classes essential for the Spring framework's operation.
spring-beans: Provides components for accessing configuration files, instantiating and managing beans, and implementing Inversion of Control/Dependency Injection (IoC/DI) mechanisms.
spring-context: Built upon the Core and Beans modules, this offers a framework-style object access mechanism similar to JNDI registries. It extends Spring's core capabilities with internationalization support, event propagation, resource loading, and transparent context creation. The ApplicationContext interface serves as the central component of this module.
spring-expression: Delivers a powerful expression language for runtime object querying and manipulation. Supports property value setting/retrieval, method invocation, array and context access, logical and arithmetic operations, variable naming, and Spring IoC container object retrieval by name.

Contains three modules focused on aspect-oriented programming:

spring-aop: Implements an AOP-compliant solution according to AOP Alliance standards. Allows definition of method interceptors and join points to separate logic code, reducing coupling. Supports source-level metadata functionality and provides transaction management services for Spring-based applications without EJB dependencies.
spring-aspects: Provides integration with AspectJ.
spring-instrument: Offers class-level tooling support and ClassLoader implementations for server environments.

Comprises five modules for data persistence:

spring-jdbc: Supplies a JDBC abstraction layer that eliminates verbose coding and handles database-specific error codes. Contains all classes for Spring's JDBC data access encapsulation.
spring-tx: Supports both programmatic and declarative transaction management, with transaction classes implementing specific interfaces applicable to all POJOs.
spring-orm: Provides an integration layer for popular object-relational mapping APIs including JPA, JDO, Hibernate, iBatis, and others. Allows combination of Spring features with O/R mapping capabilities.
spring-oxm: Offers an abstract layer for Object/XML mapping implementations including JAXB, Castor, XMLBeans, JiBX, and XStream.
spring-jms: Implements Java Message Service capabilities for producing and consuming messages.

Contains three modules for web application development:

spring-web: Provides basic web integration features such as multi-file upload, Servlet listeners for IoC container initialization, and a web application context. Includes web-related components from Spring's remote support.
spring-webmvc: Houses Spring's Model-View-Controller (MVC) implementation, enabling clear separation between model code and web forms while integrating with other Spring framework features.
spring-webflux: A non-blocking asynchronous framework built on Reactor APIs. Operates on servers like Netty, Undertow, and Servlet 3.1+ containers, offering greater runtime environment flexibility than traditional web frameworks.

spring-test: Provides JUnit and mocking functionality for Spring application testing.

Posted on Sat, 12 Sep 2026 16:00:36 +0000 by cjdesign