1. 首页
  2. 编程语言
  3. Golang
  4. 正文

goioc：一个使用 Go 写的简易的 ioc 框架

2022年11月27日 1664点热度 0人点赞 0条评论
内容目录

goioc 介绍

goioc 是一个基于 GO 语言编写的依赖注入框架，基于反射进行编写。

  • 支持泛型；
  • 简单易用的 API；
  • 简易版本的对象生命周期管理，作用域内对象具有生命；
  • 延迟加载，在需要的时候才会实例化对象；
  • 支持结构体字段注入，多层注入；
  • 对象实例化线程安全，作用域内只会被执行一次。

下载依赖：

go get -u github.com/whuanle/goioc v2.0.0

快速上手

定义接口：

type IAnimal interface {
    Println(s string)
}

实现接口：

type Dog struct {
}
func (my Dog) Println(s string) {
    fmt.Println(s)
}

依赖注入以及使用：

// 注册容器
var sc goioc.IServiceCollection = &ServiceCollection{}
// 注入服务
goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)
// 构建提供器
p := sc.Build()
// 获取服务
obj := goioc.Get[IAnimal](p)

接口介绍

IServiceCollection 是一个容器接口，通过此接口，将需要进行依赖注入的对象注册到容器中。

IServiceProvider 是一个服务提供器，当服务注册到容器后，构建一个服务提供器，IServiceProvider 可以管理服务的生命周期以及提供服务。

IDispose 接口用于声明此对象在 IServiceProvider 结束时，需要执行接口释放对象。

// IDispose 释放接口
type IDispose interface {
    // Dispose 释放资源
    Dispose()
}

除此之外，goioc 中还定义了部分扩展函数，如泛型注入等，代码量不多，简单易用。

使用 goioc

如何使用

注入的服务有两种形式，第一种是 B:A，即 B 实现了 A，使用的时候获取 A ；第二种是注入 B，使用的时候获取 B。

// 第一种
AddServiceOf[A,B]()
// 第二种
AddService[B]()

A 可以是接口或结构体，只要 B 实现了 A 即可。

定义一个接口：

type IAnimal interface {
    Println(s string)
}

实现这个接口：

type Dog struct {
    Id int
}

func (my Dog) Println(s string) {
    fmt.Println(s)
}

当使用依赖注入框架时，我们可以将接口和实现分开，甚至放到两个模块中，可以随时替换接口的实现。

注册服务和获取服务的代码示例如下：

func Demo() {
    sc := &ServiceCollection{}
    goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)
    p := sc.Build()
    animal := goioc.GetI[IAnimal](p)
    animal.Println("test")
}

下面讲解编码过程。

首先创建 IServiceCollection 容器，容器中可以注册服务。

sc := &ServiceCollection{}

然后通过接口注入服务：

goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)

这个函数是泛型方法。如果不使用泛型，则注入过程麻烦得多。

注册完毕后，开始构建提供器：

p := sc.Build()

然后获取服务：

    animal := goioc.GetI[IAnimal](p)
    animal.Println("test")

生命周期

goioc 中定义了三个生命周期：

const (
    Transient ServiceLifetime = iota
    Scope
    Singleton
)

Transient：瞬时模式，每次获取到的都是新的对象；

Scope：作用域模式，同一个 Provider 中获取到的是同一个对象。

Singleton：单例模式，同一个 ServiceCollection 获取到的是同一个对象，也就是所有 Provider 获取到的都是同一个对象。

如果是单例模式(Singleton)，那么无论多少次 Build，对象始终是同一个：

在注册服务的时候，需要注明对象生命周期。

goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)

生命周期为 scope 的注入，同一个 Provider 中，获取到的对象是一样的。

    sc := &ServiceCollection{}
    goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)
    p := sc.Build()

    // 第一次获取对象
    animal1 := goioc.GetI[IAnimal](p)
    if animal1 == nil {
        t.Errorf("service is nil!")
    }
    animal1.Println("test")

    // 第二次获取对象
    animal2 := goioc.GetI[IAnimal](p)
    if animal2 == nil {
        t.Errorf("service is nil!")
    }

    // animal1 和 animal2 引用了同一个对象
    if animal1 != animal2 {
        t.Errorf("animal1 != animal2")
    }

