Google Guice 快速入门-CSDN博客

Guice是Google开源的一个依赖注入类库，相比于Spring IoC来说更小更快。Elasticsearch大量使用了Guice，本文简单的介绍下Guice的基本概念和使用方式

基本使用

1. 引入依赖

如果使用gradle的话，添加下列依赖

compile group: 'com.google.inject.extensions', name: 'guice-multibindings', version: '4.2.0'
compile group: 'com.google.inject', name: 'guice', version: '4.2.0'
复制代码

当构建工具解决完项目的依赖之后，我们就可以开始使用Guice了

项目骨架

我们来假设一个简单的项目框架。首先我们需要一个业务接口，简单的包含一个方法用于执行业务逻辑。
它的实现也非常简单

// UserService接口
public interface UserService {
    void process();
}

// 实现类
public class UserServiceImpl implements UserService {
    @Override
    public void process() {
        System.out.println("我需要做一些业务逻辑");
    }
}
复制代码

然后我们需要一个日志接口，它和它的实现也非常简单

// 日志接口
public interface LogService {
    void log(String msg);
}

// 实现类
public class LogServiceImpl implements LogService {
    @Override
    public void log(String msg) {
        System.out.println("------LOG:" + msg);
    }
}
复制代码

最后是一个系统接口和相应的实现。
在实现中我们使用了业务接口和日志接口处理业务逻辑和打印日志信息。

public interface Application {
    void work();
}
 
public class MyApp implements Application {
    private UserService userService;
    private LogService logService;
 
    @Inject
    public MyApp(UserService userService, LogService logService) {
        this.userService = userService;
        this.logService = logService;
    }
 
    @Override
    public void work() {
        userService.process();
        logService.log("程序正常运行");
    }
}
复制代码

在 MyApp 类中定义了 UserService 和 LogService 两个变量，但是还没有给它们创建对象，而 word 方法中分别调用了 process 和 log 方法，它们的实际执行结果由最终注入的对象决定

简单的依赖注入

首先来配置依赖关系。我们继承AbstractModule类，并重写configure方法即可。在configure方法中，我们可以调用AbstractModule类提供的一些方法来配置依赖关系。

最常用的方式就是 bind(接口或父类).to(实现类或子类) 的方式来设置依赖关系。

public class MyAppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(LogService.class).to(LogServiceImpl.class);
        bind(UserService.class).to(UserServiceImpl.class);
        bind(Application.class).to(MyApp.class);
    }
}
复制代码

这样一来，当Guice遇到接口或父类需要注入具体实现的时候，就会使用这里配置的实现类或子类来注入。
如果希望在构造器中注入依赖的话，只需要添加 @Inject 注解即可

Guice配置完之后，我们需要调用 Guice.createInjector 方法传入配置类来创建一个注入器，然后使用注入器的 getInstance 方法获取目标类，Guice会按照配置帮我们注入所有依赖。

我们使用单元测试来看看效果

public class MyAppTest {
    private static Injector injector;
 
    @BeforeClass
    public static void init() {
        injector = Guice.createInjector(new MyAppModule());
    }
 
    @Test
    public void testMyApp() {
        Application myApp = injector.getInstance(Application.class);
        myApp.work();
    }
}
 
//程序结果
//我需要做一些业务逻辑
//------LOG:程序正常运行
复制代码

依赖绑定

下面这些例子都是Guice文档上的例子

链式绑定

我们在绑定依赖的时候不仅可以将父类和子类绑定，还可以将子类和更具体的子类绑定。

下面的例子中，当我们需要 TransactionLog 的时候，Guice最后会为我们注入 MySqlDatabaseTransactionLog 对象。

// 链式绑定：TransactionLog -> DatabaseTransactionLog -> MySqlDatabaseTransactionLog
public class BillingModule extends AbstractModule {
  @Override 
  protected void configure() {
    bind(TransactionLog.class).to(DatabaseTransactionLog.class);
    bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);
  }
}
复制代码

注解绑定

当我们需要将多个同一类型的对象注入不同对象的时候，就需要使用注解区分这些依赖了。
最简单的办法就是使用 @Named 注解进行区分

