Dependency Injection and the Tools for It | DI (dependency injection) in Go

مهدی خانزادی

۲۷ مرداد ۱۴۰۵

Dependency Injection and the Tools for It | DI (dependency injection) in Go

Large software is built from small, independent parts — and those parts need each other. This article explains what a dependency is, why injecting it from the outside beats constructing it inline, and compares the four main DI tools in Go: Dig, Wire, Fx, and Container.

Introduction

Large software is made of smaller, more independent parts. To build a complex system, we split it into pieces, give each piece one clear responsibility, and then assemble them together.

What is a dependency?

Each of these pieces usually can't do everything on its own — to fulfill its responsibility, it may need other parts of the software.

Example: an order system

package order

import (
   "database"
)

type Manager struct {
    db *database.Database
}

func (m *OrderManager) CreateOrder(order *Order) (string, error) {
     id, err = m.db.Save(order)
     
     return id, err
}

Here, Manager depends on Database.

Two ways to supply dependencies

Construct the dependency right where the code needs it
Use dependency injection

Option one: constructing it directly (an anti-pattern)

package order

import (
    "database"
)

type Manager struct {
    db *database.Database
}

func New() *Manager {
    return Manager{
        db: database.New(),
    }
}

func (m *OrderManager) CreateOrder(order *Order) (string, error) {
     id, err = m.db.Save(order)
     
     return id, err
}

This approach has problems:

The code isn't testable
Dependencies can't be mocked
You can't swap in different implementations
If database.New has requirements of its own, New has to declare them too
Having a singleton isn't straightforward

What is dependency injection, and why do we need it?

Dependency injection means passing the dependency into the code from the outside.

package order

import (
    "database"
)

type Manager struct {
    db *database.Database
}

func New(db *database.Database) *Manager {
    return Manager{
        db: db,
    }
}

func (m *OrderManager) CreateOrder(order *Order) (string, error) {
     id, err = m.db.Save(order)
     
     return id, err
}

We can also add a method to replace the dependency:

package order

import (
    "database"
)

type Manager struct {
    db *database.Database
}

func New(db *database.Database) *Manager {
    return Manager{
        db: db,
    }
}

func (m *Manager) SetDatabase(db *database.Database) {
    m.db = db
}

func (m *Manager) CreateOrder(order *Order) (string, error) {
     id, err = m.db.Save(order)
     
     return id, err
}

#golang #go

Feature	Dig	Wire	Fx	Container
Developer	Uber	Google	Uber	Danceable
DI approach	Runtime DI via reflection	Compile-time DI via code generation	Runtime DI built on Dig	Runtime DI via a container
When dependencies resolve	Runtime	Compile-time	Runtime	Runtime
Uses reflection	✓ Yes	✗ No	✓ Yes	✓ Yes
Compile-time safety	Limited	Very high	Limited	Limited
Ease of use	Moderate	High	Moderate	High
Flexibility	High	Moderate	Very high	High
Lifecycle management	Limited	✗ No	Very powerful	✓ Yes
Scope support	✓ Yes	✗ No	✓ Yes	✓ Yes
Runtime configuration	High	Limited	High	High
Code generation	✗ No	✓ Yes	✗ No	✗ No
Manual configuration required	Moderate	Low to moderate	Moderate	Low
Good for small projects	✓ Yes	Excellent	Usually overkill	Excellent
Good for large projects	✓ Yes	✓ Yes	✓ Yes	✓ Yes
Learning curve	Moderate	Low	High	Low to moderate
Runtime performance	Good	Very good	Good	Good
Good for microservices	✓ Yes	✓ Yes	✓ Yes	✓ Yes

Latest

Most viewed

Latest

Most viewed

Comments

Comments