实例一，Scope 生命周期的对象，在同一个提供器下获取到的都是同一个对象。

    sc := &ServiceCollection{}
    goioc.AddServiceHandlerOf[IAnimal, Dog](sc, goioc.Scope, func(provider goioc.IServiceProvider) interface{} {
        return &Dog{
            Id: 3,
        }
    })

    p := sc.Build()

    // 第一次获取
    a := goioc.GetI[IAnimal](p)

    if v := a.(*Dog); v == nil {
        t.Errorf("service is nil!")
    }
    v := a.(*Dog)
    if v.Id != 2 {
        t.Errorf("Life cycle error")
    }
    v.Id = 3

    // 第二次获取
    aa := goioc.GetI[IAnimal](p)
    v = aa.(*Dog)
    if v.Id != 3 {
        t.Errorf("Life cycle error")
    }

    // 重新构建的 scope，不是同一个对象
    pp := sc.Build()
    aaa := goioc.GetI[IAnimal](pp)
    v = aaa.(*Dog)
    if v.Id != 2 {
        t.Errorf("Life cycle error")
    }

实例二， ServiceCollection 构建的提供器，单例模式下获取到的都是同一个对象。

    sc := &ServiceCollection{}
    goioc.AddServiceHandler[Dog](sc, goioc.Singleton, func(provider goioc.IServiceProvider) interface{} {
        return &Dog{
            Id: 2,
        }
    })

    p := sc.Build()
    b := goioc.GetS[Dog](p)
    if b.Id != 2 {
        t.Errorf("Life cycle error")
    }

    b.Id = 3

    bb := goioc.GetS[Dog](p)
    if b.Id != bb.Id {
        t.Errorf("Life cycle error")
    }
    ppp := sc.Build()

    bbb := goioc.GetS[Dog](ppp)
    if b.Id != bbb.Id {
        t.Errorf("Life cycle error")
    }

实例化

由开发者决定如何实例化一个对象。

主要由注册形式决定，有四个泛型函数实现注册服务：

// AddService 注册对象
func AddService[T any](con IServiceCollection, lifetime ServiceLifetime)

// AddServiceHandler 注册对象，并自定义如何初始化实例
func AddServiceHandler[T any](con IServiceCollection, lifetime ServiceLifetime, f func(provider IServiceProvider) interface{})

// AddServiceOf 注册对象，注册接口或父类型及其实现，serviceType 必须实现了 baseType
func AddServiceOf[I any, T any](con IServiceCollection, lifetime ServiceLifetime)

// AddServiceHandlerOf 注册对象，注册接口或父类型及其实现，serviceType 必须实现了 baseType，并自定义如何初始化实例
func AddServiceHandlerOf[I any, T any](con IServiceCollection, lifetime ServiceLifetime, f func(provider IServiceProvider) interface{})

AddService[T any]：只注册可被实例化的对象：

AddService[T any]
goioc.AddService[Dog](sc, goioc.Scope)

AddServiceHandler 注册一个接口或结构体，自定义实例化。

func(provider goioc.IServiceProvider) interface{} 函数会在实例化对象时执行。

    goioc.AddServiceHandler[Dog](sc, goioc.Scope, func(provider goioc.IServiceProvider) interface{} {
        return &Dog{
            Id: 1,
        }
    })

在实例化时，如果这个对象还依赖其他服务，则可以通过 goioc.IServiceProvider 来获取其他依赖。

例如下面示例中，一个依赖另一个对象，可以自定义实例化函数，从容器中取出其他依赖对象，然后构建一个新的对象。

    goioc.AddServiceHandler[Dog](sc, goioc.Scope, func(provider goioc.IServiceProvider) interface{} {
        a := goioc.GetI[IA](provider)
        return &Dog{
            Id: 1,
            A:  a,
        }
    })
    goioc.AddServiceHandler[Dog](sc, goioc.Scope, func(provider goioc.IServiceProvider) interface{} {
        config := goioc.GetI[Config](provider)
        if config.Enable == false
        return &Dog{
            Id: 1,
        }
    })

获取对象

前面提到，我们可以注入 [A,B]，或者 [B]。

那么获取的时候就有三种函数：

// Get 获取对象
func Get[T any](provider IServiceProvider) interface{} 

// GetI 根据接口获取对象
func GetI[T interface{}](provider IServiceProvider) T 

// GetS 根据结构体获取对象
func GetS[T interface{} | struct{}](provider IServiceProvider) *T

Get[T any] 获取接口或结构体，返回 interface{} 。

GetI[T interface{}] 获取的是一个接口实例。

