依赖注入不是Java的专利,Golang也有

钱文品 · · 470 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

笔者在使用Golang的时候就发现构建系统依赖树非常繁琐,New了很多对象,又手工代码将它们拼接起来,写了一堆非常冗繁的代码。然后就开始想,要是Golang像Java一样有一个好用的依赖注入框架就好啦。

果不其然,Golang还真有,居然还是大厂facebook团队开源的。

Golang的很多用户都不是来自Java,依赖注入他们可能听过,可是从来没有玩过。为了说明依赖注入有多好用,我先用Java代码来解释一下。

先来看一下没有依赖注入的Java世界是怎样的

class DBEngine {
}

class CacheEngine {
	
}

class UserDB {

	private DBEngine db;
	private CacheEngine cache;

	public UserDB(DBEngine db, CacheEngine cache) {
		this.db = db;
		this.cache = cache;
	}

}

class ItemDB {

	private DBEngine db;
	private CacheEngine cache;

	public ItemDB(DBEngine db, CacheEngine cache) {
		this.db = db;
		this.cache = cache;
	}

}

class UserService {

	private UserDB db;

	public UserService(UserDB db) {
		this.db = db;
	}

}

class ItemService {

	private ItemDB db;

	public ItemService(ItemDB db) {
		this.db = db;
	}

}

class App {

	private UserService user;
	private ItemService item;

	public App(UserService user, ItemService item) {
		this.user = user;
		this.item = item;
	}
}

public class GuiceTest {

	public static void main(String[] args) {
		DBEngine db = new DBEngine();
		CacheEngine cache = new CacheEngine();
		UserDB userDB = new UserDB(db, cache);
		ItemDB itemDB = new ItemDB(db, cache);
		UserService userServ = new UserService(userDB);
		ItemService itemServ = new ItemService(itemDB);
		App app = new App(userServ, itemServ);
	}

}

在main方法里面,我们new出来很多对象,然后用他们构造了一颗依赖树。我们还写了很多构造器,为了能方便的构造出每个节点。

然后我们用依赖注入框架来改造它。

class DBEngine {
}

class CacheEngine {
}

@Singleton
class UserDB {

	@Inject
	private DBEngine db;
	@Inject
	private CacheEngine cache;

}

@Singleton
class ItemDB {
	@Inject
	private DBEngine db;
	@Inject
	private CacheEngine cache;

}

@Singleton
class UserService {

	@Inject
	private UserDB db;

}

@Singleton
class ItemService {

	@Inject
	private ItemDB db;

}

@Singleton
class App {

	@Inject
	private UserService user;
	@Inject
	private ItemService item;

}

class AppModule extends AbstractModule {

	@Override
	protected void configure() {
		DBEngine db = new DBEngine();
		CacheEngine cache = new CacheEngine();
		bind(DBEngine.class).toInstance(db);
		bind(CacheEngine.class).toInstance(cache);
	}

}

public class GuiceTest {

	public static void main(String[] args) {
		Injector injector = Guice.createInjector(new AppModule());
		App app = injector.getInstance(App.class);
	}

}

这里我们使用的是另一个开源大厂google的依赖注入框架Guice。我们发现main方法缩减了很多代码,所有的new操作都不见了,然后我们还发现每个对象的构造器也消失了,取而代之的是多了两个注解@Singleton和@Inject,Singleton表示类是单例的,Inject表示当前字段使用依赖注入自动设置。好处不用多说,一目了然,就是帮我们节省代码,省去了很多系统初始化时构建一系列对象的细节。另外Guice还需要定义一个Module,把依赖树的叶子节点手工实例化一下,叶子结点对象往往不是简单的依赖注入,而需要手动构造。如果把整个系统的状态比喻成现实的物理世界,那么Module里面干的事就是宇宙大爆炸,所有一切对象的输入源点。依赖注入仅仅帮我们省去了中间节点的构建工作。

