本教程主要详细讲解Guice依赖注入中的特性接口多实现，一般使用到guice的框架的插件机制都是基于该方式实现。

基础环境

技术 版本
Java 1.8+
Guice 4.2.3

初始化项目

  • 初始化项目
  1. mvn archetype:generate -DgroupId=com.edurt.sli.guice -DartifactId=guice-binder-multiple -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=1.0.0 -DinteractiveMode=false
  • 修改pom.xml增加Guice依赖
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <parent>
  7.         <artifactId>learn-integration-guice</artifactId>
  8.         <groupId>com.edurt.sli.guice</groupId>
  9.         <version>1.0.0</version>
  10.     </parent>
  12.     <modelVersion>4.0.0</modelVersion>
  14.     <artifactId>guice-binder-multiple</artifactId>
  15.     <name>Guice依赖注入(接口多实现)</name>
  17.     <properties>
  18.         <system.java.version>1.8</system.java.version>
  19.         <guice.version>4.2.3</guice.version>
  20.         <lombok.version>1.18.2</lombok.version>
  21.     </properties>
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>com.google.inject</groupId>
  26.             <artifactId>guice</artifactId>
  27.             <version>${guice.version}</version>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.projectlombok</groupId>
  31.             <artifactId>lombok</artifactId>
  32.             <version>${lombok.version}</version>
  33.         </dependency>
  34.     </dependencies>
  36.     <build>
  37.         <plugins>
  38.             <plugin>
  39.                 <groupId>org.apache.maven.plugins</groupId>
  40.                 <artifactId>maven-compiler-plugin</artifactId>
  41.                 <version>${plugin.maven.compiler.version}</version>
  42.                 <configuration>
  43.                     <source>${system.java.version}</source>
  44.                     <target>${system.java.version}</target>
  45.                 </configuration>
  46.             </plugin>
  47.         </plugins>
  48.     </build>
  50. </project>

guice: guice就是我们核心要使用的依赖

接口多实现注入

如果一个接口有多个实现，如果单单通过@Inject和Module都难以直接实现，但多实现是经常会出现的，Guice提供了其它注入方式来解决此问题。

  • 创建com.edurt.sli.guice.multiple文件夹，并在该文件夹下创建Service接口文件，用于添加我们需要测试的函数
  1. package com.edurt.sli.guice.multiple;
  3. public interface Service {
  5.     void print(String source);
  7. }
  • 创建Service接口的实现类JavaService和GuiceService，用于实现接口中的方法，代码如下
  1. package com.edurt.sli.guice.multiple;
  3. public class JavaService implements Service {
  5.     @Override
  6.     public void print(String source) {
  7.         System.out.println("Java Service " + source);
  8.     }
  10. }
  1. package com.edurt.sli.guice.multiple;
  3. public class GuiceService implements Service {
  5.     @Override
  6.     public void print(String source) {
  7.         System.out.println("Guice Service " + source);
  8.     }
  10. }
  • 创建Guice和Java注解类，用于提供guice框架标识
  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.BindingAnnotation;
  5. import java.lang.annotation.ElementType;
  6. import java.lang.annotation.Retention;
  7. import java.lang.annotation.RetentionPolicy;
  8. import java.lang.annotation.Target;
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target({ElementType.FIELD, ElementType.PARAMETER})
  12. @BindingAnnotation
  13. public @interface Guice {
  14. }
  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.BindingAnnotation;
  5. import java.lang.annotation.ElementType;
  6. import java.lang.annotation.Retention;
  7. import java.lang.annotation.RetentionPolicy;
  8. import java.lang.annotation.Target;
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target({ElementType.FIELD, ElementType.PARAMETER})
  12. @BindingAnnotation
  13. public @interface Java {
  14. }
  • 创建用于测试注入的应用类Application，代码如下
  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.Guice;
  4. import com.google.inject.Inject;
  6. public class Application {
  8.     @Inject
  9.     @Java
  10.     public Service java;
  12.     @Inject
  13.     @com.edurt.sli.guice.multiple.Guice
  14.     public Service guice;
  16.     public static void main(String[] args) {
  17.         Application application = Guice.createInjector(binder -> {
  18.             binder.bind(Service.class).annotatedWith(Java.class).to(JavaService.class);
  19.             binder.bind(Service.class).annotatedWith(com.edurt.sli.guice.multiple.Guice.class).to(GuiceService.class);
  20.         }).getInstance(Application.class);
  21.         application.guice.print("sss");
  22.         application.java.print("sss");
  23.     }
  25. }

我们运行程序输出

  1. Guice Service sss
  2. Java Service sss

我们注意看binder的配置中，我们将注解与实际的实现类绑定到了一起，这样就实现了绑定多接口实现的功能。

注意：在本次程序中我们使用的是lambda表达式进行的代码编程，需要jdk1.8及以上版本

静态代码注入

