di7/di：Go语言终极依赖注入容器详解，让你的代码更解耦、更灵活

di7/di：Go语言终极依赖注入容器详解，让你的代码更解耦、更灵活

【免费下载链接】diDependency injection container in go (golang)项目地址: https://gitcode.com/gh_mirrors/di7/di

di7/di 是一个专为 Go 语言设计的依赖注入容器框架，它能够高效管理应用程序中对象的生命周期，自动创建对象、解析依赖关系，并在对象不再使用时妥善关闭它们。作为一款专注于性能的依赖注入工具，di7/di 可以帮助开发者构建更解耦、更灵活且易于维护的 Go 应用程序。

为什么选择依赖注入容器？

依赖注入（Dependency Injection）是一种重要的软件设计模式，它通过将对象的创建和依赖解析过程与业务逻辑分离，带来了诸多好处：

• 降低耦合度：组件之间不再直接创建依赖对象，而是通过容器获取，减少了代码间的直接关联
• 提高可测试性：可以轻松替换依赖对象为模拟实现，便于单元测试
• 简化代码维护：对象的创建和配置集中管理，修改时无需遍历所有使用处
• 增强代码灵活性：通过配置即可改变对象的实现方式，无需修改业务逻辑代码

如果你还不确定依赖注入是否能改善你的应用，可以了解更多关于依赖注入和依赖注入容器的知识。

快速上手：di7/di 基本使用

使用 di7/di 只需几个简单步骤，即可实现对象的依赖管理。

定义对象

首先，你需要为要管理的对象创建一个定义（Definition）。定义至少包含一个Build函数，用于创建对象实例：

MyObjectDef := &di.Def{ Build: func(ctn di.Container) (interface{}, error) { return &MyObject{}, nil }, } // 可选：为定义设置名称和类型，便于检索 MyObjectDef.SetName("my-object") MyObjectDef.SetIs((*MyObject)(nil))

创建构建器

接下来，使用NewEnhancedBuilder创建一个增强型构建器，这是推荐的使用方式：

builder, err := di.NewEnhancedBuilder()

添加定义到构建器

将之前创建的对象定义添加到构建器中：

err = builder.Add(MyObjectDef)

构建容器

调用构建器的Build方法生成容器：

ctn, err := builder.Build()

从容器中获取对象

现在，你可以从容器中检索对象了。di7/di 提供了多种检索方式：

// 通过定义获取（推荐，性能最优） ctn.Get(MyObjectDef).(*MyObject) // 通过名称获取（稍慢，但更灵活） ctn.Get("my-object").(*MyObject) // 通过类型获取（较慢，需使用反射） ctn.Get(reflect.TypeOf((*MyObject)(nil))).(*MyObject)

容器默认采用单例模式，第一次调用Get方法时创建对象，之后的调用会返回同一个实例，除非将定义的Unshared字段设置为true。

深入理解：di7/di 核心功能

定义（Definitions）详解

定义是 di7/di 的核心概念，它描述了如何创建和管理对象。除了基本的Build函数外，定义还支持多种高级特性：

依赖解析

Build函数可以使用容器来解析依赖关系，实现对象间的自动装配：

MyObjectWithDependencyDef := di.NewDef(func(ctn di.Container) (interface{}, error) { return &MyObjectWithDependency{ Object: ctn.Get(MyObjectDef).(*MyObject), }, nil })

生命周期管理

通过Close函数，你可以定义对象的清理逻辑，当容器被删除时，会自动调用这些清理函数：

