Dependency injection

一个Go编程语言的运行依赖注入库。依赖注入是更广泛的控制反转技术的一种形式。它用于增加程序的模块化并使其具有可扩展性.

实例展示(High API):

                        
                          type A struct {
	Name string
}

func NewA() *A {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	name := "A-" + strconv.Itoa(r.Int())
	return &A{Name: ls}
}

services := NewServiceCollection()
services.AddSingleton(NewA)
//serviceCollection.AddSingletonByImplementsAndName("redis-master", NewRedis, new(abstractions.IDataSource))
//serviceCollection.AddTransientByImplements(NewRedisClient, new(redis.IClient))
//serviceCollection.AddTransientByImplements(NewRedisHealthIndicator, new(health.Indicator))
serviceProvider := services.Build()

var env *A
_ = serviceProvider.GetService(&env) // used

                        
                      

依赖注入将如何帮助我们的?

依赖注入是更广泛的控制反转技术的一种形式。它用于增加程序的模块化并使其具有可扩展性.

安装

                        
                          go get -u github.com/yoyofxteam/dependencyinjection@v1.0.1

                        
                      

组件特性

• Providing
• Extraction
• Invocation
• Lazy-loading
• Interfaces
• Groups
• Named definitions
• Optional parameters
• Parameter Bag
• Prototypes
• Cleanup

Providing

首先，我们需要创建两个基本类型:http。服务器和http.ServeMux。让我们创建一个简单的构造函数来初始化它

                        
                          // 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])

                          
                        

现在让我们来容器构建这些类型.

下面展示是Low API, 也可以用High API来构建

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

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

                        
                      

函数di. new()解析构造函数，编译依赖关系图并返回*di。用于交互的容器类型。如果无法编译，容器会出现恐慌.

我认为在应用程序初始化时而不是在运行时出现恐慌是很常见的.

Extraction

我们可以从容器中提取构建的服务器。为此，定义提取类型的变量，并将变量指针传递给Extract函数.

如果未找到提取的类型或构建实例的过程导致错误，则提取返回错误。 如果没有错误发生，我们就可以使用这个变量，就像我们自己构建它一样.

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

server.ListenAndServe()

                        
                      

请注意，默认情况下，容器作为单例创建实例 , 但也可使用Provide做行为上的改变.

                        
                          