GetS[T interface{} | struct{}] 获取的是一个结构体实例。

以上三种方式，返回的都是对象的引用，即指针。

    sc := &ServiceCollection{}
    goioc.AddService[Dog](sc, goioc.Scope)
    goioc.AddServiceOf[IAnimal, Dog](sc, goioc.Scope)
    p := sc.Build()

    a := goioc.Get[IAnimal](p)
    b := goioc.Get[Dog](p)
    c := goioc.GetI[IAnimal](p)
    d := goioc.GetS[Dog](p)

结构体字段依赖注入

结构体中的字段，可以自动注入和转换实例。

如结构体 Animal 的定义，其使用了其它结构体，goioc 可以自动注入 Animal 对应字段，要被注入的字段必须是接口或者结构体。

// 结构体中包含了其它对象
type Animal struct {
    Dog IAnimal <code>ioc:"true"</code>
}

要对需要自动注入的字段设置 tag 中包含ioc:"true" 才会生效。

示例代码：

    sc := &ServiceCollection{}
    goioc.AddServiceHandlerOf[IAnimal, Dog](sc, goioc.Scope, func(provider goioc.IServiceProvider) interface{} {
        return &Dog{
            Id: 666,
        }
    })
    goioc.AddService[Animal](sc, goioc.Scope)

    p := sc.Build()
    a := goioc.GetS[Animal](p)
    if dog := a.Dog.(*Dog); dog.Id != 666 {
        t.Errorf("service is nil!")
    }

goioc 可以自动给你的结构体字段进行自动依赖注入。

注意，goioc 的字段注入转换逻辑是这样的。

如果 obj 要转换为接口，则是使用：

  animal := (*obj).(IAnimal)

如果 obj 要转换为结构体，则是：

  animal := (*obj).(*Animal)

Dispose 接口

反射形式使用 goioc

如何使用

goioc 的原理是反射，ioc 使用了大量的反射机制实现依赖注入，但是因为 Go 的反射比较难用，导致操作十分麻烦，因此使用泛型包装一层可以降低使用难度。

当然，也可以直接使用原生的反射方式进行依赖注入。

首先反射通过反射获取 reflect.Type。

    // 获取 reflect.Type
    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()

依赖注入：

    // 创建容器
    sc := &ServiceCollection{}

    // 注入服务，生命周期为 scoped
    sc.AddServiceOf(goioc.Scope, imy, my)

    // 构建服务 Provider
    serviceProvider := sc.Build()

获取服务以及进行类型转换：

    // 获取对象
    // *interface{} = &Dog{}，因此需要处理指针
    obj, err := serviceProvider.GetService(imy)
    animal := (*obj).(IAnimal)

示例：

    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()
    var sc IServiceCollection = &ServiceCollection{}
    sc.AddServiceOf(goioc.Scope,imy, my)
    p := sc.Build()

    // 获取对象
    // *interface{} = &Dog{}，因此需要处理指针
    obj1, _ := p.GetService(imy)
    obj2, _ := p.GetService(imy)

    fmt.Printf("obj1 = %p,obj2 = %p\r\n", (*obj1).(*Dog), (*obj2).(*Dog))
    if fmt.Sprintf("%p",(*obj1).(*Dog)) != fmt.Sprintf("%p",(*obj2).(*Dog)){
        t.Error("两个对象不是同一个")
    }

获取接口和结构体的 reflect.Type：

// 写法 1
    // 接口的 reflect.Type
    var animal IAnimal
    imy := reflect.TypeOf(&animal).Elem()
    my := reflect.TypeOf(Dog{})

// 写法 2
    // 获取 reflect.Type
    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()

以上两种写法都可以使用，目的在于获取到接口和结构体的 reflect.Type。不过第一种方式会实例化结构体，消耗了一次内存，并且要获取接口的 reflect.Type，是不能直接有用 reflect.TypeOf(animal) 的，需要使用 reflect.TypeOf(&animal).Elem() 。

然后注入服务，其生命周期为 Scoped：

    // 注入服务，生命周期为 scoped
    sc.AddServiceOf(goioc.Scope, imy, my)

当你需要 IAnimal 接口时，会自动注入 Dog 结构体给 IAnimal。

构建依赖注入服务提供器：

    // 构建服务 Provider
    serviceProvider := sc.Build()

