Overview

  • Installing godi
    • Requirements
    • Installation
      • Using Go Modules (Recommended)
      • Import in Your Code
    • Verify Installation
    • Version Management
      • Check Current Version
      • Update to Latest
      • Use Specific Version
    • Development Setup
    • Editor Support
    • Next Steps
  • Why Dependency Injection?
    • The Problem: Dependency Management at Scale
      • Problems with this approach:
    • The Solution: Dependency Injection with godi
    • Key Benefits
      • 1. Never Touch Constructors Again
      • 2. Request Scoping for Web Applications
      • 3. Testability Built-In
      • 4. Automatic Resource Management
      • 5. Clear Dependency Graph
    • Real-World Benefits
      • Large Team Development
      • Microservices
      • Growing Applications
    • Common Concerns Addressed
      • “But Go is simple! This adds complexity!”
      • “I can just pass dependencies manually”
      • “What about performance?”
    • Conclusion
  • Core Concepts
    • Service
    • Constructor
    • Service Collection
    • Service Provider
    • Service Lifetimes
      • Singleton
      • Scoped
      • Transient
    • Scopes
    • Dependency Resolution
    • Type Safety
    • Disposal and Cleanup
    • Keyed Services
    • Service Groups
    • Modules
    • Best Practices
    • Next Steps
  • Comparison with Other DI Solutions
    • Comparison Table
    • Detailed Comparisons
      • godi vs wire (Google)
      • godi vs fx (Uber)
      • godi vs dig (Uber)
      • godi vs Manual DI
    • Feature-by-Feature Comparison
      • Service Lifetimes
      • Developer Experience
      • Testing Support
      • Use Cases
    • Code Examples Side-by-Side
      • Basic Setup
      • With Dependencies
      • Testing
    • Decision Matrix
    • Migration Effort
    • Conclusion

Tutorials

  • Getting Started with godi
    • Prerequisites
    • Setting Up
    • Step 1: Define Our Services
    • Step 2: Implement Our Services
    • Step 3: Wire Everything with godi
    • Step 4: Run the Application
    • What Just Happened?
    • Step 5: Add a New Feature
    • Next Steps
    • Key Takeaways
  • Building a Web Application with godi
    • Prerequisites
    • Project Setup
    • Project Structure
    • Step 1: Define Models and Interfaces
    • Step 2: Create Configuration
    • Step 3: Implement Repositories
    • Step 4: Implement Services
    • Step 5: Create HTTP Handlers
    • Step 6: Wire Everything with godi
    • Step 7: Test the API
    • Key Takeaways
    • Next Steps
  • Testing with godi
    • Why DI Makes Testing Better
    • Setting Up
    • Step 1: Create Test Utilities
    • Step 2: Create Mocks
    • Step 3: Unit Testing Services
    • Step 4: Integration Testing
    • Step 5: Testing Scoped Services
    • Step 6: Testing Best Practices
    • Step 7: Benchmark Tests
    • Testing Strategies
      • 1. Unit Testing with Mocks
      • 2. Integration Testing
      • 3. End-to-End Testing
      • 4. Test Organization
    • Key Testing Benefits with godi
      • 1. Easy Mock Injection
      • 2. Isolated Test Environments
      • 3. Parallel Testing
      • 4. Test-Specific Configuration
    • Common Testing Patterns
      • Factory Pattern for Test Data
      • Test Fixtures
      • Cleanup Helpers
    • Summary
    • Next Steps
  • Building Microservices with godi
    • Architecture Overview
    • Project Structure
    • Step 1: Shared Infrastructure
      • Shared Configuration
      • User Service Main
    • Step 4: Product Service
    • Step 5: Order Service (Depends on User and Product)
      • Service Client Implementations
    • Step 6: Docker Compose Setup
    • Key Benefits of DI in Microservices
      • 1. Service Isolation
      • 2. Testability
      • 3. Configuration Management
      • 4. Cross-Cutting Concerns
      • 5. Service Discovery Integration
    • Best Practices for Microservices with godi
    • Summary
    • Next Steps
      • Shared Logging
      • Shared Tracing
      • Service Discovery
    • Step 2: Base Service Structure
    • Step 3: User Service
      • User Service Proto
      • User Service Implementation