## Invocation
作为提取的替代方法，我们可以使用Invoke()函数。它解析函数依赖并调用函数。调用函数可能返回可选错误。
```golang
// NewServer creates a http server with provided mux as handler.
func NewServer(handler http.Handler) *http.Server {
	return &http.Server{
		Handler: handler,
	}
}

                        
                      

对于一个容器来说，要知道作为http的实现。处理程序是必须使用的，我们使用选项di.As()。这个选项的参数必须是一个指向接口的指针，比如new(Endpoint).

这种语法可能看起来很奇怪，但我还没有找到更好的方式来指定接口.

修改依赖注入容器初始化代码

                        
                          container := inject.New(
	// provide http server
	inject.Provide(NewServer),
	// provide http serve mux as http.Handler interface
	inject.Provide(NewServeMux, inject.As(new(http.Handler)))
)

                        
                      

现在容器使用提供*http。ServeMux作为http。服务器构造函数中的处理程序。使用接口有助于编写更多可测试的代码.

Groups

容器自动将接口的所有实现分组到[] 组。例如，提供with inject.As(new(http.Handler))自动创建一个组[]http.Handler.

让我们使用这个特性添加一些http控制器。控制器有典型的行为。它正在注册路由。首先，将为它创建一个接口.

                        
                          // Controller is an interface that can register its routes.
type Controller interface {
	RegisterRoutes(mux *http.ServeMux)
}

                        
                      

现在我们将编写控制器并实现控制器接口.

                        
                          // OrderController is a http controller for orders.
type OrderController struct {}

// NewOrderController creates a auth http controller.
func NewOrderController() *OrderController {
	return &OrderController{}
}

// RegisterRoutes is a Controller interface implementation.
func (a *OrderController) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("/orders", a.RetrieveOrders)
}

// Retrieve loads orders and writes it to the writer.
func (a *OrderController) RetrieveOrders(writer http.ResponseWriter, request *http.Request) {
	// implementation
}

                        
                      

UserController 。

                        
                          // UserController is a http endpoint for a user.
type UserController struct {}

// NewUserController creates a user http endpoint.
func NewUserController() *UserController {
	return &UserController{}
}

// RegisterRoutes is a Controller interface implementation.
func (e *UserController) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("/users", e.RetrieveUsers)
}

// Retrieve loads users and writes it using the writer.
func (e *UserController) RetrieveUsers(writer http.ResponseWriter, request *http.Request) {
    // implementation
}

                        
                      

就像在这个接口的例子中，我们将使用inject.As()提供provide选项.

                        
                          container := inject.New(
	di.Provide(NewServer),        // provide http server
	di.Provide(NewServeMux),       // provide http serve mux
	// endpoints
	di.Provide(NewOrderController, di.As(new(Controller))),  // provide order controller
	di.Provide(NewUserController, di.As(new(Controller))),  // provide user controller
)

                        
                      

现在，我们可以在mux中使用控制器数组。参见更新后的代码

                        
                          // NewServeMux creates a new http serve mux.
func NewServeMux(controllers []Controller) *http.ServeMux {
	mux := &http.ServeMux{}

	for _, controller := range controllers {
		controller.RegisterRoutes(mux)
	}

	return mux
}

                        
                      

高级功能

Named definitions

在某些情况下，一种类型有多个实例。例如两个数据库实例:master -用于写，slave -用于读.

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

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

                        
                      

第二种方法是使用带有di.WithName()提供选项的命名定义 。

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

                        
                      

如果需要从容器中提取，请使用di.Name()提取选项.

                        
                          var db *Database
container.Extract(&db, di.Name("master"))

                        
                      

如果需要在其他构造函数中提供命名定义，请使用di。参数嵌入.

                        
                          // ServiceParameters
type ServiceParameters struct {
	di.Parameter
	
	// use `di` tag for the container to know that field need to be injected.
	MasterDatabase *Database `di:"master"`
	SlaveDatabase *Database  `di:"slave"`
}

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

                        
                      

Optional parameters

                        
                          // ServiceParameter
type ServiceParameter struct {
	di.Parameter
	
	StdOutLogger *Logger `di:"stdout"`
	FileLogger   *Logger `di:"file,optional"`
}

                        
                      

将依赖声明为可选的构造函数必须处理这些依赖不存在的情况.

Parameter Bag

如果需要在定义级别上指定一些参数，则可以使用 inject.ParameterBag provide option. 这是一个map[string]interface{}，可以转换为di.ParameterBag类型.

                        
                          // Provide server with parameter bag
di.Provide(NewServer, di.ParameterBag{
	"addr": ":8080",
})

// NewServer create a server with provided parameter bag. Note: use di.ParameterBag type.
// Not inject.ParameterBag.
func NewServer(pb di.ParameterBag) *http.Server {
	return &http.Server{
		Addr: pb.RequireString("addr"),
	}
}

                        
                      

Prototypes

如果您想在每次提取上创建一个新实例，请使用di.Prototype()提供选项.

                        
                          di.Provide(NewRequestContext, di.Prototype())

                        
                      

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
}

                        
                      

在调用container.Cleanup()之后，它遍历实例，如果存在则调用cleanup函数.

                        
                          container := di.New(
	// ...
    di.Provide(NewFile),
)

// do something
container.Cleanup() // file was closed

                        
                      

总结

Dependency injection 是一个运行时的依赖注入框架, 它也会集成到了微服务框架 yoyogo 中. 🦄🌈 YoyoGo （Go语言框架）一个简单、轻量、快速、基于依赖注入的微服务框架( web 、grpc ),支持Nacos/Consoul/Etcd/Eureka/k8s /Apollo等 . 。

参考

yoyogo: https://github.com/yoyofx/yoyogo 。

dependencyinjection: https://github.com/yoyofxteam/dependencyinjection 。

最后此篇关于Go开源库运行时依赖注入框架Dependencyinjection的文章就讲到这里了,如果你想了解更多关于Go开源库运行时依赖注入框架Dependencyinjection的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。