1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
# Go Dependency Inject Container
Main repo: [https://gitrepo.ru/neonxp/di](https://gitrepo.ru/neonxp/di). Github is only mirror.
Simple dependecy inject container with generics.
Use for your own risk!
## Usage
### Register dependency
```go
di.Register("service id", func () (*Service, error) { /* construct service */ })
```
### Get dependency
Get dependencies by type:
```go
services, err := di.GetByType[Service]()
```
Get dependencies by type and id:
```go
service, err := di.Get[Service]("service id")
```
Get dependencies by interface:
```go
services, err := di.GetByInterface[Worker]() // Worker is interface for many workers
```
### Go doc
```go
package di // import "go.neonxp.dev/di"
func Get[T any](id string) (*T, error)
func GetByInterface[Interface any]() ([]Interface, error)
func GetByType[T any]() ([]*T, error)
func Register[T any](id string, constructor func() (*T, error))
```
### Example
```go
di.Register("serviceA", func() (*ServiceA, error) { // <- Register service A
return &ServiceA{}, nil
})
di.Register("serviceB", func() (*ServiceB, error) { // <- Register service B, that depends from service A
serviceA, err := di.Get[ServiceA]() // <- Get dependency from container by type
if err != nil {
return nil, err
}
return &ServiceB{
ServiceA: serviceA[0],
}, nil
})
// Do work ...
service, err := di.Get[ServiceB]("serviceB") // <- Get instantinated service B
if err != nil {
panic(err)
}
service.DoStuff() // Output: Hello, world!
// Services ...
type ServiceA struct{}
func (d *ServiceA) DoStuff() {
fmt.Println("Hello, world!")
}
type ServiceB struct {
ServiceA *ServiceA
}
func (d *ServiceB) DoStuff() {
d.ServiceA.DoStuff()
}
```
## License
GPLv3
|
