Google Guice超轻量级依赖注入容器

  • 开发
  • 6

Google Guice是Goolge开源的一款超轻量级依赖注入容器，超轻量的特点主要体现在：可与其它依赖注入容器混合使用，例如和Spring/Spring Boot的IOC容器混合使用；不需要任何配置信息，只需要引入几个有限的依赖包即可以使用；使用简单，只需要掌握几个有限的注释就可以使用；相对更重的依赖注入容器，Google Guice运行速度更快，消耗更少的系统资源。
在这里插入图片描述
（图片来源于网络）

实际上大多数技术人员都在不知不觉地使用Google Guice，这是因为很多工具性的组件和中间件内部都通过Google Guice进行实例管理，诸如：Elasticsearch、Netty等。本文试图通过示例和知识点讲解结合的方式，向读者介绍Google Guice的最基本使用。

1、典型使用

我们先来看一个最简单的示例，这个实例包括了相当一部分在后文将要介绍的Google Guice知识点：

// 首先我们按照正常的编码流程，定义一个普通的接口和普通的实现类
public interface OrderService {
  public void doSomething();
}

// ============================
// 以下是OrderService的一个普通实现
public class OrderServiceImpl implements OrderService {
  @Override
  public void doSomething() {
    System.out.println(" ===== doSomething ===== ");
  }
}

// ============================
// 然后我们将OrderService接口和OrderServiceImpl实现类的绑定关系，注册到依赖注入容器中
// 这个过程是通过一个Module的概念进行设计的
public class PlayerModule implements Module {
  @Override
  public void configure(Binder binder) {
    // .....
    binder.bind(OrderService.class).to(OrderServiceImpl.class);
    // .....
  }
}

// ============================
// 最后就可以通过依赖注入管理器，来进行使用了
// 只是一个Google Guice最简单的使用
public static void main(String[] args) {
  // 加载各个配置模块，module是Google Guice的一个概念，里面实际上是容器的实例映射信息
  Injector injector = Guice.createInjector(new Module[] {new PlayerModule()});
  // 从依赖容器中取得实例
  OrderService orderService = injector.getInstance(OrderServiceImpl.class);
  // 开始调用具体的工作方法
  orderService.doSomething();
}
// ......

  • Injector：是Google Guice中的一个概念，是依赖注入容器（管理器），一个应用程序中可以根据实际情况创建一个或者多个依赖注入容器（管理器）。

  • Module：是Google Guice中的另一个概念，可以看作模块配置信息。其中设定了依赖注入容器中实例对象和接口、实例对象和创建器等在依赖注入容器中的绑定关系。以上代码中，我们基于一个Module创建了一个依赖注入容器（管理器）。

  • 除了Google Guice专有的几个概念外，对于OrderService接口和它的实现 OrderServiceImpl上，并不需要增加特别的方法、属性或者注解。

2、Google Guice中的单例

和大家经常使用的Spring IOC容器相比，Guice依赖注入容器最需要注意的是，容器中的实例默认情况下并不是单例模式，而是多例模式。如果要求注入容器中的实例是单例模式，就需要在对应的Module中进行设定，或者通过@Singleton注解进行设定。 以下代码是在Module中绑定注册时进行单例模式的设定：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // asEagerSingleton()方法，就是设置成单例模式
    binder.bind(Service.class).annotatedWith(Names.named("one")).to(OneService.class).asEagerSingleton();
    // ......
  }
}

以下是通过注解方式进行单例模式的设定，注意@Singleton注解一定要加在直接注册到Module中的具体类上，如果@Singleton注解写在OrderServiceImpl类上，但是在Module设定时却描述为一个Provider（后文会讲），那么@Singleton注解将不再起作用：

// 使用@Singleton注解，表示单例
@Singleton
public class OneService implements Service {
  //  类中的各种内容可以忽略
}

3、Google Guice中的创建器

在很多情况下，技术人员需要在依赖注入容器创建一个实例时，加入一些特定的逻辑。也就是说需要干预依赖注入容器创建实例的过程。这时技术人员就需要通过设定一个Provider来完成特定实例在创建时的干预过程，如下所示：

// 注意，如果使用Provider，那么加载在World上面的Singleton注释会失效
public class WorldProvider implements Provider<World> {
  @Override
  public World get() {
    // 这是创建World类实例对象的过程
    // 具体代码忽略
    World world = new World();
    // ......
    return world;
  }
}

以上Provider的代码很好理解，就是描述一个具体的对象实例应该怎么进行创建。在设定完成后，Module中的相关设定方式也要进行调整，如下所示：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
	// 将这个Provider注册到容器
    binder.bind(World.class).toProvider(new WorldProvider())
    // ......
  }
}

4、Google Guice中的默认实现和多个实现

有的情况下，应用程序中一个接口可能有多个实现，并且这些实现都需要注入到容器中进行管理。那么这些实现就需要指定一个默认实现，这样才能保证注入管理器（Injector）能够正常工作。Google Guice主要提供了两种注解方式来为接口指定默认的实现方式。分别是@ImplementedBy注解和@ProvidedBy注解，示例代码如下：

