Guice 依赖注入(Scope)

qianmoQ

本教程主要详细讲解Guice依赖注入中的一些高级选项，他们分别是Scope，Eagerly Loading Bindings，Stage，Optional Injection。我们将一一对他们进行讲解。

基础环境

—

技术	版本
Java	1.8+
Guice	4.2.3

初始化项目

—

初始化项目

mvn archetype:generate -DgroupId=com.edurt.sli.guice -DartifactId=guice-binder-scope -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=1.0.0 -DinteractiveMode=false

修改pom.xml增加Guice依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>spring-learn-integration</artifactId>
        <groupId>com.edurt.sli</groupId>
        <version>1.0.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>guice-binder-scope</artifactId>
    <name>Guice依赖注入(Scope)</name>

    <properties>
        <system.java.version>1.8</system.java.version>
        <guice.version>4.2.3</guice.version>
        <lombok.version>1.18.2</lombok.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.inject</groupId>
            <artifactId>guice</artifactId>
            <version>${guice.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${plugin.maven.compiler.version}</version>
                <configuration>
                    <source>${system.java.version}</source>
                    <target>${system.java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

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

Singleton

—

Guice支持我们在其他DI框架中逐渐习惯的Scope和Scope机制。Guice默认提供已定义依赖项的新实例。

创建Service接口，用于提供使用的测试使用到的方法，代码如下

package com.edurt.sli.guice.scope;

public interface Service
{
    void println(String source);
}

创建ScopeService类，用于构建对Service的实现

package com.edurt.sli.guice.scope;

import java.time.LocalDateTime;

public class ScopeService
        implements Service
{
    @Override
    public void println(String source)
    {
        System.out.println(String.format("%s on %s", source, LocalDateTime.now()));
    }
}

创建用于测试注入的应用类ScopeApplication，代码如下

package com.edurt.sli.guice.scope;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Scopes;

public class ScopeApplication
{
    public static void main(String[] args)
    {
        Injector injector = Guice.createInjector(binder -> binder.bind(Service.class).to(ScopeService.class).in(Scopes.SINGLETON));
        Service service = injector.getInstance(Service.class);
        service.println("Singleton Scope");
    }
}

我们运行程序输出

Scope on 2020-12-18T16:01:37.792656

通过代码binder.bind(Service.class).to(ScopeService.class).in(Scopes.SINGLETON)我们指定了ScopeService的Scope，他将会被标志为一个单例实例。当然我们也可以使用@Singleton标志该类的作用域，我们修改ScopeService类文件代码如下：

package com.edurt.sli.guice.scope;

import javax.inject.Singleton;

import java.time.LocalDateTime;

@Singleton
public class ScopeService
        implements Service
{
    @Override
    public void println(String source)
    {
        System.out.println(String.format("%s on %s", source, LocalDateTime.now()));
    }
}

将ScopeApplication中的binder.bind(Service.class).to(ScopeService.class).in(Scopes.SINGLETON)代码修改为binder.bind(Service.class).to(ScopeService.class)

两种方式实现的效果都是一致的。此时ScopeService会被构建为单例实例。

当然还有一个asEagerSingleton()方法也可以用来标记单例模式。

他们的对比图如下：

使用方式	PRODUCTION	DEVELOPMENT
.asEagerSingleton()	eager	eager
.in(Singleton.class)	eager	lazy
.in(Scopes.SINGLETON)	eager	lazy
@Singleton	eager*	lazy

自定义Scope

—

Guice还支持我们用户自定义作用域，通常情况下我们不需要自己实现Scope，一般内置的作用域对于大多数的应用已经足够了。如果您正在编写一个web应用程序，那么ServletModule为HTTP请求和HTTP会话提供了简单的、良好作用域实现是一个很好的想法。

自定义Scope注解

Scope注解用于标记当前Scope在容器中使用的作用域。将使用它来注释guice构造的类型，@Provides方法和bind语法中的in()。Scope注解代码如下:

package com.edurt.sli.guice.seso;

import com.google.inject.ScopeAnnotation;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({TYPE, METHOD})
@Retention(RUNTIME)
@ScopeAnnotation
public @interface CustomScope
{
}

在使用自定义Scope时，请确保导入了正确的Scope注解。否则，您可能会得到一个SCOPE_NOT_FOUND错误。

实现Scope接口

Scope接口确保每个Scope实例拥有一到多个类型实例。实现的Scope接口代码如下：

package com.edurt.sli.guice.seso;

import com.google.inject.Key;
import com.google.inject.Provider;
import com.google.inject.Scope;

public class CustomScopeImpl
        implements Scope
{
    ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    @Override
    public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped)
    {
        return () -> {
            T instance = (T) threadLocal.get();
            if (instance == null) {
                instance = unscoped.get();
                threadLocal.set(instance);
            }
            return instance;
        };
    }
}

我们在上述代码中实现了一个简单线程抽取Scope，我们只是为了做测试使用，具体的Scope还需要根据业务自己使用。当我们传递的线程中没有构造一个对象时，先构造一个，然后放入线程上下文中，以后每次都从线程中获取对象。

使用创建CustomScopeApplication用来使用自定义的Scope代码如下：

package com.edurt.sli.guice.seso;

import com.google.inject.Guice;
import com.google.inject.Injector;

public class CustomScopeApplication
{
    public static void main(String[] args)
    {
        Injector injector = Guice.createInjector(binder -> {
            binder.bind(Service.class).to(ScopeService.class).in(new CustomScopeImpl());
        });
        for (int i = 0; i < 3; i++) {
            System.out.println(injector.getInstance(Service.class).hashCode());
        }
    }
}

运行程序后我们得到以下结果：

1574598287
1574598287
1574598287

我们通过结果得到运行了3次后的实例hashCode是一致的，这就说明我们的自定义Scope已经起作用了。如果新的实例构建后那么hashCode将会被改变。

绑定自定义Scope注解，我们通过实现Module进行注入

package com.edurt.sli.guice.seso;

import com.google.inject.AbstractModule;

public class CustomScopeModule
        extends AbstractModule
{
    @Override
    protected void configure()
    {
        bindScope(CustomScope.class, new CustomScopeImpl());
    }
}

需要使用到改Module只需要在Guice.createInjector构建的时候添加该Module即可，代码如下：

Injector injector = Guice.createInjector(new CustomScopeModule(), binder -> {
            binder.bind(Service.class).to(ScopeService.class).in(new CustomScopeImpl());
        });

在ScopeService类上使用@CustomScope注解即可。

打包文件部署

—

打包数据

mvn clean package -Dmaven.test.skip=true -X

运行打包后的文件即可

java -jar target/guice-binder-scope-1.0.0.jar

源码地址

—

GitHub

小助手

标题: Guice 依赖注入(Scope): 引发了怎样的辩论？

最近，在一个知名的技术论坛上，关于 Guice 依赖注入(Scope) 的讨论引起了极大的争议。讨论中涉及到了众多热衷于软件开发的专业人士，他们就 Guice 的 Scope 功能各抒己见，各持己见。

其中一位名为张三的开发者认为，Guice 的 Scope 功能是一种非常有用的特性。他指出，通过定义依赖的作用域，我们可以控制对象的生命周期，并且在不同的上下文中引入不同的依赖对象。这样可以提高系统的灵活性和可维护性。他举例说，对于一个 Web 应用程序，可以将某些依赖对象设置为 “Request” 作用域，这样每个请求都能获得一个新的实例，避免了线程安全问题。

然而，与张三持不同观点的是一位名为李四的开发者。他认为 Guice 的 Scope 功能是多余的，并且容易导致代码复杂性的增加。他认为通过合理设计和使用单例模式，可以满足大部分情况下的对象生命周期管理需求。他提出了一个问题：在大多数情况下，为什么我们需要不同的作用域？是否应该倾向于简化代码并避免引入额外的复杂性？

这场讨论引来了其他开发者的参与。有些人支持张三的观点，认为 Guice 的 Scope 功能提供了更高级别的依赖注入管理，有助于解决复杂的业务需求。而另一些人则支持李四的观点，认为在简单的应用场景中，合理设计和使用单例模式已经足够。

在我的观点上，我认为 Guice 的 Scope 功能确实提供了一种便捷的方式来管理对象的生命周期，但是否使用取决于具体的应用场景。对于简单的应用程序，可以通过单例模式等简单的手段满足需求。但是，在复杂的系统中，特别是涉及到线程安全、并发等方面时，使用 Guice 的 Scope 功能可以提供更大的灵活性和可维护性。

总之，Guice 的 Scope 功能引发了不同的观点和意见。选择是否使用这一功能应该根据具体需求以及项目的规模和复杂度来决定。这场讨论也让我们更加深入地思考了依赖注入管理的最佳实践。