程序必须是为了给人看而写,给机器去执行只是附带任务。
目录
前言
说起依赖注入(DI),相信你首先想到的必然是Spring
,Spring是Java技术全家桶,是Java EE开发的一站式解决方案和实际开发标准。但本文并不聊它,而是介绍一款谷歌开源的轻量级依赖注入框架:Guice
。
Guice
在Java领域并不流行(相较于Spring),但因为它轻量级,所以可以作为你去学习理解DI的一个抓手,适合你去进行独立的分析和理解依赖注入的思想,毕竟程序员经常说的:思想都是相通的。
另外,学习它还有一个重要原因是有些流行框架/库使用了它作为基础DI库,如:Druid、Elastic Search、Play2
以及我们熟悉的携程开源的Apollo
和Netflix的Eureka
。
正文
正所谓谷歌出品,必属精品,况且Guice
还出自于它的广告这种多金部门,自然也不例外。Google Guice
被大量应用于谷歌内部,然后2010年开源出来。虽然业界反响并不大,但是因为它的轻量级,有些流行的开源框架(如Druid、Apollo、Elastic Search、Play2
)把它作为基础的DI组件。
轻量级是什么意思?
轻量级是一个相对概念,它至少应该有如下特征:
- 代码少
- 易维护
- 性能优异
Google Guice
就是这么一个框架,它特别强调它的Lightweight
特性。
Google Guice
Google Guice
作为一个纯粹的DI框架,主要用于减轻你对工厂的需求以及Java代码中对new的使用。通过它来构建你的代码,能减少依赖,从而使得更容易更改以及更容易单元测试和重用。
下面我们就研究它的特性,然后辅以一定的代码示例对它展开基础学习。
公用基础代码
导包:
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>com.google.inject.extensions</groupId>
<artifactId>guice-multibindings</artifactId>
<version>4.1.0</version>
</dependency>
基础代码:
public interface Animal {
void run();
}
public class Dog implements Animal {
@Override
public void run() {
System.out.println("dog run...");
}
}
public class Cat implements Animal {
@Override
public void run() {
System.out.println("run run...");
}
}
DI配置类(模块):
public class MainModule extends AbstractModule {
@Override
protected void configure() {
bind(Animal.class).to(Dog.class);
}
}
测试类:
public class TestGuice {
@Inject
private Animal animal;
//// 官方推荐使用构造器注入,但本类是测试类,为了方便就使用属性注入喽
//// 当然喽,test类必须有空构造器~~~~这就另说了
//@Inject
//public TestGuice(Animal animal){
// this.animal = animal;
//}
@Test
public void fun1(){
Injector injector = Guice.createInjector(new MainModule());
// 为当前实例注入容器内的对象
injector.injectMembers(this);
System.out.println(animal);
System.out.println(injector.getInstance(Animal.class));
System.out.println(injector.getInstance(Animal.class));
animal.run();
}
}
运行程序,控制台打印:
com.yourbatman.eurekaclient.guice.Dog@6fb0d3ed
com.yourbatman.eurekaclient.guice.Dog@24b1d79b
com.yourbatman.eurekaclient.guice.Dog@68ceda24
dog run...
这便是一个最简单的使用Guice来实现依赖注入的示例,和Spring的ApplicationContext
还蛮像的有木有。针对此实例的输出,你应该也意识到此处一个非常非常不一样的不同:默认是多例的(每次get/注入的都是不同的实例)。
如何保证单例?
不同于Spring,它默认是多例的,因此需要我们做一些事情来保证单例。
1、使用@Singleton
注解
@Singleton
public class Dog implements Animal { ... }
说明:该注解只能标注在实现类上,不能标注在接口/抽象类上
2、绑定时指定单例
bind(Animal.class).to(Dog.class).in(Singleton.class);
3、绑定一个现存的实例
bind(Animal.class).toInstance(new Dog());
以上三种方式处理后,使用依赖注入或者用API injector.getInstance()
得到的均会是同一个实例对象,这就是单例了。
绑定
任何需要依赖注入的资源,只有先实现了绑定才能注入,本处开始介绍它的绑定方式。
- 类名绑定:把实现类绑定到接口(当然也可以实现类绑到实现类),具体实例交给框架去帮你创建
bind(Animal.class).to(Dog.class);
- 实例绑定:绑定一个现有实例
bind(Animal.class).toInstance(new Dog())
注意:采用这种绑定,依赖注入时永远是单例(也就是这个实例)
- 连接绑定:对于已经绑定了的关系,可以无限一直连接下去
bind(Animal.class).to(Dog.class);
bind(Dog.class).toInstance(new Dog(){
@Override
public void run() {
System.out.println("son dog");
super.run();
}
});
Provider
绑定:类似于Spring的@Bean注解,适合完成需要编程逻辑完成的实例
见基础代码,略。
- 泛型绑定:支持泛型类型的绑定。借助
TypeLiteral
来完成
bind(new TypeLiteral<List<Animal>>(){}).toInstance(Arrays.asList(new Dog(),new Cat()));
- 集合绑定:可在不同的Module内向同一个集合分别去绑定自己所要支持的内容,当然喽也可以在同一个Module内
Multibinder<Animal> multibinder = Multibinder.newSetBinder(binder(), Animal.class);
multibinder.addBinding().toInstance(new Dog());
multibinder.addBinding().toInstance(new Cat());
说明:依赖于扩展包
guice-multibindings
,需要导入这个jar才行
注入
常用的注入方式有多种。
- 简单的单一注入(接口的实现仅有一个类型)
如示例代码
Provider
注入(具有延迟效果)
@Inject
private Provider<Animal> animal;
对于Provider
方式,配置的方式也可这样来提供(类似于@Bean
):
// 方法上是可以有入参的。但入参请确保已经是容器内的对象
@Provides // 作用类似于@Bean
@Singleton // 若这里不使用该注解,那就是多例,每次都会执行此方法
private Animal getAnimal(){
return new Dog();
}
需要注意的是,若使用了@Provides方式配置了实例,那么向bind(Animal.class).toInstance(new Dog())
这句话就不能再要了,否则就是重复绑定,启动时会抛错:
A binding to com.yourbatman.eurekaclient.guice.Animal was already configured at com.yourbatman.eurekaclient.guice.MainModule.configure(MainModule.java:11).
at com.yourbatman.eurekaclient.guice.MainModule.getAnimal(MainModule.java:7)
...
- 命名注入:用于对同一接口多个实现类做区分注入
bind(Animal.class).annotatedWith(DogAnno.class).to(Dog.class);
bind(Animal.class).annotatedWith(CatAnno.class).to(Cat.class);
@Inject
@DogAnno
private Animal animal;
除了自定义注解,你还可以使用Guice自带的命令类:Names.named("dog")
(它返丝线了注解接口,所以返回值是个注解类型)。
Module之间的关系
创建一个Injector
可以使用多个任意多个Module
,因此需要明确它们的关系。
- 并列:默认顺序传递就是此关系
Guice.createInjector(new MainModule(), .......);
- 嵌套:大的Module可以嵌套任意多个子Module
public class ServerModule extends AbstractModule {
@Override
protected void configure() {
install(new MainModule());
}
}
- 覆盖:如果有冲突的话后者覆盖前者,没有的话就都生效
// 用后者覆盖前者
Module finalModule = Modules.override(new MainModule()).with(new ServerModule());
Guice和Spring Boot整合
作为主流的微服务开发框架Spring Boot
,可以说Guice
不可能撼动Spring的江湖地位,其实它也无意去撼动它,乖乖的专心做自己的DI就好。
那么如果一个开源的库是用Guice
构建的,而你想在Spring Boot环境下使用肿么办呢???那就是整合。他俩并发冲突,反而也可以一起协作,总的思想有点类似于Spring MVC
和Spring
的协作:MVC
负责请求控制,而Spring负载从当IoC容器,负责DI依赖注入。
当然喽,他俩的集成做不到那么的浑然天成, 思考的思路是:向Spring Boot
容器内注入的业务Bean请不要new,请不要new,请不要new,而是通过injector.getInstance(xxx)
从Guice里拿,这样便完成了整合。总之就是各自做各自的事,然后通过某个“接口”来完成融合即可,比如这里用Spring Boot总控(其实就是MVC),然后Guice负责管理业务对象之间的依赖关系(如Service、Dao等)。
另外,在web下使用/整合Guice
,一般需要导入下面Jar包给与支持:
<dependency>
<groupId>com.google.inject.extensions</groupId>
<artifactId>guice-servlet</artifactId>
<version>4.1.0</version>
</dependency>
Tips:整合过程中,请一定一定一定要注意对象的生命周期以及Scope(Spring Boot一般要单例,而Guice需要做特殊的满足哦~~~)
Guice vs Spring
虽然这两者没有太大的可比性,但由于都是DI框架,所以做一个简单的比较吧。
- Spring不仅仅是DI,它是一个全家桶技术总和;Guice是个轻量级的DI框架,只聚焦于依赖的管理、注入
- Spring的配置文件(xml or Confiuration以及扫描的)体现了完整的装配结构;
Guice
使用Java代码来描述绑定关系 - Spring使用字符串来表示Bean的key;Guice一般使用类型绑定关系来描述一个实例,且是分模块的、局部的
- Spring在容器初始化时候完成所有关系的绑定;Guice只记录绑定关系,然后在运行时有需要的时候帮你完成注入
优缺点
Spring 的优缺点此处不做说明,主要描述Guice
它的DI领域的优缺点。
- 优点
- 轻量级(代码量少)
- 性能优异
- 良好的泛型支持
- 因为都用Java语言绑定,所以是强类型的,不容易出错
- 易于重构Refactor(也得益于是Java代码的强类型)
- 缺点
- 学习成本颇高,学习曲线相对陡峭
Module
的众多绑定规则不太容易理解,导致出错了不易排查- 教程少,文档少,中文文档、案例就更少了
- 社区活跃度无法同Spring相提并论
- 无法解决循环依赖注入的问题
- 此问题官方认为不是问题,因为官方建议你通过别的方式避免循环依赖(说明:Spring是解决了循环依赖注入问题的)
- 编译器支持相对差些(比如它的Guice的AOP不能方便的跳转)
总之,Spring大而全,Guice小而美。企业级应用当然还是推荐使用Spring,而如果你是自己写写组件,不妨用Guice
去管理的依赖吧,它能让你的代码结构更加优美且显得不那么臃肿。
当然,理想归理想,说去真心话国内的Java技术毕竟还是阿里这种大厂主导,而非Google系,因此实际生产中若你要使用请三思而后行,毕竟你还有同伴~
总结
关于轻量级依赖注入框架Google Guice就先介绍到这了,相信通过本文的学习,你只需要花几分钟的时间就能了解到Guice
的几乎全貌了。
我个人意见,此门DI技术不用深究,但却有必要了解,因为文首说了有些流行的开源框架是基于它构建的,所以了解Guice
才能更好的阅读学习其源码。
声明
原创不易,码字不易,多谢你的点赞、收藏、关注。把本文分享到你的朋友圈是被允许的,但拒绝抄袭
。你也可【左边扫码/或加wx:fsx641385712】邀请你加入我的 Java高工、架构师 系列群大家庭学习和交流。
- [享学Jackson] 一、初识Jackson – 世界上最好的JSON库
- [享学Jackson] 二、jackson-core之流式API与JsonFactory、JsonGenerator、JsonParser
- [享学Jackson] 三、jackson-databind之ObjectMapper与数据绑定、树模型
- [享学Jackson] 四、控制Jackson行为的特征们之JsonFactory.Feature、JsonGenerator.Feature、JsonParser.Feature
- [享学Jackson] 五、控制Jackson行为的特征们之JsonWriteFeature、JsonReadFeature
- [享学Jackson] 六、控制Jackson行为的特征们之MapperFeature、SerializationFeature、DeserializationFeature
- [享学Jackson] 七、Jackson使用bit位运算来开启/禁用Feature的原理解析
- [享学Jackson] 八、jackson-databind数据绑定基础配置之BaseSettings、MapperConfig、MapperConfigBase
- [享学Jackson] 九、jackson-databind数据绑定序列化/反序列化配置之SerializationConfig、DeserializationConfig
- [享学Jackson] 十、jackson-databind序列化之ObjectMapper序列化原理、序列化器匹配原理
- [享学Jackson] 十一、jackson-databind之JsonSerializer序列化器全解析
- [享学Jackson] 十二、jackson-databind反序列化之ObjectMapper反序列化原理、JsonDeserializer反序列化器全解析
- [享学Jackson] 十三、jackson-annotation注解模块全解析及Jackson注解大全
- [享学Jackson] 十四、深入理解Jackson的Module模块化设计及原理分析
- [享学Jackson] 十五、第三方模块Module的深度实践:JavaTimeModule、JSR310Module、ParameterNamesModule、Jdk8Module
- [享学Jackson] 十六、Jackson在Spring MVC中的使用之Date、JSR310时间类型的处理
- [享学Jackson] 十七、spring-web整合Jackson源码解析之Jackson2ObjectMapperBuilder
- [享学Jackson] 十八、Spring容器深度整合Jackson的桥梁之SpringHandlerInstantiator
- [享学Jackson] 十九、Spring下使用ObjectMapper的正确姿势 — Jackson2ObjectMapperFactoryBean
- [享学Jackson] 二十、Spring MVC下的Jackson — MappingJackson2HttpMessageConverter
- [享学Jackson] 二十一、Spring Boot下的Jackson — JacksonAutoConfiguration自动配置
- [享学Jackson] 二十二、Jackson与Fastjson的恩怨情仇(完结篇)