// 使用@ImplementedBy注解，说明这个接口的默认实现是OneService
@ImplementedBy(OneService.class)
public interface Service {
  public void doSomething();
  public void doOther();
}

// 或者，使用@Provided注解，说明这个接口默认的创建器是WorldProvider
@ProvidedBy(WorldProvider.class)
public interface OrderService {
  public void doSomething();
}

@ImplementedBy注解加载到Service接口上，说明这个接口的默认实现为OneService类；@ProvidedBy注解加载到Service接口上，说明这个接口的默认实例创建的工作，由WorldProvider负责完成。当一个接口拥有多个实现时，除了为这个接口指定默认实现外，还需要为注入容器的多个实现分别指定辨识名。这个辨识名可以使用Google Guice提供的@Names注解，也可以使用Google Guice提供的注解扩展@BindingAnnotation。以下是给出的示例：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 通过一个别名绑定接口和它的实现
    // 分别给Service接口的两个实现，设定了别名“one”和“two”
    // 别名设置为“one”的具体实现OneService，还设定了以单例模式工作
    binder.bind(Service.class).annotatedWith(Names.named("one")).to(OneService.class).asEagerSingleton();
    binder.bind(Service.class).annotatedWith(Names.named("two")).to(TwoService.class);
    // ......
  }
}

// ========= 那么从依赖注入容器中获取对象实例使用时，可以这样来编码
// 这只是一种获取方式，后文还会介绍另外一种
@Named("one")
Service service = injector.getInstance(Service.class);

以上代码为@Named注解的使用，包括Module中设定一个接口的多个实现时，如何为每个实现设置不同的名字，以及在获取实例时如何使用@Names注解获取特定的实现。还有一种方式是使用@BindingAnnotation注解创建多个新的注解，来标识不同的实现。具体示例如下：

// =========== 
// 首先我们定义两个注解One和Two
// 主要关注@BindingAnnotation注解，这个注解表明，One注解可以用来标识和区分具体的实现类
@BindingAnnotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.LOCAL_VARIABLE)
public @interface One {

}

// 主要关注@BindingAnnotation注解，这个注解表明，Two注解可以用来标识和区分具体的实现类
@BindingAnnotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.LOCAL_VARIABLE)
public @interface Two {

}

// =========== 
// 接着我们可以使用这两个注解，区分一个接口的两个不同实现
public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 通过两个注解区分Service接口的两个不同实现
    binder.bind(Service.class).annotatedWith(One.class).to(OneService.class);
    binder.bind(Service.class).annotatedWith(Two.class).to(TwoService.class);
    // ......
  }
}

// ===========
// 最后，从依赖注入容器中获取对象实例使用时，可以这样来编码
// 这只是一种获取方式，后文还会介绍另外一种
@One
Service service = injector.getInstance(Service.class);

以上代码通过@BindingAnnotation创建了两个新的注解，分别是@One和@Two，然后在Module注册该接口的不同实现时，为不同实现分别绑定不同的注解。最后在获取实例时，使用已经绑定的不同注解，就可以获取对应的实例了。Google Guice的依赖注入容器（管理器）也提供了方法，可以让开发者中取得已注册到容器中的，某一个接口的所有实现。示例如下：

// ......
List<Binding<Service>> serviceBindings = injector.findBindingsByType(TypeLiteral.get(Service.class));
// 通过findBindingsByType方法，开发人员可以获取Service接口中的一个或者多个实现
// ......

5、Google Guice 中的Module

在以上各小节中，为了向读者介绍相关知识点，实际上本文已经或多或少涉及了Google Guice中的Module使用方式。本节我们主要进行Module设定方式的总结。

5.1、绑定接口和类

Google Guice可以注册到依赖注入容器的类型可以很多，除了我们一般知道的接口以外，普通的类也可以注入到容器中。代码片如下所示：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 注册普通的类到容器
    binder.bind(World.class);
    // ......
  }
}

除此以外，Google Guice可以使用以下很多种方式绑定接口和它的实现：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 通过一个别名绑定接口和它的实现
    binder.bind(Service.class).annotatedWith(Names.named("one")).to(OneService.class);
    // 通过自定义注解绑定接口和它的实现
    binder.bind(Service.class).annotatedWith(One.class).to(OneService.class);
    // 直接绑定一个接口和它的实现
    binder.bind(Service.class).to(OneService.class);
    // ......
  }
}

5.2、绑定实例

除了绑定类以外，Google Guice还可以将一个已经完成实例化的对象，或者一个实例化过程注册到容器中，代码实例如下：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 可以直接注入一个实例对象到容器中
    OrderService orderService = new OrderServiceImpl();
    binder.bind(OrderService.class).toInstance(orderService);
    // 也可以是一个实例化过程
    binder.bind(OrderService.class).toInstance(new OrderService() {
      @Override
      public void doSomething() {
        // 这个实例创建的创建过程
        // ........
      }
    });
    // ......
  }
}