How-to Guides

  • Registering Services
    • Basic Registration
      • AddSingleton
      • AddScoped
      • AddTransient
    • Constructor Patterns
      • Simple Constructor
      • Constructor with Error
      • Interface Registration
    • Keyed Services
    • Service Groups
    • Instance Registration
    • Conditional Registration
    • Generic Services
    • Registration Options
      • Service Replacement
      • Remove Services
    • Factory Pattern
    • Best Practices
      • 1. Register by Interface
      • 2. Use Appropriate Lifetimes
      • 3. Validate Early
      • 4. Document Dependencies
    • Common Patterns
      • Options Pattern
      • Multi-Stage Initialization
    • Next Steps
  • Using Scopes
    • What is a Scope?
    • Web Request Scoping
      • HTTP Middleware Pattern
  • Keyed Services
    • When to Use Keyed Services
    • Basic Registration
    • Resolving Keyed Services
    • Database Example
    • Notification Channels
    • Payment Gateways
    • Environment-Based Services
    • Feature Flags
    • Storage Backends
    • Injecting Keyed Services
    • Dynamic Key Resolution
    • Testing with Keyed Services
    • Best Practices
      • 1. Use Constants for Keys
      • 2. Document Available Keys
      • 3. Provide Fallbacks
      • 4. Validate at Startup
    • Summary
  • Service Groups
    • Basic Concept
    • HTTP Handler Example
    • Middleware Chain
    • Event Handlers
    • Validation Rules
    • Plugin System
    • Observers and Listeners
    • Conditional Registration
    • Testing with Groups
    • Best Practices
      • 1. Use Meaningful Group Names
      • 2. Document Group Members
      • 3. Handle Empty Groups
      • 4. Order Matters Sometimes
    • Summary
  • Modules
    • What are Modules?
    • Creating a Module
      • Basic Module
      • Module with Dependencies
    • Using Modules
      • Single Module
      • Multiple Modules
    • Module Patterns
      • Layered Architecture
      • Feature Modules
      • Environment-Specific Modules
    • Advanced Module Techniques
      • Module with Configuration
      • Conditional Registration in Modules
      • Module Composition
    • Testing with Modules
      • Test Module
      • Module Override Pattern
    • Module Organization
      • Directory Structure
      • Module File Example
    • Best Practices
      • 1. Single Responsibility
      • 2. Clear Dependencies
      • 3. Avoid Circular Dependencies
      • 4. Document Module Purpose
      • 5. Test Modules Independently
    • Module Patterns for Common Scenarios
      • Web Application Module
      • Background Jobs Module
      • Plugin System Module
    • Summary
  • Decorators
    • What are Decorators?
    • Basic Decorator
      • Simple Logging Decorator
      • Registering Decorators
    • Common Decorator Patterns
      • Caching Decorator
      • Metrics Decorator
      • Retry Decorator
      • Validation Decorator
    • Chaining Decorators
    • Advanced Decorator Patterns
      • Conditional Decorator
      • Context-Aware Decorator
      • Generic Decorator
      • Circuit Breaker Decorator
    • Testing Decorators
      • Unit Testing Decorators
      • Integration Testing
    • Best Practices
      • 1. Keep Decorators Focused
      • 2. Maintain Interface Compatibility
      • 3. Make Decorators Optional
      • 4. Document Decorator Order
      • 5. Consider Performance
    • Common Use Cases
      • 1. Cross-Cutting Concerns
      • 2. Security
      • 3. Resilience
      • 4. Performance
      • 5. Business Logic
    • Summary
  • Parameter Objects
    • Understanding Parameter Objects
    • Input Parameter Objects (In)
      • Basic Usage
      • Optional Dependencies
      • Named Dependencies
      • Groups in Parameters
    • Output Result Objects (Out)
      • Basic Usage
      • Named Results
      • Group Results
    • Advanced Patterns
      • Nested Parameter Objects
      • Combining In and Out
      • Factory Pattern with Parameters
    • Best Practices
      • 1. When to Use Parameter Objects
      • 2. Naming Conventions
      • 3. Field Documentation
      • 4. Validation
      • 5. Avoid Overuse
    • Testing with Parameter Objects
      • Mock Specific Fields
      • Test Helpers
    • Common Patterns
      • Configuration Parameters
      • Multi-Database Parameters
      • Plugin Parameters
    • Summary
  • Service Disposal
    • Disposable Interface
    • Basic Disposal
      • Simple Disposable Service
      • Context-Aware Disposal
    • Disposal Order
    • Lifetime-Based Disposal
      • Singleton Disposal
      • Scoped Disposal
      • Transient Disposal
    • Disposal Patterns
      • Resource Pool
      • Composite Disposal
      • Graceful Shutdown
    • Error Handling
      • Multiple Disposal Errors
      • Panic Recovery
    • Testing Disposal
      • Verify Disposal
      • Test Disposal Order
    • Best Practices
      • 1. Always Implement Disposal for Resources
      • 2. Use Defer for Scopes
      • 3. Handle Disposal Errors
      • 4. Make Disposal Idempotent
      • 5. Document Disposal Behavior
    • Summary
  • Advanced Patterns
    • Factory Pattern
      • Service Factory
      • Abstract Factory
    • Strategy Pattern
      • Dynamic Strategy Selection
    • Chain of Responsibility
      • Middleware Chain
    • Lazy Initialization
      • Lazy Service Resolution
    • Service Locator (Anti-)Pattern
    • Composite Pattern
      • Composite Services
    • Proxy Pattern
      • Service Proxy
    • Observer Pattern
      • Event System
    • Command Pattern
      • Command Execution
    • Unit of Work Pattern
      • Transaction Management
    • Specification Pattern
      • Dynamic Queries
    • Summary

