The answer is to implement a lightweight DI container using Go's structures, interfaces and reflection. Automatic injection is achieved by defining a Container structure containing service mapping, registering a constructor and using reflection to resolve dependencies. Supports storage and retrieval of service instances by type to ensure loose coupling and testability. It is suitable for simple scenarios. For complex requirements, libraries such as uber/dig can be used.

Implementing a dependency injection (DI) container in Go doesn't require a complex framework. You can build a lightweight, effective DI container using Go's standard features like structs, interfaces, and reflection. The goal is to manage object creation and their dependencies automatically, reducing coupling and improving testability.

1. Define the Container Structure

A DI container holds instances or constructors of services. Use a map to store named dependencies, and leverage interface{} or reflect.Type as keys.

Example:

 type Container struct {<br> services map[reflect.Type]reflect.Value<br> }<br><br> func NewContainer() *Container {<br> return &Container{<br> services: make(map[reflect.Type]reflect.Value),<br> }<br> }

2. Register Services

Add methods to register types or factory functions. You can support both concrete structs and constructor functions that return instances.

Example:

 func (c *Container) Register(factory interface{}) {<br> factoryValue := reflect.ValueOf(factory)<br> result := factoryValue.Call(nil)[0]<br> c.services[result.Type()] = result<br> }

3. Resolve Dependencies

When resolving a type, check if it's already built. If not, call its constructor and inject any required dependencies by recursively resolving them.

For more advanced cases, inspect constructor parameters using reflection and resolve each one from the container.

Example Resolve method:

 func (c *Container) Get(t reflect.Type) reflect.Value {<br> if service, exists := c.services[t]; exists {<br> return service<br> }<br> panic("service not found: " t.Name())<br> }

4. Usage Example

Define services and wire them together through the container.

 type Database struct{}<br> func NewDatabase() *Database { return &Database{} }<br><br> typeUserService struct {<br> DB*Database<br> }<br> func NewUserService(db *Database) *UserService {<br> return &UserService{DB: db}<br> }<br><br> // In main:<br> container := NewContainer()<br> container.Register(NewDatabase)<br> container.Register(func() *UserService {<br> return NewUserService(container.Get(reflect.TypeOf((*Database)(nil)).Elem()).Interface().(*Database))<br> })<br><br> userSvc := container.Get(reflect.TypeOf((*UserService)(nil)).Elem()).Interface().(*UserService)

Basically just map types to instances or factories, use reflection to wire them, and resolve on demand. Keep it simple unless you need lifecycle management or scopes. There are also solid open-source options like uber/dig if you prefer a full-featured DI library.

The above is the detailed content of How to implement a dependency injection container in Golang. For more information, please follow other related articles on the PHP Chinese website!