fuzhengwei/small-spring
Small Spring
Small-Spring is a simplified Java implementation of the Spring framework designed to study the internal architecture of inversion of control containers and dependency injection frameworks. It functions as a bean container that manages object lifecycles and resolves dependencies through automated instantiation and property injection.
The project implements a mechanism for intercepting method calls using dynamic proxies to support aspect-oriented programming. It separates cross-cutting concerns from business logic by wrapping target objects to modify method executions.
The system covers component discovery through classpath scanning and external resource loading, including XML configuration parsing. It includes application context management, bean scope control, and an event dispatching system based on the observer pattern to handle system events and lifecycle hooks.
Features
- Dependency Injection Frameworks - Implements a full dependency injection framework that automatically manages object creation and resolves component dependencies.
- Dependency Injection - Implements a core dependency injection system to decouple software components through automated wiring.
- Java Component Containers - Functions as a Java component container that handles the creation and management of singleton and prototype scoped objects.
- Classpath Component Scanners - Provides automatic discovery and registration of managed beans by scanning the classpath for annotations.
- Annotation-Based Component Scanning - Automatically detects and registers classes as managed beans by scanning packages for annotations.
- Aspect-Oriented Programming - Implements techniques for modularizing cross-cutting concerns by intercepting method calls.
- Aspect-Oriented Programming Frameworks - Implements a system for modularizing cross-cutting concerns using dynamic proxies and interceptors.
- Object Lifecycle Management - Controls the creation, registration, and destruction of objects to decouple instantiation from usage.
- Inversion-of-Control Containers - Provides an inversion-of-control container that manages bean lifecycles and resolves dependencies through automated instantiation.
- Singleton Instance Sharing - Manages a central map of singleton instances to ensure shared object access across the dependency graph.
- Dependency Injection Population - Uses Java reflection and metadata to automatically populate object properties with their required dependencies.
- Method Interception Proxies - Uses dynamic proxies to intercept method calls, allowing the injection of custom behavior.
- Spring Bean Contexts - Coordinates resource loading and object recognition within a managed bean application context.
- External Configuration Loading - Provides mechanisms to load external configuration files for component discovery and registration.
- Hook Registration - Implements a registration mechanism for executing custom logic during object initialization and destruction.
- Framework Architecture Studies - Provides a simplified implementation of the Spring framework as a resource for studying IoC and DI internals.
- Framework Implementation Studies - Provides a simplified implementation of the Spring framework specifically designed for studying the internals of IoC and DI containers.
- Bean Scope Definitions - Defines how objects are instantiated and shared using scope definitions and factory patterns.
- Initialization and Shutdown Hooks - Provides initialization and shutdown hooks to trigger specific methods during the application lifecycle.
- Event Triggering - Implements mechanisms for programmatically firing events to notify registered listeners within the container.
- Container Event Observers - Implements an observer-pattern event dispatcher to notify listeners of internal system events.
- XML Configurations - Supports the use of external XML files to define object relationships and application settings.
- Java Frameworks - A simplified implementation of the Spring framework for learning.