Reference

  • API Reference
    • Core Types
      • ServiceCollection
        • Creating a ServiceCollection
      • ServiceProvider
      • Scope
      • ServiceLifetime
    • Registration Functions
      • Basic Registration
      • Keyed Registration
      • Group Registration
      • Interface Registration
    • Resolution Functions
      • Generic Resolution Helpers
      • Direct Resolution
    • Dependency Injection
      • Constructor Injection
      • Parameter Objects (In)
      • Result Objects (Out)
    • Modules
    • Service Provider Options
    • Decorators
    • Disposal
      • Disposable Interface
    • Error Handling
      • Error Types
      • Common Errors
    • Invoke Function
    • Default Provider
    • Complete Example
  • Service Lifetimes Reference
    • Overview
    • Singleton Services
      • Characteristics
      • When to Use
      • Example
      • Implementation Details
    • Scoped Services
      • Characteristics
      • When to Use
      • Example
      • Scope Hierarchy
    • Transient Services
      • Characteristics
      • When to Use
      • Example
      • Factory Pattern
    • Lifetime Compatibility
      • Dependency Rules
      • Captive Dependencies
    • Disposal Order
    • Best Practices
      • Choose the Right Lifetime
      • Avoid Common Pitfalls
    • Testing Considerations
    • Performance Implications
      • Optimization Tips
    • Summary
  • Error Handling Reference
    • Error Categories
    • Common Error Values
      • Service Resolution Errors
      • Lifecycle Errors
      • Constructor Errors
    • Typed Errors
      • ResolutionError
      • CircularDependencyError
      • LifetimeConflictError
      • TimeoutError
    • Error Checking Functions
      • IsNotFound
      • IsCircularDependency
      • IsDisposed
      • IsTimeout
    • Error Handling Patterns
      • Basic Error Handling
      • Registration Error Handling
      • Build Error Handling
      • Graceful Degradation
    • Custom Error Types
      • Creating Custom Errors
      • Wrapping Errors
    • Error Recovery
      • Panic Recovery
      • Validation Options
    • Testing Error Scenarios
      • Testing Not Found Errors
      • Testing Circular Dependencies
      • Testing Disposal Errors
    • Best Practices
      • 1. Always Check Errors
      • 2. Use Error Context
      • 3. Handle Specific Errors
      • 4. Fail Fast on Configuration
    • Summary
  • Configuration Options Reference
    • ServiceProviderOptions
      • ValidateOnBuild
      • OnServiceResolved
      • OnServiceError
      • ResolutionTimeout
      • DryRun
      • RecoverFromPanics
      • DeferAcyclicVerification
    • Provide Options
      • Name Option
      • Group Option
      • As Option
      • Callback Options
    • Decorate Options
    • Complete Example
    • Option Patterns
      • Development vs Production
      • Testing Configuration
      • Monitoring Configuration
    • Best Practices
  • Changelog
    • [Unreleased]
      • Added
      • Changed
      • Deprecated
      • Removed
      • Fixed
      • Security
    • [1.0.0] - 2025-01-15
      • Added
      • Features
      • Examples
      • Documentation
    • Version History
      • Versioning Policy
      • Compatibility
      • Future Releases
    • Upgrading
      • From v0.x to v1.0.0
      • Breaking Changes
    • Support
    • Contributors
    • License

