Golang轻量级IoC依赖注入容器插件库GoLobby/Container的使用

GoLobby Container是一个轻量级但功能强大的Go项目IoC(依赖注入)容器。它设计简洁、易于使用，并注重性能。

主要特性

• 单例(Singleton)和瞬时(Transient)绑定
• 命名依赖项(绑定)
• 通过函数、变量和结构体解析依赖
• 将错误转换为panic的Must帮助方法
• 可选的延迟加载绑定
• 小型应用的全局实例
• 100%测试覆盖率

安装

在项目目录中运行以下命令安装：

go get github.com/golobby/container/v3

然后在代码中引入：

import "github.com/golobby/container/v3"

快速入门

基本绑定和解析示例

// 将Config接口绑定到JsonConfig结构体
err := container.Singleton(func() Config {
    return &JsonConfig{...}
})

var c Config
err := container.Resolve(&c)
// `c` 将是JsonConfig的实例

绑定类型

单例绑定(Singleton)

err := container.Singleton(func() Abstraction {
  return Implementation
})

// 如果需要返回错误
err := container.Singleton(func() (Abstraction, error) {
  return Implementation, nil
})

示例：

err := container.Singleton(func() Database {
  return &MySQL{}
})

瞬时绑定(Transient)

err := container.Transient(func() Shape {
  return &Rectangle{}
})

命名绑定

可以为同一个抽象类型绑定多个具体实现：

// 单例命名绑定
err := container.NamedSingleton("square", func() Shape {
    return &Rectangle{}
})
err := container.NamedSingleton("rounded", func() Shape {
    return &Circle{}
})

// 瞬时命名绑定
err := container.NamedTransient("sql", func() Database {
    return &MySQL{}
})
err := container.NamedTransient("noSql", func() Database {
    return &MongoDB{}
})

解析依赖

使用引用解析

var a Abstraction
err := container.Resolve(&a)
// `a` 将是Abstraction的实现

命名解析示例：

var s Shape
err := container.NamedResolve(&s, "rounded")
// `s` 将是名为"rounded"的Shape实现

使用闭包解析

err := container.Call(func(db Database) {
  // `db` 将是Database接口的实现
  db.Query("...")
})

可以解析多个依赖：

err := container.Call(func(db Database, s Shape) {
  db.Query("...")
  s.Area()
})

使用结构体解析

type App struct {
    mailer Mailer   `container:"type"`
    sql    Database `container:"name"`
    noSql  Database `container:"name"`
    other  int
}

myApp := App{}

err := container.Fill(&myApp)

// `myApp.mailer` 将是Mailer接口的实现
// `myApp.sql` 将是名为"sql"的Database实现
// `myApp.noSql` 将是名为"noSql"的Database实现
// `myApp.other` 将被忽略，因为它没有container标签

绑定时解析依赖

可以在绑定时解析其他依赖：

// 将Config绑定到JsonConfig
err := container.Singleton(func() Config {
    return &JsonConfig{...}
})

// 将Database绑定到MySQL
err := container.Singleton(func(c Config) Database {
    // `c` 将是JsonConfig的实例
    return &MySQL{
        Username: c.Get("DB_USERNAME"),
        Password: c.Get("DB_PASSWORD"),
    }
})

独立实例

默认情况下，容器将绑定保存在全局实例中。你也可以创建独立实例：

c := container.New()

err := c.Singleton(func() Database {
    return &MySQL{}
})

err := c.Call(func(db Database) {
    db.Query("...")
})

Must帮助方法

这些方法在出错时会panic而不是返回错误：

c := container.New()

container.MustSingleton(c, func() Shape {
    return &Circle{a: 13}
})

container.MustCall(c, func(s Shape) {
    // ...
})

延迟绑定

延迟绑定会推迟调用解析函数，直到第一次请求：

// 延迟单例绑定
err := container.SingletonLazy(func() Database {
    return &MySQL{}
})

// 延迟命名绑定
err := container.NamedSingletonLazy("db", func() Database {
    return &PostgreSQL{}
})

性能提示

容器不可避免地使用反射进行绑定和解析过程。如果性能是关键考虑因素，请尝试在只运行一次的地方(如main或init函数)绑定和解析依赖。

完整示例

package main

import (
	"fmt"
	"github.com/golobby/container/v3"
)

// 定义接口和实现
type Database interface {
	Query(string) string
}

type MySQL struct{}

func (m MySQL) Query(q string) string {
	return fmt.Sprintf("MySQL查询结果: %s", q)
}

type PostgreSQL struct{}

func (p PostgreSQL) Query(q string) string {
	return fmt.Sprintf("PostgreSQL查询结果: %s", q)
}

func main() {
	// 绑定接口到具体实现
	err := container.Singleton(func() Database {
		return &MySQL{}
	})
	if err != nil {
		panic(err)
	}

	// 命名绑定
	err = container.NamedSingleton("postgres", func() Database {
		return &PostgreSQL{}
	})
	if err != nil {
		panic(err)
	}

	// 解析默认实现
	var db Database
	err = container.Resolve(&db)
	if err != nil {
		panic(err)
	}
	fmt.Println(db.Query("SELECT * FROM users"))

	// 解析命名实现
	var pgDb Database
	err = container.NamedResolve(&pgDb, "postgres")
	if err != nil {
		panic(err)
	}
	fmt.Println(pgDb.Query("SELECT * FROM products"))

	// 使用闭包解析
	err = container.Call(func(db Database) {
		fmt.Println(db.Query("SELECT * FROM orders"))
	})
	if err != nil {
		panic(err)
	}
}

这个示例展示了GoLobby Container的基本用法，包括单例绑定、命名绑定以及多种解析方式。