di.Def{ Build: func(ctn di.Container) (interface{}, error) { return &MyObject{}, nil }, Close: func(obj interface{}) error { // 假设 MyObject 有一个 Close 方法 return obj.(*MyObject).Close() }, }

非共享对象

默认情况下，容器会缓存对象实例。如果需要每次获取新实例，可以将Unshared设为true：

MyObjectDef = &di.Def{ Unshared: true, // 每次调用 Get 都会创建新实例 Build: func(ctn di.Container) (interface{}, error) { return &MyObject{}, nil }, }

作用域（Scopes）：管理对象生命周期

作用域是 di7/di 中另一个强大的特性，特别适用于请求式应用（如 Web 应用）。通过作用域，你可以控制对象的生命周期范围。

di7/di 默认提供三个作用域：App（应用级）、Request（请求级）和SubRequest（子请求级），按从通用到具体的顺序排列。

// 创建具有默认作用域的构建器 builder, err := di.NewEnhancedBuilder() // 定义一个应用级对象 AppDef := di.Def{ Scope: di.App, // 可选，默认即为 App 作用域 Build: func(ctn di.Container) (interface{}, error) { return &MyObject{}, nil }, } // 定义一个请求级对象 RequestDef := di.Def{ Scope: di.Request, Build: func(ctn di.Container) (interface{}, error) { return &MyObject{}, nil }, }

容器可以创建子容器来管理更具体作用域的对象：

// 构建应用级容器 app, err := builder.Build() // 创建请求级子容器 req1, err := app.SubContainer() req2, err := app.SubContainer()

应用级对象在所有子容器中共享，而请求级对象则每个请求容器都有自己的实例：

// 应用级对象：所有容器获取的是同一个实例 o1 := app.Get(AppDef).(*MyObject) o2 := req1.Get(AppDef).(*MyObject) o3 := req2.Get(AppDef).(*MyObject) // o1 == o2 == o3 // 请求级对象：每个请求容器有自己的实例 o4 := req1.Get(RequestDef).(*MyObject) o5 := req2.Get(RequestDef).(*MyObject) // o4 != o5

对象检索的三种方式

di7/di 提供了三种从容器中检索对象的方法，适用于不同场景：

Get 方法

Get方法是最常用的检索方式，如果对象无法创建，它会直接 panic：

o1 := ctn.Get(MyObjectDef).(*MyObject)

SafeGet 方法

SafeGet方法与Get类似，但不会 panic，而是返回错误：

objectInterface, err := ctn.SafeGet(MyObjectDef) object, ok := objectInterface.(*MyObject)

Fill 方法

Fill方法使用反射来填充提供的对象指针，同样返回错误：

var object *MyObject err := ctn.Fill(MyObjectDef, &object)

Web 应用集成：HTTP 辅助工具

di7/di 提供了方便的 HTTP 中间件，简化在 Web 应用中的使用：

// 创建应用容器 builder, err := di.NewEnhancedBuilder() err = builder.Add(/* 定义 */) app, err := builder.Build() // 使用 HTTP 中间件 handlerWithDiMiddleware := di.HTTPMiddleware(handler, app, func(msg string) { logger.Error(msg) // 错误日志处理 })

在请求处理函数中，可以轻松获取请求级容器：

handler := func(w http.ResponseWriter, r *http.Request) { // 获取请求容器 ctn := di.C(r) obj := ctn.Get("object").(*MyObject) // 或者使用快捷方式 obj := di.Get(r, "object").(*MyObject) }

性能优化：让依赖注入更高效

虽然依赖注入会带来一些性能开销，但 di7/di 已经做了很多优化，同时你也可以通过以下方式进一步提升性能：

选择合适的检索方式

性能从高到低排序：通过定义检索 > 通过名称检索 > 通过类型检索。在性能关键路径上，优先使用定义检索。

预加载共享对象

共享对象的第一次检索会有互斥锁开销，可以在应用启动阶段预加载这些对象：

// 应用启动时预加载关键对象 app.Get(MyCriticalObjectDef)

避免非共享对象的 Close 函数

非共享对象如果定义了Close函数，容器需要跟踪它们，这会增加开销。如果可能，避免为非共享对象定义Close函数。

实际示例：数据库连接管理

下面是一个使用 di7/di 管理数据库连接的示例，展示了如何在实际项目中应用依赖注入：

// 定义数据库连接池（应用级） var MysqlPoolDef = &di.Def{ Name: "mysql-pool", Scope: di.App, Build: func(ctn di.Container) (interface{}, error) { db, err := sql.Open("mysql", "user:password@/") db.SetMaxOpenConns(1) return db, err }, Close: func(obj interface{}) error { return obj.(*sql.DB).Close() }, } // 定义数据库连接（请求级） var MySqlDef = &di.Def{ Name: "mysql", Scope: di.Request, Build: func(ctn di.Container) (interface{}, error) { pool := ctn.Get("mysql-pool").(*sql.DB) return pool.Conn(context.Background()) }, Close: func(obj interface{}) error { return obj.(*sql.Conn).Close() }, } func main() { builder, _ := di.NewEnhancedBuilder() builder.Add(MysqlPoolDef) builder.Add(MySqlDef) app, _ := builder.Build() defer app.Delete() http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { // 创建请求容器并在请求结束时删除 request, _ := app.SubContainer() defer request.Delete() handler(w, r, request) }) http.ListenAndServe(":8080", nil) }

在这个示例中，数据库连接池是应用级别的单例，而每个请求会获取自己的数据库连接，请求结束时自动关闭连接，既保证了连接的高效利用，又简化了资源管理。

总结：提升 Go 项目质量的得力助手

di7/di 作为一个功能强大的依赖注入容器，为 Go 项目提供了优雅的依赖管理解决方案。通过使用 di7/di，你可以：

• 编写更清晰、更解耦的代码
• 简化对象生命周期管理
• 提高代码可测试性和可维护性
• 轻松应对复杂的依赖关系

无论是小型工具还是大型应用，di7/di 都能帮助你构建更专业、更高质量的 Go 程序。

要开始使用 di7/di，只需通过以下命令克隆仓库：

git clone https://gitcode.com/gh_mirrors/di7/di

然后参考项目中的示例代码和文档，快速将依赖注入集成到你的项目中。

【免费下载链接】diDependency injection container in go (golang)项目地址: https://gitcode.com/gh_mirrors/di7/di