Conceptual Guides

  • Architecture Guide
    • How godi Works
      • Core Components
      • Lifetime Management
      • Resolution Process
    • Application Architecture Patterns
      • Clean Architecture
      • Hexagonal Architecture (Ports and Adapters)
      • Vertical Slice Architecture
    • Service Organization Patterns
      • Service Layers
      • Service Boundaries
    • Dependency Management
      • Dependency Direction
      • Avoiding Circular Dependencies
    • Testing Architecture
      • Test Pyramid with DI
      • Test Organization
    • Performance Considerations
      • Service Resolution Performance
      • Scope Management
    • Scalability Patterns
      • Modular Monolith
      • Microservices Ready
    • Best Practices Summary
    • Conclusion
  • Best Practices
    • Service Design
      • Use Interfaces
      • Constructor Injection
      • Single Responsibility
    • Lifetime Management
      • Choose the Right Lifetime
      • Avoid Captive Dependencies
    • Scope Management
      • Always Close Scopes
      • One Scope Per Operation
    • Error Handling
      • Check Resolution Errors
      • Constructor Validation
    • Testing
      • Use Test Containers
      • Test Helpers
    • Module Organization
      • Group Related Services
      • Module Dependencies
    • Performance
      • Cache Service Resolution
      • Avoid Over-Injection
    • Common Pitfalls
      • 1. Circular Dependencies
      • 2. Service Locator Anti-Pattern
      • 3. Leaking Abstractions
    • Summary Checklist
  • Migration Guide
    • Migrating from Manual Dependency Management
      • Before: Manual Wiring
      • After: With godi
      • Migration Steps
    • Migrating from Google Wire
      • Wire Approach
      • godi Approach
      • Key Differences
      • Migration Steps
    • Migrating from Uber Fx
      • Fx Approach
      • godi Approach
      • Key Differences
      • Migration Steps
    • Migrating from Microsoft.Extensions.DependencyInjection
      • .NET Approach
      • godi Approach (Very Similar!)
      • Familiar Concepts
      • Migration Steps
    • Migrating from Spring/Java DI
      • Spring Approach
      • godi Approach
      • Key Differences
    • Common Migration Patterns
      • 1. Converting Singletons
      • 2. Converting Factory Functions
      • 3. Converting Init Functions
    • Testing Migration
      • Before: Complex Setup
      • After: Clean DI
    • Migration Checklist
    • Benefits After Migration
    • Getting Help
  • Performance Guide
    • Performance Overview
      • Performance Characteristics
    • Resolution Performance
      • Singleton Services
      • Scoped Services
      • Transient Services
    • Optimization Techniques
      • 1. Cache Service Resolution
      • 2. Minimize Transient Usage
      • 3. Optimize Scope Usage
      • 4. Lazy Resolution
    • Benchmarking
      • Basic Benchmark
      • Concurrent Benchmark
    • Memory Optimization
      • 1. Dispose Scopes Promptly
      • 2. Avoid Service Leaks
      • 3. Pool Expensive Objects
    • Provider Options for Performance
      • Validation Timing
      • Resolution Monitoring
    • Common Performance Pitfalls
      • 1. Excessive Transient Usage
      • 2. Deep Dependency Chains
      • 3. Scope Explosion
    • Performance Best Practices
      • 1. Profile Before Optimizing
      • 2. Measure Resolution Times
      • 3. Use Appropriate Lifetimes
      • 4. Batch Operations
    • Optimization Checklist
    • Conclusion
  • Troubleshooting Guide
    • Common Issues
      • Service Not Found
      • Circular Dependencies
      • Disposed Provider/Scope
      • Lifetime Conflicts
      • Missing Dependencies
      • Constructor Errors
    • Debugging Techniques
      • 1. Enable Validation
      • 2. Add Resolution Logging
      • 3. Check Service Registration
      • 4. Trace Dependency Chain
    • Performance Issues
      • Slow Resolution
      • Memory Leaks
    • Testing Issues
      • Mocks Not Being Used
      • Test Isolation
    • Error Patterns
      • Check Error Types
      • Wrap Errors with Context
    • Prevention Strategies
      • 1. Consistent Registration Pattern
      • 2. Validate Early
      • 3. Document Dependencies
    • Getting Help
    • Quick Reference

Quick Links

  • GitHub
  • pkg.go.dev
  • Go Report Card

Community

  • Discussions
  • Issues
godi
  • Search

© Copyright 2025, junioryono.

Built with Sphinx using a theme provided by Read the Docs.