在我们的例子中,这棵树还谈不上复杂,毕竟节点数很有限,节点之间的连接也很有限。在大型的复杂业务系统中,这样的对象那就是成百上千了,如果没有使用依赖注入的话,那就真是剪不断理还乱了。

好,接下来我们说说facebookgo团队开源的这个Inject框架如何使用。我们还使用上面的例子,用golang 改写一下。

首先,我们看一下没有依赖注入的Golang世界是怎样的。

type DBEngine struct{}

func NewDBEngine() *DBEngine {
	return &DBEngine{}
}

type CacheEngine struct{}

func NewCacheEngine() *CacheEngine {
	return &CacheEngine{}
}

type UserDB struct {
	db    *DBEngine
	cache *CacheEngine
}

func NewUserDB(db *DBEngine, cache *CacheEngine) *UserDB {
	return &UserDB{db, cache}
}

type ItemDB struct {
	db    *DBEngine
	cache *CacheEngine
}

func NewItemDB(db *DBEngine, cache *CacheEngine) *ItemDB {
	return &ItemDB{db, cache}
}

type UserService struct {
	db *UserDB
}

func NewUserService(db *UserDB) *UserService {
	return &UserService{db}
}

type ItemService struct {
	db *ItemDB
}

func NewItemService(db *ItemDB) *ItemService {
	return &ItemService{db}
}

type App struct {
	user *UserService
	item *ItemService
}

func NewApp(user *UserService, item *ItemService) *App {
	return &App{user, item}
}

func main() {
	db := NewDBEngine()
	cache := NewCacheEngine()
	userDB := NewUserDB(db, cache)
	itemDB := NewItemDB(db, cache)
	userServ := NewUserService(userDB)
	itemServ := NewItemService(itemDB)
	_ = NewApp(userServ, itemServ)
}

跟Java版本一样,定义了不少构造器,然后手工组装依赖树。

然后我们把这段代码改造成facebookgo依赖注入版本的

import "github.com/facebookgo/inject"

type DBEngine struct{}

func NewDBEngine() *DBEngine {
	return &DBEngine{}
}

type CacheEngine struct{}

func NewCacheEngine() *CacheEngine {
	return &CacheEngine{}
}

type UserDB struct {
	db    *DBEngine    `inject:""`
	cache *CacheEngine `inject:""`
}

type ItemDB struct {
	db    *DBEngine    `inject:""`
	cache *CacheEngine `inject:""`
}

type UserService struct {
	db *UserDB `inject:""`
}

type ItemService struct {
	db *ItemDB `inject:""`
}

type App struct {
	user *UserService `inject:""`
	item *ItemService `inject:""`
}

func main() {
	db := NewDBEngine()
	cache := NewCacheEngine()
	var g inject.Graph
	var app App
	g.Provide(
		&inject.Object{Value: &app},
		&inject.Object{Value: db},
		&inject.Object{Value: cache})
	g.Populate()
	// use app do something
}

这个跟Java版本也很类似,只是Module的定义直接放在了main方法里,也就是上面代码中的Provide方法调用,@Singleton不需要了,@Inject变成了`inject:""`。然后用Populate方法一次性将整个依赖树构建出来就可以使用了。

看这个开源库的源码发现,整个类库的实现才500多行代码。这是多么轻量级的一个类库,只不过代码这么短,功能也不会太多,相比Java的依赖注入而言,它的功能就单一太多了。不过没关系,相比Guice而言这些缺失的功能不是必须的,能帮我们省掉很多代码它已经做得很好了,这就足够了。要知道Java里面非常完善的依赖注入框架80%的代码那都是为了实现那20%的特殊功能,基本功能所需要的代码量是非常少的。

阅读更多相关文章,请关注知乎专栏【码洞】

本文来自:知乎专栏

感谢作者:钱文品

查看原文:依赖注入不是Java的专利,Golang也有

470 次点击  
加入收藏 微博
2 回复  |  直到 2018-01-12 14:53:55
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传