3分钟带你了解轻量级依赖注入框架Google Guice【享学Java】

  • 2020 年 3 月 26 日
  • 筆記

程序必须是为了给人看而写，给机器去执行只是附带任务。

前言

说起依赖注入（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组件。

轻量级是什么意思？

轻量级是一个相对概念，它至少应该有如下特征：

  1. 代码少
  2. 易维护
  3. 性能优异

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());

@ImplementedBy 与 @ProvidedBy

单独介绍这两个注解，它是Guice提供的标注在类上的注解，用于简化绑定，他俩可以标注在接口上。

  • @ImplementedB：注解用于简化绑定配置，通常用于指定默认的实现类型。最常用的场景在于编写 Dao 或者 Service 时，指定 Interface 的实现类。
  • @ProvidedBy：作用同上，只不过是通过Provider方式来提供
@ImplementedBy(Dog.class)  // @Singleton // 不能标记在接口上，只能标记在Dog实现类上  public interface Animal {      void run();  }    @Test  public void fun1() {  	// 注意：并不需要使用使用模块，注解就行哦~~      Injector injector = Guice.createInjector();      injector.injectMembers(this);        System.out.println(animal);      System.out.println(injector.getInstance(Animal.class));      System.out.println(injector.getInstance(Animal.class));      animal.run();  }

这样标注后效果完全同：

bind(Animal.class).to(Dog.class)

@ProvidedBy就不用演示了，它的效果同：

bind(Animal.class).toProvider(DogProvider.class)

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才能更好的阅读学习其源码。

声明

原创不易，码字不易，多谢你的点赞、收藏、关注。把本文分享到你的朋友圈是被允许的，但拒绝抄袭。

VirMach 便宜 VPS

QNews

QNews