首先需要在要注入的地方添加 @Named 注解

public class RealBillingService implements BillingService {
 
  @Inject
  public RealBillingService(@Named("Checkout") CreditCardProcessor processor,
      TransactionLog transactionLog) {
    ...
  }
复制代码

然后在绑定中添加 annotatedWith 方法指定 @Named 中指定的名称。
由于编译器无法检查字符串，所以Guice官方建议我们保守地使用这种方式

bind(CreditCardProcessor.class)
        .annotatedWith(Names.named("Checkout"))
        .to(CheckoutCreditCardProcessor.class);
复制代码

如果希望使用类型安全的方式，可以自定义注解

@BindingAnnotation 
@Target({ FIELD, PARAMETER, METHOD }) 
@Retention(RUNTIME)
public @interface PayPal {
    
}
复制代码

然后在需要注入的类上应用

public class RealBillingService implements BillingService {
 
  @Inject
  public RealBillingService(@PayPal CreditCardProcessor processor,
      TransactionLog transactionLog) {
    ...
  }
复制代码

在配置类中，使用方法也和@Named类似

bind(CreditCardProcessor.class)
        .annotatedWith(PayPal.class)
        .to(PayPalCreditCardProcessor.class);
复制代码

实例绑定

有时候需要直接注入一个对象的实例，而不是从依赖关系中解析。
如果我们要注入基本类型的话只能这么做

bind(String.class)
        .annotatedWith(Names.named("JDBC URL"))
        .toInstance("jdbc:mysql://localhost/pizza");
        
bind(Integer.class)
        .annotatedWith(Names.named("login timeout seconds"))
        .toInstance(10);
复制代码

如果使用 toInstance 方法注入的实例比较复杂的话，可能会影响程序启动。这时候可以使用 @Provides 方法代替

@Provides方法

当一个对象很复杂，无法使用简单的构造器来生成的时候，我们可以使用 @Provides 方法，也就是在配置类中生成一个注解了 @Provides 的方法。

在该方法中我们可以编写任意代码来构造对象

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    ...
  }
 
  @Provides
  TransactionLog provideTransactionLog() {
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();
    transactionLog.setJdbcUrl("jdbc:mysql://localhost/pizza");
    transactionLog.setThreadPoolSize(30);
    return transactionLog;
  }
}
复制代码

@Provides 方法也可以应用 @Named 和自定义注解，还可以注入其他依赖，Guice会在调用方法之前注入需要的对象

  @Provides 
  @PayPal
  CreditCardProcessor providePayPalCreditCardProcessor(
        @Named("PayPal API key") String apiKey) {
    PayPalCreditCardProcessor processor = new PayPalCreditCardProcessor();
    processor.setApiKey(apiKey);
    return processor;
  }
复制代码

Provider绑定

如果项目中存在多个比较复杂的对象需要构建，使用 @Provide 方法会让配置类变得比较乱。我们可以使用Guice提供的 Provider接口 将复杂的代码放到单独的类中。办法很简单，实现 Provider<T> 接口的get方法即可。在 Provider 类中，我们可以使用 @Inject 任意注入对象

public class DatabaseTransactionLogProvider implements Provider<TransactionLog> {
  private final Connection connection;
 
  @Inject
  public DatabaseTransactionLogProvider(Connection connection) {
    this.connection = connection;
  }
 
  public TransactionLog get() {
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();
    transactionLog.setConnection(connection);
    return transactionLog;
  }
}
复制代码

在配置类中使用 toProvider 方法绑定到 Provider 上即可

  public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(TransactionLog.class)
        .toProvider(DatabaseTransactionLogProvider.class);
  }
复制代码

作用域

默认情况下Guice会在每次注入的时候创建一个新对象。如果希望创建一个单例依赖的话，可以在实现类上应用 @Singleton 注解

@Singleton
public class InMemoryTransactionLog implements TransactionLog {
  /* everything here should be threadsafe! */
}
复制代码

或者也可以在配置类中指定

