分解uber依赖注入库dig-使用篇
golang的依赖注入库非常的少,好用的更是少之又少,比较好用的目前有两个
本系列分几部分,先对dig进行分析,第一篇介绍dig
的使用,第二篇再从源码来剖析他是如何通过返射实现的的依赖注入的,后续会介绍fx 的使用和实现原理。
dig主要的思路是能过Provider
将不同的函数注册到容器内,一个函数可以通过参数来声明对其他函数返回值的依赖。在Invoke
的时候才会真正的去调用容器内相应的Provider
方法。
dig
还提供了可视化的方法Visualize
用于生成dot
有向图代码,更直观的观察依赖关系,关于dot
的基本语法,可以查看帖子dot 语法总结
使用的dig
版本为1.11.0-dev
,帖子所有的代码都在github
上,地址:fx_dig_adventure
简单使用
func TestSimple1(t *testing.T) {
type Config struct {
Prefix string
}
c := dig.New()
err := c.Provide(func() (*Config, error) {
return &Config{Prefix: "[foo] "}, nil
})
if err != nil {
panic(err)
}
err = c.Provide(func(cfg *Config) *log.Logger {
return log.New(os.Stdout, cfg.Prefix, 0)
})
if err != nil {
panic(err)
}
err = c.Invoke(func(l *log.Logger) {
l.Print("You've been invoked")
})
if err != nil {
panic(err)
}
}
输出
[foo] You've been invoked
可以生成dot
图,来更直观的查看依赖关系
b := &bytes.Buffer{}
if err := dig.Visualize(c, b); err != nil {
panic(err)
}
fmt.Println(b.String())
输出
digraph {
rankdir=RL;
graph [compound=true];
subgraph cluster_0 {
label = "main";
constructor_0 [shape=plaintext label="main.func1"];
"*main.Config" [label=<*main.Config>];
}
subgraph cluster_1 {
label = "main";
constructor_1 [shape=plaintext label="main.func2"];
"*log.Logger" [label=<*log.Logger>];
}
constructor_1 -> "*main.Config" [ltail=cluster_1];
}
可以看到 func2
返回的参数为Log
依赖 func1
返回参数 Config
。dot 语法总结
展示出来:
命名参数--多个返回相同类型的Provide
如果Provide
里提供的函数,有多个函数返回的数据类型是一样的怎么处理?比如,我们的数据库有主从两个连接库,怎么进行区分?
dig
可以将Provide
命名以进行区分
我们可以直接在Provide
函数里使用dig.Name
,为相同的返回类型设置不同的名字来进行区分。
func TestName1(t *testing.T) {
type DSN struct {
Addr string
}
c := dig.New()
p1 := func() (*DSN, error) {
return &DSN{Addr: "primary DSN"}, nil
}
if err := c.Provide(p1, dig.Name("primary")); err != nil {
t.Fatal(err)
}
p2 := func() (*DSN, error) {
return &DSN{Addr: "secondary DSN"}, nil
}
if err := c.Provide(p2, dig.Name("secondary")); err != nil {
t.Fatal(err)
}
type DBInfo struct {
dig.In
PrimaryDSN *DSN `name:"primary"`
SecondaryDSN *DSN `name:"secondary"`
}
if err := c.Invoke(func(db DBInfo) {
t.Log(db.PrimaryDSN)
t.Log(db.SecondaryDSN)
}); err != nil {
t.Fatal(err)
}
}
输出
&{primary DSN}
&{secondary DSN}
dot
图
这样做并不通用,一般我们是有一个结构体来实现,dig
也有相应的支持,用一个结构体嵌入dig.out
来实现,
相同类型的字段在tag
里设置不同的name
来实现
func TestName2(t *testing.T) {
type DSN struct {
Addr string
}
c := dig.New()
type DSNRev struct {
dig.Out
PrimaryDSN *DSN `name:"primary"`
SecondaryDSN *DSN `name:"secondary"`
}
p1 := func() (DSNRev, error) {
return DSNRev{PrimaryDSN: &DSN{Addr: "Primary DSN"},
SecondaryDSN: &DSN{Addr: "Secondary DSN"}}, nil
}
if err := c.Provide(p1); err != nil {
t.Fatal(err)
}
type DBInfo struct {
dig.In
PrimaryDSN *DSN `name:"primary"`
SecondaryDSN *DSN `name:"secondary"`
}
inv1 := func(db DBInfo) {
t.Log(db.PrimaryDSN)
t.Log(db.SecondaryDSN)
}
if err := c.Invoke(inv1); err != nil {
t.Fatal(err)
}
}
输出
&{primary DSN}
&{secondary DSN}
dot
图
和上面的不同之处就是一个function
返回了两个相同类型的字段。
组--把同类型的参数放在一个slice里
如果有很多相同类型的返回参数,可以把他们放在同一个slice
里,和命名方式一样,有两种使用方式
第一种在调用Provide
时直接使用dig.Group
func TestGroup1(t *testing.T) {
type Student struct {
Name string
Age int
}
NewUser := func(name string, age int) func() *Student {
return func() *Student {
return &Student{name, age}
}
}
container := dig.New()
if err := container.Provide(NewUser("tom", 3), dig.Group("stu")); err != nil {
t.Fatal(err)
}
if err := container.Provide(NewUser("jerry", 1), dig.Group("stu")); err != nil {
t.Fatal(err)
}
type inParams struct {
dig.In
StudentList []*Student `group:"stu"`
}
Info := func(params inParams) error {
for _, u := range params.StudentList {
t.Log(u.Name, u.Age)
}
return nil
}
if err := container.Invoke(Info); err != nil {
t.Fatal(err)
}
}
输出
jerry 1
tom 3
生成dot
图
或者使用结构体嵌入dig.Out
来实现,tag
里要加上了group
标签
type Rep struct {
dig.Out
StudentList []*Student `group:"stu,flatten"`
}
这个flatten
的意思是,底层把组表示成[]*Student
,如果不加flatten
会表示成[][]*Student
完整示例
func TestGroup2(t *testing.T) {
type Student struct {
Name string
Age int
}
type Rep struct {
dig.Out
StudentList []*Student `group:"stu,flatten"`
}
NewUser := func(name string, age int) func() Rep {
return func() Rep {
r := Rep{}
r.StudentList = append(r.StudentList, &Student{
Name: name,
Age: age,
})
return r
}
}
container := dig.New()
if err := container.Provide(NewUser("tom", 3)); err != nil {
t.Fatal(err)
}
if err := container.Provide(NewUser("jerry", 1)); err != nil {
t.Fatal(err)
}
type InParams struct {
dig.In
StudentList []*Student `group:"stu"`
}
Info := func(params InParams) error {
for _, u := range params.StudentList {
t.Log(u.Name, u.Age)
}
return nil
}
if err := container.Invoke(Info); err != nil {
t.Fatal(err)
}
}
输出
jerry 1
tom 3
生成dot
图
从dot
图可以看出有两个方法生成了Group: stu
需要注意的一点是,命名方式和组方式不能同时使用。
可选参数
如果注册的方法返回的参数是可以为nil的,可以使用option
来实现
func TestOption1(t *testing.T) {
type Student struct {
dig.Out
Name string
Age *int `option:"true"`
}
c := dig.New()
if err := c.Provide(func() Student {
return Student{
Name: "Tom",
}
}); err != nil {
t.Fatal(err)
}
if err := c.Invoke(func(n string, age *int) {
t.Logf("name: %s", n)
if age == nil {
t.Log("age is nil")
} else {
t.Logf("age: %d", age)
}
}); err != nil {
t.Fatal(err)
}
}
输出
name: Tom
age is nil
dry run
如果我们只是想看一下依赖注入的整个流程是不是通的,可以通过dry run
来跑一下,他不会调用具体的函数,而是直接返回函数的返回参数的zero
值
func TestDryRun1(t *testing.T) {
// Dry Run
c := dig.New(dig.DryRun(true))
type Config struct {
Prefix string
}
err := c.Provide(func() (*Config, error) {
return &Config{Prefix: "[foo] "}, nil
})
if err != nil {
panic(err)
}
err = c.Provide(func(cfg *Config) *log.Logger {
return log.New(os.Stdout, cfg.Prefix, 0)
})
if err != nil {
panic(err)
}
err = c.Invoke(func(l *log.Logger) {
l.Print("You've been invoked")
})
if err != nil {
panic(err)
}
}
运行代码不会有任何输出。
分解uber依赖注入库dig-使用篇的更多相关文章
- 分解uber依赖注入库dig-源码分析
上一篇帖子 分解uber依赖注入库dig-使用篇 把如何使用dig进行代码示例说明,这篇帖子分析dig的源码,看他是如何实现依赖注入的. dig实现的中心思想:所有传入Provide的函数必须要有除e ...
- Google 开源的依赖注入库,比 Spring 更小更快!
Google开源的一个依赖注入类库Guice,相比于Spring IoC来说更小更快.Elasticsearch大量使用了Guice,本文简单的介绍下Guice的基本概念和使用方式. 学习目标 概述: ...
- Json.NET提供依赖注
Json.NET提供依赖注 [.NET] 使用Json.NET提供依赖注入功能(Dependence Injection) 前言 在一些小型项目的开发情景里,系统不需要大型DI Framework所提 ...
- 任务21 :了解ASP.NET Core 依赖注入,看这篇就够了
DI在.NET Core里面被提到了一个非常重要的位置, 这篇文章主要再给大家普及一下关于依赖注入的概念,身边有工作六七年的同事还个东西搞不清楚.另外再介绍一下.NET Core的DI实现以及对实例 ...
- spring依赖注入时,什么时候会创建代理类
spring 依赖注入时,什么时候会创建代理类 有的会创建代理类来替代目标类的实现.比如有事务注解啊 有的直接使用目标类.啥拦截配置都没有.
- 了解ASP.NET Core 依赖注入,看这篇就够了 于2017年11月6日由jesseliu发布
DI在.NET Core里面被提到了一个非常重要的位置, 这篇文章主要再给大家普及一下关于依赖注入的概念,身边有工作六七年的同事还个东西搞不清楚.另外再介绍一下.NET Core的DI实现以及对实例 ...
- 了解ASP.NET Core 依赖注入,看这篇就够了
DI在.NET Core里面被提到了一个非常重要的位置, 这篇文章主要再给大家普及一下关于依赖注入的概念,身边有工作六七年的同事还个东西搞不清楚.另外再介绍一下.NET Core的DI实现以及对实例 ...
- 【开源项目7】Android视图注入库:butterknife
介绍 ButterKnife通过@InjectView和视图的ID注解的变量去找到并自动转换为你布局上相应的布局视图. class ExampleActivity extends Activity { ...
- spring 依赖注入时,什么时候会创建代理类
问题来源 以前一直有个疑惑,为什么我创建的controller中注入的service类有时候是代理类,有时候是普通javabean,当时能力不够,现在已经有了点经验就大胆跟了跟源码,看看到底咋回事. ...
随机推荐
- 1.2 Python3基础-规范
>>返回主目录 总的来说,如果安装的不是安装的Anaconda,pip命令还是经常会用到的(cmd模式使用),当然也可以在PyCharm中直接安装 PEP8规范,我另有一篇博客已经写好,可 ...
- mongodb导入,导出实例
MongoDB中文手册|官方文档中文版 英文版:https://docs.mongodb.com/manual/ 1.mongoexport 导出文件 打开命令行,进入我们所安装的mongodb路径下 ...
- 迷宫问题(DFS)
声明:图片及内容基于https://www.bilibili.com/video/BV1oE41177wk?t=3245 问题及分析 8*8的迷宫,最外周是墙,0表示可以走,1表示不可以走 设置迷宫 ...
- 基于renren-fast的快速入门项目实战(实现报表增删改查)
基于renren-fast的快速入门项目实战(实现报表增删改查) 说明:renren-fast是一个开源的基于springboot的前后端分离手脚架,当前版本是3.0 官方开发文档需付费,对于新手而言 ...
- 题解 CF746D 【Green and Black Tea】
# 题目分析这道题表面上看上去挺简单,其实仔细研究一下还是值得钻研的.我本人做这道题使用的任然是$ DFS01 $背包.不过呢,与往常背包不同的是,这次递归中需要加许多参数.就数据强度来看,栈问题不大 ...
- Django之Auth认证模块
一.Auth模块是什么 Auth模块是Django自带的用户认证模块: 我们在开发网站的时候,无可避免的需要设计实现网站的用户系统,此时我们需要实现包括用户注册,用户登陆,用户认证,注销修改密码等功能 ...
- Python读写配置文件模块--Configobj
一.介绍 我们在项目的开发过程中应该会遇到这样的问题:我们的项目读取某个配置文件,然后才能按照配置的信息正常运行服务,当我们需要对修改服务的某些信息时,可以直接修改这个配置文件,重启服务即可,不用再去 ...
- P1036_选数(JAVA语言)
题目描述 已知 n 个整数x1,x2,-,xn,以及1个整数k(k<n).从n个整数中任选k个整数相加,可分别得到一系列的和.例如当n=4,k=3,4个整数分别为3,7,12,19时,可得 ...
- 创建Maven父子项目以及它们的优点
此文引用:https://blog.csdn.net/zxl8876/article/details/104180133 创建maven父子项目 第一步创建父项目: 新建一个普通的maven项目 删除 ...
- 【pytorch学习笔记0】-CNN与LSTM输入输出维度含义
卷积data的四个维度: batch, input channel, height, width Conv2d的四个维度: input channel, output channel, kernel, ...