服务提供者#

// NewServer creates a http server with provided mux as handler.
func NewServer(mux *http.ServeMux) *http.Server {
	return &http.Server{
		Handler: mux,
	}
}

// NewServeMux creates a new http serve mux.
func NewServeMux() *http.ServeMux {
	return &http.ServeMux{}
}

支持的构造器签名如下

func([dep1, dep2, depN]) (result, [cleanup, error])

构建一个DI容器#

import (
  di "github.com/yoyofxteam/dependencyinjection"
)

container := di.New(
	// provide http server
    di.Provide(NewServer),
    // provide http serve mux
    di.Provide(NewServeMux)
)

获取容器中的实例#

// declare type variable
var server *http.Server
// extracting
err := container.Extract(&server)
if err != nil {
	// check extraction error
}

server.ListenAndServe()

注册Naming定义提供者#

// MasterDatabase provide write database access.
type MasterDatabase struct {
	*Database
}

// SlaveDatabase provide read database access.
type SlaveDatabase struct {
	*Database
}

// 省略
// provide master database
di.Provide(NewMasterDatabase, di.WithName("master"))
// provide slave database
di.Provide(NewSlaveDatabase, di.WithName("slave"))

var database *Database
err := container.Extract(&database,di.Name(master))  // get master databse

依赖关联#

可能实际的情况，类型间会有大量依赖，组件A依赖组件B，这种情况我们使用 di.Parameter 来声明结构体，对其它提供者提供多依赖管理：

// ServiceParameters
type ServiceParameters struct {
	di.Parameter
	MasterDatabase *Database `di:"master"`
	SlaveDatabase *Database  `di:"slave,optional"`   // optional 可选参数，如果没有实例则为nil
}

// NewService creates new service with provided parameters.
func NewService(parameters ServiceParameters) *Service {
	return &Service{
		MasterDatabase:  parameters.MasterDatabase,
		SlaveDatabase: parameters.SlaveDatabase,
	}
}

Cleanup函数#

提供者构造器返回清理函数用于销毁实例和释放资源,它由容器的container.Cleanup()函数统一管理：

func NewFile(log Logger, path Path) (*os.File, func(), error) {
    f, err := os.Open(string(path))
    if err != nil {
        return nil, nil, err
    }
    cleanup := func() {
        if err := f.Close(); err != nil {
            log.Log(err)
        }
    }
    return f, cleanup, nil
}