bind(TransactionLog.class).to(InMemoryTransactionLog.class).in(Singleton.class);
复制代码

在@Provides方法中也可以指定单例

  @Provides 
  @Singleton
  TransactionLog provideTransactionLog() {
    ...
  }
复制代码

如果一个类型上存在多个冲突的作用域，Guice会使用 bind() 方法中指定的作用域。如果不想使用注解的作用域，可以在 bind() 方法中将对象绑定为 Scopes.NO_SCOPE

Guice和它的扩展提供了很多作用域，有单例Singleton，Session作用域SessionScoped，Request请求作用域RequestScoped等等。我们可以根据需要选择合适的作用域

Servlet集成

Guice也可以和Servlet项目集成，这样我们就可以不用编写冗长的 web.xml，以依赖注入的方式使用Servlet和相关组件

安装Guice Servlet扩展

要在Servlet项目中集成Guice，首先需要安装Guice Servlet扩展。如果使用Maven，添加下面的依赖。

compile group: 'com.google.inject.extensions', name: 'guice-servlet', version: '4.2.0'
复制代码

加依赖之后，在 web.xml 中添加下面的代码，让Guice过滤所有web请求

<filter>
    <filter-name>guiceFilter</filter-name>
    <filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
</filter>
 
<filter-mapping>
    <filter-name>guiceFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
复制代码

配置Injector

和普通的项目一样，Servlet项目同样需要配置Injector。一种比较好的办法就是在 ContextListener 中配置 Injector。Guice的Servlet集成提供了 GuiceServletContextListener，我们继承该类并在 getInjector 方法中配置 Injector 即可。

public class MyGuiceServletConfigListener extends GuiceServletContextListener {
 
  @Override
  protected Injector getInjector() {
    return Guice.createInjector(new ServletModule());
  }
}
复制代码

当然仅仅继承 GuiceServletContextListener 还是不够的。我们还需要在 web.xml 中添加几行代码

<listener>
    <listener-class>yitian.study.servlet.MyGuiceConfigListener</listener-class>
</listener>
复制代码

配置Servlet和过滤器

默认的ServletModule就会启用一些功能。如果需要自定义Servlet和Filter，就需要继承ServletModule并重写configureServlets()方法。配置Servlet和Filter的方法和配置普通依赖注入类似

public class MyServletConfig extends ServletModule {
    @Override
    protected void configureServlets() {
        serve("/*").with(MainServlet.class);
        filter("/*").through(CharEncodingFilter.class);
    }
}
复制代码

然后将ServletModule替换为我们自己的实现类

public class MyGuiceConfigListener extends GuiceServletContextListener {
 
    @Override
    protected Injector getInjector() {
        return Guice.createInjector(new MyServletConfig());
    }
}
复制代码

注入Servlet相关对象

除了配置Servlet之外，Guice还允许我们把Request、Response和Session对象注入到非Servlet对象中。下面是Guice的一个例子

@RequestScoped
class SomeNonServletPojo {
 
  @Inject
  SomeNonServletPojo(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
    ...
  }
}
复制代码

我们还可以使用Guice注入请求参数。下面这个类的作用是获取所有请求参数并转换为字符串形式。

@RequestScoped
public class Information {
    @Inject
    @RequestParameters
    Map<String, String[]> params;
 
    public String getAllParameters() {
        return params.entrySet()
                .stream()
                .map(entry -> entry.getKey() + " : " + Arrays.toString(entry.getValue()))
                .collect(Collectors.joining(", "));
    }
}
复制代码

之后，我们就可以将该对象注入到Servlet中使用，将结果返回给页面

@Singleton
public class MainServlet extends HttpServlet {
    @Inject
    private Injector injector;
 
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("name");
        req.setAttribute("name", name);
        Information info = injector.getInstance(Information.class);
        req.setAttribute("params", info.getAllParameters());
        req.getRequestDispatcher("index.jsp").forward(req, resp);
    }
 
    @Override
    public void init() throws ServletException {
        super.init();
    }
}
复制代码

Guice Servlet扩展还有其他功能，这里就不在列举了。详情请参看Guice文档