go包dig依赖注入

package main

import (
	"errors"
	"fmt"

	"go.uber.org/dig"
)

func main() {
	c := BuildContainer()
	if err := c.Invoke(func(i *PersonRepositor) {
		i.Hello()
	}); err != nil {
		fmt.Println("Invoke", err)
		return
	}

	if err := c.Invoke(func(i *DB2) {
		fmt.Println("Invoke DB2", i.Config.Name)
	}); err != nil {
		fmt.Println("Invoke DB2", err)
		return
	}
}

func BuildContainer() *dig.Container {
	container := dig.New()

	err := container.Provide(NewConfig)
	if err != nil {
		fmt.Println("NewConfig", err)
		return nil
	}
	container.Provide(ConnectDatabase)
	container.Provide(NewPersonRepository)
	if err = container.Provide(NewDb2); err != nil {
		fmt.Println("NewDb2", err)
		return nil
	}
	return container
}

type Config struct {
	Name string `json:"name"`
}

func NewConfig() *Config {
	c := new(Config)
	c.Name = "go.uber.org/dig"
	fmt.Printf("new Config, %s\n", c.Name)
	return c
}

type DB struct {
	Config *Config
}

func ConnectDatabase(c *Config) *DB {
	fmt.Printf("new DB, need config:%+v\n", c)
	return &DB{
		Config: c,
	}
}

type DB2 struct {
	Config *Config
}

func NewDb2(c *Config) (*DB2, error) {
	fmt.Println("db2")
	return &DB2{
		Config: c,
	}, errors.New("test err")
}

type PersonRepositor struct {
	DB     *DB
	Config *Config
}

func (p PersonRepositor) Hello() {
	fmt.Printf("hello, test for:%s\n", p.DB.Config.Name)
}

func NewPersonRepository(db *DB, c *Config) *PersonRepositor {
	fmt.Printf("new PersonRepositor, need DB:%+v\n", db)
	return &PersonRepositor{
		DB:     db,
		Config: c,
	}
}

type PersonService struct {
	PersonRepositor *PersonRepositor
}

type Server struct {
	PersonService *PersonService
}