uber-go/fx
Fx
Fx is a dependency injection framework and application lifecycle manager for Go. It functions as a component model container that automates the instantiation and connection of components by analyzing constructor parameters and return values to resolve complex dependency graphs.
The framework distinguishes itself through module-based component bundling, which encapsulates related constructors into reusable units to manage visibility and logic. It provides advanced resolution capabilities, including mapping concrete types to interfaces for decoupling, resolving dependency ambiguities via unique naming, and aggregating multiple instances of the same type into named or typed groups.
Beyond dependency resolution, the system orchestrates the startup and shutdown sequences of singletons and background processes. It handles the bootstrapping of interlocking dependencies and provides mechanisms for blocking execution until stop signals trigger cleanup operations.
The project includes integration for custom logging to capture and format internal operational events of the dependency system.
Features
- Automatic Constructor Injection - Automatically provides dependencies into constructors by analyzing function signatures.
- Go DI Frameworks - Provides a full-featured dependency injection framework for Go that automates component wiring via constructors.
- Lifecycle Sequence Orchestration - Orchestrates startup and shutdown sequences by executing hooks in the order of dependency resolution.
- Dependency Injection Containers - Functions as a container that manages the instantiation and lifecycle of components to achieve loose coupling.
- Go DI Frameworks - Provides a framework that automates component connection by analyzing constructor parameters and return values.
- Application Bootstrapping - Automates the instantiation of interlocking dependencies to remove global state from the application startup process.
- Application Lifecycle Management - Coordinates the precise startup and shutdown sequences of services to ensure correct resource initialization and cleanup.
- Application Component Lifecycles - Provides a mechanism to manage the startup and shutdown sequences of application components to ensure correct resource ordering.
- Dependency Injection - Provides required dependencies automatically to decouple implementation from instantiation.
- Dependency Injection Containers - Implements a dependency injection container that resolves shared application state and maps concrete types to interfaces.
- Dependency Injection - Maps concrete return types to interfaces so consumers remain decoupled from specific implementations.
- Interface-to-Implementation Bindings - Maps concrete return types to interfaces to allow flexible implementation swapping.
- DI Module Bundling - Encapsulates related constructors into modules to manage visibility and reuse across services.
- Reflection-Based Dependency Resolution - Uses runtime type analysis to match requested dependencies with available providers.
- Component Bundles - Provides the ability to group related constructors and logic into modules for simplified application assembly.
- Execution Blocking - Blocks application execution until a stop signal triggers necessary cleanup operations.
- Reusable DI Modules - Enables the creation of reusable component modules that can be integrated across different services.
- Dependency Graph Pruning - Instantiates only the components necessary to satisfy the requirements of the root application process.
- Group Value Injection - Assigns a typed result to a named collection so multiple components contribute values to a shared group.
- Named Group Injection - Retrieves a collection of components of the same type by a named group to receive all registered instances.
- Type-Based Group Injection - Collects multiple components of the same type into a slice and injects them as a group.
- Modular Software Design - Organizes code into decoupled, reusable modules that bundle constructors and logic for better maintainability.
- Module Encapsulation Patterns - Implements patterns for controlling constructor visibility and encapsulating internal implementation details within modules.
- Named Dependency Groups - Aggregates multiple instances of the same type into slices using unique group identifiers.
- Named Dependency Resolution - Assigns unique names to multiple instances of the same type to ensure the correct implementation is injected.
- Application Entry Point Triggering - Executes root-level functions to start background workers or servers.
- Dependency Injection - Application framework built on top of dependency injection.
- Frameworks and Libraries - A dependency injection-based application framework.
