Go’s dependency injection (DI) has become essential in modern application development. I’ve spent years implementing these patterns across various projects, and I’ll share the most effective techniques I’ve encountered.
Constructor Injection remains the most straightforward and widely used approach in Go. Here’s a comprehensive example:
type EmailService struct {
sender MailSender
templates TemplateEngine
config Config
}
func NewEmailService(sender MailSender, templates TemplateEngine, config Config) *EmailService {
return &EmailService{
sender: sender,
templates: templates,
config: config,
}
}
// Implementation
type MailSender interface {
Send(to string, subject string, body string) error
}
type SMTPSender struct {
host string
port int
}
func (s *SMTPSender) Send(to, subject, body string) error {
// SMTP implementation
return nil
}
Interface Injection provides flexibility through dependency contracts. I’ve found this particularly useful in large systems:
type ServiceInjector interface {
InjectLogger(logger Logger)
InjectMetrics(metrics MetricsCollector)
}
type OrderProcessor struct {
logger Logger
metrics MetricsCollector
}
func (op *OrderProcessor) InjectLogger(logger Logger) {
op.logger = logger
}
func (op *OrderProcessor) InjectMetrics(metrics MetricsCollector) {
op.metrics = metrics
}
Functional Injection offers elegant solutions for specific use cases:
type ServiceOption func(*Service) error
func WithLogger(logger Logger) ServiceOption {
return func(s *Service) error {
s.logger = logger
return nil
}
}
func WithCache(cache Cache) ServiceOption {
return func(s *Service) error {
s.cache = cache
return nil
}
}
func NewService(opts ...ServiceOption) (*Service, error) {
s := &Service{}
for _, opt := range opts {
if err := opt(s); err != nil {
return nil, err
}
}
return s, nil
}
Container-based Injection scales well in complex applications:
type Container struct {
services map[reflect.Type]interface{}
mu sync.RWMutex
}
func NewContainer() *Container {
return &Container{
services: make(map[reflect.Type]interface{}),
}
}
func (c *Container) Register(service interface{}) {
c.mu.Lock()
defer c.mu.Unlock()
t := reflect.TypeOf(service)
c.services[t] = service
}
func (c *Container) Resolve(t reflect.Type) interface{} {
c.mu.RLock()
defer c.mu.RUnlock()
return c.services[t]
}
Struct Tags provide metadata-driven injection:
type Application struct {
Database *Database `inject:"database"`
Cache *Cache `inject:"cache"`
Logger Logger `inject:"logger"`
}
func InjectDependencies(target interface{}, container *Container) error {
v := reflect.ValueOf(target).Elem()
t := v.Type()
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
if tag := field.Tag.Get("inject"); tag != "" {
dependency := container.Get(tag)
v.Field(i).Set(reflect.ValueOf(dependency))
}
}
return nil
}
Service Locator Pattern offers a centralized dependency registry:
type ServiceLocator struct {
services map[string]interface{}
mu sync.RWMutex
}
func (sl *ServiceLocator) Register(name string, service interface{}) {
sl.mu.Lock()
defer sl.mu.Unlock()
sl.services[name] = service
}
func (sl *ServiceLocator) Get(name string) interface{} {
sl.mu.RLock()
defer sl.mu.RUnlock()
return sl.services[name]
}
Real-world Implementation:
type UserModule struct {
repo UserRepository
auth AuthService
logger Logger
}
func NewUserModule(opts ...ModuleOption) (*UserModule, error) {
m := &UserModule{}
for _, opt := range opts {
if err := opt(m); err != nil {
return nil, fmt.Errorf("module initialization failed: %w", err)
}
}
if err := m.validate(); err != nil {
return nil, err
}
return m, nil
}
type ModuleOption func(*UserModule) error
func WithRepository(repo UserRepository) ModuleOption {
return func(m *UserModule) error {
m.repo = repo
return nil
}
}
func WithAuth(auth AuthService) ModuleOption {
return func(m *UserModule) error {
m.auth = auth
return nil
}
}
func (m *UserModule) validate() error {
if m.repo == nil {
return errors.New("repository is required")
}
if m.auth == nil {
return errors.New("auth service is required")
}
return nil
}
Testing becomes straightforward with dependency injection:
func TestUserModule(t *testing.T) {
mockRepo := &MockUserRepository{}
mockAuth := &MockAuthService{}
module, err := NewUserModule(
WithRepository(mockRepo),
WithAuth(mockAuth),
)
if err != nil {
t.Fatalf("Failed to create module: %v", err)
}
// Test specific functionality
mockRepo.On("FindUser", 1).Return(&User{ID: 1}, nil)
user, err := module.GetUser(1)
assert.NoError(t, err)
assert.NotNil(t, user)
mockRepo.AssertExpectations(t)
}
Each technique serves specific needs. Constructor injection works well for simple scenarios. Interface injection supports flexible dependency contracts. Functional injection enables optional dependencies. Container-based injection manages complex dependency graphs. Struct tags offer declarative injection. Service locator provides centralized dependency management.
The choice depends on application requirements, team size, and codebase complexity. I prefer constructor injection for small services and container-based injection for larger applications. Functional injection excels when handling optional dependencies.
These patterns improve code organization, testability, and maintenance. They separate concerns and make dependencies explicit. The result is more maintainable and scalable Go applications.
Remember to keep interfaces small and focused. Avoid circular dependencies. Use mocks judiciously in tests. Document dependency requirements clearly. These practices enhance the benefits of dependency injection.
The Go ecosystem continues evolving, but these fundamental patterns remain relevant. They form the foundation of robust, maintainable applications. Master these techniques to build better Go services.