构建完成后，即可通过 Provider 对象获取需要的实例：

    // 获取对象
    // *interface{}
    obj, err := serviceProvider.GetService(imy)
    if err != nil {
        panic(err)
    }

    // 转换为接口
    a := (*obj).(IAnimal)
    //  a := (*obj).(*Dog)

因为使用了依赖注入，我们使用时，只需要使用接口即可，不需要知道具体的实现。

完整的代码示例：

    // 获取 reflect.Type
    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()

    // 创建容器
    sc := &ServiceCollection{}

    // 注入服务，生命周期为 scoped
    sc.AddServiceOf(goioc.Scope, imy, my)

    // 构建服务 Provider
    serviceProvider := sc.Build()

    // 获取对象
    // *interface{} = &Dog{}
    obj, err := serviceProvider.GetService(imy)

    if err != nil {
        panic(err)
    }

    fmt.Println("obj 类型是", reflect.ValueOf(obj).Type())

    // *interface{} = &Dog{}，因此需要处理指针
    animal := (*obj).(IAnimal)
    //  a := (*obj).(*Dog)
    animal.Println("测试")

接口、结构体、结构体指针

在结构体注入时，可以对需要的字段进行自动实例化赋值，而字段可能有以下情况：

// 字段是接口
type Animal1 struct {
    Dog IAnimal <code>ioc:"true"</code>
}

// 字段是结构体
type Animal2 struct {
    Dog Dog <code>ioc:"true"</code>
}

// 字段是结构体指针
type Animal3 struct {
    Dog *Dog <code>ioc:"true"</code>
}

首先注入前置的依赖对象：

    // 获取 reflect.Type
    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()

    // 创建容器
    p := &ServiceCollection{}

    // 注入服务，生命周期为 scoped
    p.AddServiceOf(goioc.Scope,imy, my)
    p.AddService(goioc.Scope, my)

然后将我们的一些对象注入进去：

    t1 := reflect.TypeOf((*Animal1)(nil)).Elem()
    t2 := reflect.TypeOf((*Animal2)(nil)).Elem()
    t3 := reflect.TypeOf((*Animal3)(nil)).Elem()

    p.Ad(t1)
    p.AddServiceOf(goioc.Scope,t2)
    p.AddServiceOf(goioc.Scope,t3)

然后愉快地获取这些对象实例：

    // 构建服务 Provider
    p := collection.Build()

    v1, _ := p.GetService(t1)
    v2, _ := p.GetService(t2)
    v3, _ := p.GetService(t3)

    fmt.Println(*v1)
    fmt.Println(*v2)
    fmt.Println(*v3)

打印对象信息：

&{0x3abdd8}
&{{}}
&{0x3abdd8}

可以看到，当你注入实例后，结构体字段可以是接口、结构体或结构体指针，goioc 会根据不同的情况注入对应的实例。

前面提到了对象是生命周期，这里有些地方需要注意。

如果字段是接口和结构体指针，那么 scope 生命周期时，注入的对象是同一个，可以参考前面的 v1、v3 的 Dog 字段，Dog 字段类型虽然不同，但是因为可以存储指针，因此注入的对象是同一个。如果字段是结构体，由于 Go 语言中结构体是值类型，因此给值类型赋值是，是值赋值，因此对象不是同一个了。

不会自动注入本身

下面是一个依赖注入过程：

    // 获取 reflect.Type
    imy := reflect.TypeOf((*IAnimal)(nil)).Elem()
    my := reflect.TypeOf((*Dog)(nil)).Elem()

    // 创建容器
    sc := &ServiceCollection{}

    // 注入服务，生命周期为 scoped
    sc.AddServiceOf(goioc.Scope,imy, my)

此时，注册的服务是 IAnimal，你只能通过 IAnimal 获取实例，无法通过 Dog 获取实例。

如果你想获取 Dog，需要自行注入：

    // 注入服务，生命周期为 scoped
    p.AddServiceOf(goioc.Scope,imy, my)
    p.AddService(my)

如果是结构体字段，则使用 IAnimal、Dog、*Dog 的形式都可以。

本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可
标签：
最后更新：2022年11月27日

痴者工良

高级程序员劝退师

文章评论

razz evil exclaim smile redface biggrin eek confused idea lol mad twisted rolleyes wink cool arrow neutral cry mrgreen drooling persevering

文章目录

COPYRIGHT © 2024 whuanle.cn. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang

粤ICP备18051778号

粤公网安备 44030902003257号