samber/do

Features

• Dependency Injection Providers - Provides a type-safe system for automatically injecting services and dependencies into Go structures.
• Dependency Lifecycle Management - Controls the creation and destruction of dependencies as singletons, factories, or on-demand instances.
• Service Lifecycle Managers - Manages the creation and release lifecycle of services, including singletons and lazy loading.
• Hierarchical Containers - Organizes services into a tree of nested containers to isolate modules and manage inheritance.
• Hierarchical Scopes - Implements a hierarchical service container allowing child scopes to inherit dependencies from ancestors.
• Reverse-Order Teardown Protocols - Coordinates graceful shutdowns by executing cleanup logic in the exact reverse order of service initialization.
• Automatic Constructor Injection - Automatically populates structure fields with required services by inferring types or using metadata tags.
• Go DI Frameworks - Provides a dedicated dependency injection framework tailored for the Go programming language.
• Component Service Scoping - Isolates service instances within a tree of nested scopes where children inherit from ancestors.
• Interface-to-Implementation Bindings - Decouples service consumers from concrete types by binding abstract interfaces to specific implementation providers.
• Dependency Injection Population - Automatically populates structure fields with required services by scanning metadata tags using the runtime reflection system.
• Hierarchical Scopes - Provides a tree of nested service containers where child scopes inherit dependencies from their ancestors.
• Type-Safe Binding Registries - Maintains a type-safe map of unique identifiers to factory functions or singletons for consistent service retrieval.
• Conditional Service Provisioning - Supports registering dependencies only when specific conditions are met for flexible environment setups.
• Lazy Initialization - Defers the instantiation of a dependency until it is first requested to reduce startup resource usage.
• Service - Runs customizable sequences of functions during service startup and shutdown for setup and cleanup.
• Reverse-Order Shutdowns - Executes cleanup logic for services in reverse initialization order to ensure safe resource release.
• Dependency Cycle Detection - Identifies circular references within the service dependency graph to prevent infinite recursion during resolution.
• Dependency Graph Visualizations - Provides tools to map and inspect relationships and invocation chains between services for architectural verification.
• Startup Validation - Invokes service dependencies during initialization to detect missing services before the application starts.
• Circular Dependency Resolution - Detects and prevents infinite recursive loops during the registration and resolution of service dependencies.
• Lazy Loading - Defers the instantiation of dependencies until they are first requested to optimize startup time and memory.
• Service Loading Strategies - Implements eager, lazy, and transient loading strategies to manage service lifetimes and retrieval.
• Service Replacement Mechanisms - Allows swapping an existing service implementation with a different one during execution to facilitate testing.
• Health Checks - Executes health check sequences to ensure all system dependencies are operational and functioning correctly.
• Dependency Injection - DI framework based on generics.

Star history