我们如果需要进行静态代码注入服务该怎么写呢？我们参照以前讲解的Guice依赖注入(构造函数注入)资源中，我们创建一个ApplicationStatic类进行static的注入，代码如下

  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.Inject;
  5. public class ApplicationStatic {
  7.     @Inject
  8.     @Java
  9.     public static Service java;
  11.     @Inject
  12.     @com.edurt.sli.guice.multiple.Guice
  13.     public static Service guice;
  15.     public static void main(String[] args) {
  16.         com.google.inject.Guice.createInjector(binder -> {
  17.             binder.bind(Service.class).annotatedWith(Java.class).to(JavaService.class);
  18.             binder.bind(Service.class).annotatedWith(com.edurt.sli.guice.multiple.Guice.class).to(GuiceService.class);
  19.             binder.requestStaticInjection(ApplicationStatic.class);
  20.         });
  21.         ApplicationStatic.guice.print("sss");
  22.         ApplicationStatic.java.print("sss");
  23.     }
  25. }

我们只需要在binder阶段将我们的主类注入到guice容器中，也就是我们看到的binder.requestStaticInjection(ApplicationStatic.class);代码，运行程序输出以下内容

  1. Guice Service sss
  2. Java Service sss

属性绑定多接口

先看一下多接口绑定的示例

  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.Guice;
  4. import com.google.inject.Inject;
  6. public class ApplicationMultipleProperty {
  8.     @Inject
  9.     public Service java;
  11.     @Inject
  12.     public Service guice;
  14.     public static void main(String[] args) {
  15.         ApplicationMultipleProperty application = Guice.createInjector(binder -> {
  16.             binder.bind(Service.class).annotatedWith(Java.class).to(JavaService.class);
  17.             binder.bind(Service.class).annotatedWith(com.edurt.sli.guice.multiple.Guice.class).to(GuiceService.class);
  18.         }).getInstance(ApplicationMultipleProperty.class);
  19.         application.guice.print("sss");
  20.         application.java.print("sss");
  21.     }
  23. }

运行以上代码，就会出现以下错误

  1. Exception in thread "main" com.google.inject.ConfigurationException: Guice configuration errors:
  3. 1) No implementation for com.edurt.sli.guice.multiple.Service was bound.
  4.   Did you mean?
  5.     * com.edurt.sli.guice.multiple.Service annotated with interface com.edurt.sli.guice.multiple.Java
  6.     * com.edurt.sli.guice.multiple.Service annotated with interface com.edurt.sli.guice.multiple.Guice
  7.   while locating com.edurt.sli.guice.multiple.Service
  8.     for field at com.edurt.sli.guice.multiple.Application.guice(Application.java:6)
  9.   while locating com.edurt.sli.guice.multiple.Application
  11. 2) No implementation for com.edurt.sli.guice.multiple.Service was bound.
  12.   Did you mean?
  13.     * com.edurt.sli.guice.multiple.Service annotated with interface com.edurt.sli.guice.multiple.Java
  14.     * com.edurt.sli.guice.multiple.Service annotated with interface com.edurt.sli.guice.multiple.Guice
  15.   while locating com.edurt.sli.guice.multiple.Service
  16.     for field at com.edurt.sli.guice.multiple.Application.java(Application.java:6)
  17.   while locating com.edurt.sli.guice.multiple.Application
  19. 2 errors
  20.     at com.google.inject.internal.InjectorImpl.getProvider(InjectorImpl.java:1120)
  21.     at com.google.inject.internal.InjectorImpl.getProvider(InjectorImpl.java:1078)
  22.     at com.google.inject.internal.InjectorImpl.getInstance(InjectorImpl.java:1131)
  23.     at com.edurt.sli.guice.multiple.Application.main(Application.java:18)

这是因为我们使用了属性绑定了多接口实现，导致guice无法识别具体是哪个实现类，不过guice是强大的这种问题也被考虑到了，只需要使用@Named模板生成注解即可解决，我们姜代码修改为以下内容

  1. package com.edurt.sli.guice.multiple;
  3. import com.google.inject.Guice;
  4. import com.google.inject.Inject;
  5. import com.google.inject.name.Named;
  6. import com.google.inject.name.Names;
  8. public class ApplicationMultipleProperty {
  10.     @Inject
  11.     @Named("Java")
  12.     public Service java;
  14.     @Inject
  15.     @Named("Guice")
  16.     public Service guice;
  18.     public static void main(String[] args) {
  19.         ApplicationMultipleProperty application = Guice.createInjector(binder -> {
  20.             binder.bind(Service.class).annotatedWith(Names.named("Java")).to(JavaService.class);
  21.             binder.bind(Service.class).annotatedWith(Names.named("Guice")).to(GuiceService.class);
  22.         }).getInstance(ApplicationMultipleProperty.class);
  23.         application.guice.print("sss");
  24.         application.java.print("sss");
  25.     }
  27. }

运行程序后，输出以下结果

  1. Guice Service sss
  2. Java Service sss

这个示例也很好理解，其实我们只是做了两步操作

  • 在绑定实现的时候使用annotatedWith(Names.named("Java"))进行对该服务实现做名称标志
  • 在需要使用服务实现的地方使用@Named("Java")进行服务的引用即可

打包文件部署

  • 打包数据
  1. mvn clean package -Dmaven.test.skip=true -X

运行打包后的文件即可

  1. java -jar target/guice-binder-multiple-1.0.0.jar

源码地址