DerekYRC/mini-spring
Mini Spring
mini-spring is a Java dependency injection framework and inversion of control container. It manages the full lifecycle of beans, including instantiation, property population, and scope management, while providing a system for automating the wiring of components.
The project implements a Java AOP framework that uses dynamic proxies to intercept method calls for cross-cutting logic. It also functions as a Java component scanner to automatically discover and register managed objects via annotations and as a Java event bus to decouple components through a publish-subscribe multicast system.
The container supports bean definition through XML configuration and annotation-based scanning, alongside a three-level cache to resolve circular dependencies. It includes a post-processor hook pipeline to modify bean definitions and instances, and a resource loader to resolve property placeholders from external files.
Features
- Dependency Injection - Implements a core dependency injection system for managing object lifecycles and resolving dependencies.
- Dependency Injection Containers - Provides a central inversion-of-control container to manage the full lifecycle and dependency resolution of beans.
- Inversion-of-Control Containers - Provides a central container for bean instantiation, scope management, and resolution of circular dependencies.
- Circular Dependency Resolvers - Utilizes a three-level cache to provide early object references and resolve circular dependencies.
- Java Component Containers - Acts as a runtime environment that handles the lifecycle and provisioning of Java objects.
- Annotated Class Discovery - Implements automated discovery of managed objects by scanning packages for specific annotations.
- Annotation-Based Component Scanning - Automatically discovers and registers managed objects by scanning specified Java packages for annotations.
- Bean Definition Configurations - Supports defining bean metadata and relationships through XML configurations and annotations.
- Aspect-Oriented Programming Frameworks - Provides an AOP framework to modularize cross-cutting concerns like logging and security.
- Automated Component Discovery - Automatically detects and registers annotated classes from packages to eliminate manual instantiation.
- Dependency Injection Frameworks - Provides a lightweight Java dependency injection framework for managing component wiring and lifecycles.
- Annotation-Based Injection - Resolves and injects required dependencies into fields or constructors using metadata annotations.
- Method Interception Proxies - Uses runtime-generated dynamic proxies to intercept method calls for applying cross-cutting logic.
- Annotated Class Discovery - Automatically discovers and registers managed components by scanning annotated classes in specified packages.
- Bean Post-Processor Pipelines - Provides a post-processor pipeline to modify bean definitions and instances during the container initialization phase.
- Bean Initialization Customizations - Provides post-processors and aware interfaces to inject custom logic before or after bean initialization.
- External Configuration Loading - Loads external property files to resolve configuration placeholders without modifying source code.
- Publish-Subscribe Messaging - Implements a publish-subscribe pattern for triggering and listening to events within the application context.
- Classpath Component Scanners - Automatically discovers and registers managed objects by scanning classpath packages for specific annotations.
- Scoped Lifecycle Managers - Supports singleton and prototype scopes to control the visibility and lifecycle of managed objects.
- Annotation-Driven Configuration - Uses annotations and placeholder resolvers to inject configuration values from property files into beans.
- Application Event Buses - Implements an event-driven architecture to decouple components via a publish-subscribe system.
- Bean Post-Processors - Process object definitions before instantiation and modify instances before or after their initialization.
- Property Source Resolvers - Resolves configuration placeholders from external property files and classpath resources for injection into beans.
- Event Bus Systems - Provides an internal event bus implementation for decoupled communication between application components.
- Event Dispatching Systems - Includes a publish-subscribe multicast system to decouple components via a centralized event dispatcher.
- Event-Driven Architectures - Implements a publish-subscribe multicast system to decouple components via application-level events.
- Lifecycle Callbacks - Executes specific initialization and destruction methods to manage resource setup and cleanup for beans.
- Value Injection Annotations - Populates object properties using annotations to inject configuration values from external sources.
- Property Placeholders - Injects configuration values into object fields by resolving placeholders using a specific syntax.
- Application Event Multicasters - Ships a publish-subscribe system to decouple internal components via event multicasting.
- Spring Framework Analysis - Simplified framework implementation to practice and learn core principles.