通过这种注册方式，开发人员也是可以干预某个实例对象的创建过程的。但就本文来说，还是推荐使用创建器的方式进行实例对象创建过程的干预。

5.3、绑定创建器

可以使用一下方式向依赖注入容器注册一个创建器，以便在某个特定实例对象创建时干预对象的创建过程：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    // 注意，这里还设定了实例对象以单例模式工作
    binder.bind(World.class).toProvider(new WorldProvider()).asEagerSingleton();
    // ......
  }
}

另外，Google Guice还提供了@Provides注解，来设定一个实例对象的创建方法。@Provides注解是放置在方法上的一个注解，并且这个方法必须属于某一个Module。示例代码如下所示：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// 这个方法可以进行其他类型的绑定
  }
  
  // ......
  
  // 这个方法必须放置在某个Module中
  // 直接设定了如果创建OrderService接口的实例
  @Provides
  public OrderService one() {
    return new OrderServiceImpl();
  }
}

5.4、甚至可以绑定常量

一个固定的字符串当然可以进行注入：

public class XXXXX implements Module {
  @Override
  public void configure(Binder binder) {
	// ......
    binder.bind(String.class).toInstance("这是一个固定的字符串");
    // ......
  }
}

5.5、通过@Inject注解使用已注入的实例

以上本文介绍的内容，都是向依赖注入容器进行各种形式注册的示例，那么怎么进行容器中对象实例的使用呢？Google Guice提供了两种使用容器中实例对象的方式，一种是上文出现过的依赖注入管理器（Injector）；另一个是使用@Inject注解。代码实例如下：

// ......
// 加载各个配置模块，module是Google Guice的一个概念，里面实际上是容器的实例映射信息
// 得到一个依赖注入容器的管理器
Injector injector = Guice.createInjector(new Module[] {new PlayerModule()});
// 然后从依赖诸如容器中取得实例
OrderService orderService = injector.getInstance(OrderServiceImpl.class);
// ......

以上这种使用依赖注入管理器的方式并不适合大多数编码场景，因为不可能在所有场景下都先获取一个依赖注入管理器，再获取实例对象。更多的场景中，我们使用的是@Inject注解。@Inject注解可以设定在某个属性上，也可以设定在某个构造函数上。如下所示：

public class XXXXXX {
  // 加载在属性上
  @Inject
  private OrderService orderService;
  // 如果一个接口有多个实现类，并使用自定义注解进行标识，则这里可以这样使用
  @One
  private Service service;
  // 如果一个接口有多个实现类，并使用别名进行标识，则这里可以这样使用
  @Named("one")
  private Service service;

  // @Inject还可以加载在构造函数上，这时Google Guice会自动进行入参的匹配（如果有入参的话）
  // 当然，如果无法明确参数中具体的实现，还可以使用自定义注解或者别名注解进行说明
  @Inject
  public XXXXXX(String value , Service service);
  
  // ......
}

之所以介绍Google Guice，是因为在一篇专栏中其中的一块实战示例会使用这个轻量级依赖注入框架。当然Google Guice也可以应用在很多组件或者小型应用工程中。

阅读全部

相关推荐

  3. 【Spring之手写一个依赖注入容器】

    2024-06-06 22:50:01       28 阅读

  6. .NET8 依赖注入

    2024-06-06 22:50:01       35 阅读

  7. C# DI依赖注入

    2024-06-06 22:50:01       37 阅读

  8. 【csharp】依赖注入

    2024-06-06 22:50:01       33 阅读

  9. SpringBoot整理-依赖注入

    2024-06-06 22:50:01       29 阅读

  10. WebSocketServer依赖注入问题

    2024-06-06 22:50:01       29 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-06-06 22:50:01       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-06-06 22:50:01       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-06-06 22:50:01       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-06-06 22:50:01       20 阅读

热门阅读

  1. 这几个大模型产品，你觉得哪个好

    2024-06-06 22:50:01       10 阅读

  2. 神经网络---网络模型的保存、加载

    2024-06-06 22:50:01       9 阅读

  5. 汽车线束搭铁与接地设计原则

    2024-06-06 22:50:01       8 阅读

  10. 双亲委派模型

    2024-06-06 22:50:01       8 阅读

  12. C++构造器设计模式

    2024-06-06 22:50:01       8 阅读

  13. 运维开发详解

    2024-06-06 22:50:01       7 阅读

  14. C++学习笔记

    2024-06-06 22:50:01       7 阅读

  20. 常微分方程 (ODE) 和 随机微分方程 (SDE)

    2024-06-06 22:50:01       12 阅读

  21. 【面试宝藏】Go并发编程面试题

    2024-06-06 22:50:01       6 阅读

  23. Linux学习—Linux环境下的网络设置

    2024-06-06 22:50:01       9 阅读

  24. GD32F4xx+RT-Thread，SPI驱动、文件系统挂载应该怎么写

    2024-06-06 22:50:01       10 阅读

  28. 【力扣】不同的子序列

    2024-06-06 22:50:01       7 阅读