Golang轻量级通用依赖注入容器插件库Ore的使用

Ore是一个强大且灵活的Go语言依赖注入(DI)库，旨在简化复杂应用程序结构，同时保持性能和模块化。

主要特性

1. 灵活的生命周期管理

• 单例(Singletons): 生命周期贯穿整个应用程序
• 作用域(Scoped): 生命周期绑定到特定上下文
• 瞬时(Transient): 每次解析时创建新实例

2. 别名支持

• 将多个实现链接到同一接口
• 轻松解析首选实现或检索所有注册选项

3. 优雅终止

• 应用程序终止: 按正确依赖顺序关闭所有已解析的单例(实现Shutdowner接口)
• 上下文终止: 当上下文结束时释放所有已解析的作用域实例(实现Disposer接口)

4. 占位符注册

• 在应用程序设置时注册不完整的依赖项
• 在请求或事件发生时动态提供运行时值

5. 多容器(模块)

• 为模块化应用程序创建隔离的依赖关系图
• 通过为每个容器分离服务注册和解析来强制模块边界

安装

go get -u github.com/firasdarwish/ore

快速示例

package main

import (
  "context"
  "fmt"
  "github.com/firasdarwish/ore"
)

// 定义一个服务
type MyService struct {
  Message string
}

func main() {
  // 注册一个单例服务
  ore.RegisterSingleton[SomeServiceInterface](&MyService{Message: "Hello, Ore!"})
  
  // 解析服务
  service, _ := ore.Get[*SomeServiceInterface](context.Background())
  fmt.Println(service.Message) // 输出: Hello, Ore!
}

完整示例

下面是一个更完整的示例，展示Ore的主要功能：

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/firasdarwish/ore"
)

// 定义接口
type Greeter interface {
	Greet() string
}

// 实现接口
type EnglishGreeter struct{}

func (g *EnglishGreeter) Greet() string {
	return "Hello, World!"
}

type ChineseGreeter struct{}

func (g *ChineseGreeter) Greet() string {
	return "你好，世界！"
}

// 需要注入的服务
type App struct {
	greeter Greeter `ore:"inject"`
}

func (a *App) Run() {
	fmt.Println(a.greeter.Greet())
}

func main() {
	// 创建容器
	container := ore.NewContainer()

	// 注册服务(使用别名)
	container.RegisterSingleton[Greeter](&EnglishGreeter{}, ore.WithAlias("en"))
	container.RegisterSingleton[Greeter](&ChineseGreeter{}, ore.WithAlias("zh"))

	// 注册应用服务
	container.RegisterTransient(func(g Greeter) *App {
		return &App{greeter: g}
	})

	// 创建上下文
	ctx := context.Background()

	// 解析特定语言的greeter
	enGreeter, err := container.GetTagged[Greeter](ctx, "en")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(enGreeter.Greet()) // 输出: Hello, World!

	zhGreeter, err := container.GetTagged[Greeter](ctx, "zh")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(zhGreeter.Greet()) // 输出: 你好，世界！

	// 解析App并运行
	app, err := container.Get[*App](ctx)
	if err != nil {
		log.Fatal(err)
	}
	app.Run() // 默认使用最后注册的Greeter实现
}

生命周期管理示例

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/firasdarwish/ore"
)

type Database struct {
	conn string
}

func (db *Database) Connect() {
	fmt.Println("Connecting to database:", db.conn)
}

func (db *Database) Disconnect() {
	fmt.Println("Disconnecting from database:", db.conn)
}

func (db *Database) Dispose() {
	db.Disconnect()
}

func main() {
	container := ore.NewContainer()

	// 注册单例服务
	container.RegisterSingleton(func() *Database {
		return &Database{conn: "singleton-connection"}
	})

	// 注册作用域服务
	container.RegisterScoped(func() *Database {
		return &Database{conn: "scoped-connection"}
	})

	// 注册瞬时服务
	container.RegisterTransient(func() *Database {
		return &Database{conn: "transient-connection"}
	})

	// 创建上下文
	ctx := context.Background()

	// 解析单例(多次解析返回同一实例)
	db1, _ := container.Get[*Database](ctx)
	db2, _ := container.Get[*Database](ctx)
	fmt.Println("Singleton equal:", db1 == db2) // true

	// 创建作用域上下文
	scopedCtx, dispose := ore.WithScope(ctx)
	defer dispose()

	// 解析作用域服务(同一作用域内返回同一实例)
	db3, _ := container.Get[*Database](scopedCtx)
	db4, _ := container.Get[*Database](scopedCtx)
	fmt.Println("Scoped equal:", db3 == db4) // true

	// 解析瞬时服务(每次返回新实例)
	db5, _ := container.Get[*Database](scopedCtx)
	db6, _ := container.Get[*Database](scopedCtx)
	fmt.Println("Transient equal:", db5 == db6) // false
}

Ore提供了强大的依赖注入功能，可以帮助您构建更模块化、更易测试的Go应用程序。