What is the implementation method of dependency injection in Golang?

2 years ago
Sophia Anderson
2 minutes

There are several methods for implementing dependency injection in Golang.

  1. Constructor injection: by defining a constructor in the struct with dependent parameters, the dependencies are passed when creating an instance of the struct. This approach requires manually creating struct instances and passing in dependencies, which makes it easy to use mock dependencies in unit tests.
type Foo struct {
    Dependency *Dependency
}

func NewFoo(dependency *Dependency) *Foo {
    return &Foo{
        Dependency: dependency,
    }
}
  1. Property injection: By defining a public dependency property within a struct and manually setting the dependency when using the struct, this method requires manual setting of dependencies after creating a struct instance, which may not be ideal for using virtual dependencies in unit testing.
type Foo struct {
    Dependency *Dependency
}

func (f *Foo) SetDependency(dependency *Dependency) {
    f.Dependency = dependency
}
  1. Interface injection: By defining an interface, placing the dependent methods within the interface, and implementing the interface in a structure. The consumer depends on the interface rather than a specific structure, allowing for dynamic replacement of dependencies at runtime. This approach is suitable for scenarios where dependencies need to be dynamically replaced at runtime.
type Dependency interface {
    Method()
}

type DependencyImpl struct {}

func (d *DependencyImpl) Method() {}

type Foo struct {
    Dependency Dependency
}

func NewFoo(dependency Dependency) *Foo {
    return &Foo{
        Dependency: dependency,
    }
}
  1. Dependency Injection Container: Implementing dependency injection using a third-party library or a custom container. The container is responsible for managing the creation and lifecycle of dependencies, injecting them where needed. This approach is suitable for complex dependency relationships and large-scale applications.
type DependencyImpl struct {}

func (d *DependencyImpl) Method() {}

type Foo struct {
    Dependency Dependency
}

func NewFoo() *Foo {
    return &Foo{}
}

func main() {
    container := di.NewContainer()
    container.Register(&DependencyImpl{})
    container.Register(func(dependency Dependency) *Foo {
        return &Foo{
            Dependency: dependency,
        }
    })

    foo := container.Resolve((*Foo)(nil)).(*Foo)
}

These are several common methods for implementing dependency injection. The appropriate method can be chosen based on the specific application scenario and requirements.

bannerAds