Guice 依赖注入(构造函数注入)

qianmoQ

本教程主要详细讲解Guice的构造函数注入.

基础环境

—

技术	版本
Java	1.8+
Guice	4.2.3

初始化项目

—

初始化项目

mvn archetype:generate -DgroupId=com.edurt.sli.guice -DartifactId=guice-binder-constructor -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>learn-integration-guice</artifactId>
        <groupId>com.edurt.sli.guice</groupId>
        <version>1.0.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>guice-binder-constructor</artifactId>
    <name>Guice依赖注入(构造函数注入)</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就是我们核心要使用的依赖

构造函数注入

—

在Guice中我们可以通过将需要的实体信息通过构造函数直接注入到我们需要的任意地方，我们通过列举一个例子来实际说明。

创建com.edurt.sli.guice.sample文件夹，并在该文件夹下创建Service接口文件，用于添加我们需要测试的函数

package com.edurt.sli.guice.sample;

import com.google.inject.ImplementedBy;

@ImplementedBy(ServiceImpl.class)
public interface Service {

    void print(String source);

}

创建Service接口的实现类ServiceImpl，用于实现接口中的方法，代码如下

package com.edurt.sli.guice.sample;

public class ServiceImpl implements Service {
    @Override
    public void print(String source) {
        System.out.println(String.format("Hello Guice, %s", source));
    }

}

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

package com.edurt.sli.guice.sample;

import com.google.inject.Guice;
import com.google.inject.Inject;

public class Application {

    private Service service;

    @Inject
    public Application(Service service) {
        this.service = service;
    }

    public Service getService() {
        return service;
    }

    public static void main(String[] args) {
        Application application = Guice.createInjector().getInstance(Application.class);
        application.service.print("Test");
    }

}

我们运行程序输出

Hello Guice, Test

这个示例很好理解，实际就是说我们将Service接口通过@Inject注入到了Application应用中。当然我们通过@ImplementedBy(ServiceImpl.class)实现了类似Service service = new ServiceImpl()的操作，不过每次会生成一个新的实例，如果需要单例模式的话，需要单独操作。

注意：在本次程序中我们并没有通过Module关联到Guice，方便我们快速测试应用等。
我们无法通过非Guice容器进行注入，以下就是一个错误的示例
static也是无法进行注入的

package com.edurt.sli.guice.sample;

import com.google.inject.Inject;

public class ApplicationCustom {
    
    @Inject
    private Service service;
    
    public Service getService() {
        return this.service;
    }

    public static void main(String[] args) {
        ApplicationCustom custom = new ApplicationCustom();
        custom.getService().print("Test");
    }
    
}

我们运行上述代码，会提示以下错误信息

Exception in thread "main" java.lang.NullPointerException
	at com.edurt.sli.guice.sample.ApplicationCustom.main(ApplicationCustom.java:16)

这也就说明我们无法在非Guice容器中进行实例注入

多参数注入

—

上述实例我们只是注入了一个参数，那我们尝试一下多参数注入。

我们先书写另一个需要注入的服务和实现，PrintService代码如下

package com.edurt.sli.guice.sample;

import com.google.inject.ImplementedBy;

@ImplementedBy(PrintServiceImpl.class)
public interface PrintService {

    void print();

}

实现类ImplementedBy代码如下

package com.edurt.sli.guice.sample;

public class PrintServiceImpl implements PrintService {

    @Override
    public void print() {
        System.out.println("print Service");
    }

}

该服务我们只提供固定的输出字符串信息print Service，接下来我们进行对多参数注入，ApplicationMultiple代码如下

package com.edurt.sli.guice.sample;

import com.google.inject.Guice;
import com.google.inject.Inject;
import lombok.Data;

@Data
public class ApplicationMultiple {

    private Service service;
    private PrintService printService;

    @Inject
    public ApplicationMultiple(Service service, PrintService printService) {
        this.service = service;
        this.printService = printService;
    }

    public static void main(String[] args) {
        ApplicationMultiple multiple = Guice.createInjector().getInstance(ApplicationMultiple.class);
        multiple.getPrintService().print();
        multiple.getService().print("Multiple");
    }

}

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

print Service
Hello Guice, Multiple

我们使用一个@Inject也能实现多个参数的实例注入，当然还支持Set方式注入，只需要在参数的set方法上增加@Inject注解即可实现，这里我们不多做叙述，可自行实验。

static静态参数注入

—

我们说过无法注入通过static属性直接进行注入使用，方法总是很多的，Guice提供了以下static注入方式

package com.edurt.sli.guice.sample;

import com.google.inject.Guice;
import com.google.inject.Inject;

public class ApplicationStatic {

    @Inject
    private static Service service;

    public static void main(String[] args) {
        Guice.createInjector(binder -> binder.requestStaticInjection(ApplicationStatic.class));
        ApplicationStatic.service.print("Static");
    }

}

在代码中我们没有向以上两个示例直接使用Guice获取实例，而是使用了binder.requestStaticInjection方式进行了注入，这个是和static属性息息相关的，当我们注入static属性的时候要告知Guice我们具体使用static属性的父类，这样Guice才可以帮我们注入进来。

细心的话会想到我们既然使用binder.requestStaticInjection方式注入static属性，那么非static属性是不是也可以通过类似的方式注入？

答案是可以的，非static的属性我们需要通过binder.requestInjection(Type);方式注入，实例如下：

package com.edurt.sli.guice.sample;

import com.google.inject.Guice;
import com.google.inject.Inject;

public class ApplicationBinder {

    @Inject
    private Service service;

    public static void main(String[] args) {
        ApplicationBinder applicationBinder = new ApplicationBinder();
        Guice.createInjector(binder -> binder.requestInjection(applicationBinder));
        applicationBinder.service.print("Test");
    }

}

当然我们还可以通过Guice.createInjector().injectMembers(new Object());方式注入。

注意我们需要创建一个主类的实例才可以注入，使用ApplicationBinder.class是无法注入的

打包文件部署

—

打包数据

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

运行打包后的文件即可

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

源码地址

—

GitHub

小助手

题目：Guice依赖注入：有争议还是值得感谢？

在最近一次关于Guice依赖注入的讨论中，参与者们对于这种依赖注入方式存在着不同的观点。有些人认为Guice的依赖注入对于实现松耦合和可测试性非常有帮助，而另一些人则对其产生了一些疑虑。

一方面，支持者们赞扬Guice依赖注入的灵活性和易用性。他们认为通过使用Guice，我们可以通过在构造函数中声明依赖项，使代码更加清晰和可维护。使用构造函数注入依赖还可以降低类之间的耦合度，提高代码的可测试性和可扩展性。此外，Guice还提供了强大的依赖解析功能，可以实现自动注入，减少了手动管理依赖的工作。

然而，一些人对Guice的依赖注入抱有疑虑。他们认为过度依赖注入可能会导致代码的复杂性增加，使得代码更难理解和维护。此外，依赖注入可能会引入不必要的运行时开销，特别是在大型应用程序中。有些人还担心Guice的运行时依赖解析可能会降低应用程序的性能。此外，对于一些简单的应用程序，使用Guice可能会显得过于复杂和冗余。

总结来说，Guice依赖注入引发了许多有趣而有争议的讨论。虽然有些人赞同它的灵活性和易用性，但其他人对其可行性和性能问题提出了质疑。为了确定是否应该使用Guice依赖注入，开发人员需要仔细权衡其优点和缺点，并根据项目的特定需求做出决策。作为开发者，我们应该持开放的态度，不排斥新技术，同时也应该注意避免过度复杂化和不必要的依赖注入。

这是一个有关Guice依赖注入的讨论，并没有一个明确的结论。不过，通过这样的讨论，我们可以更好地了解Guice依赖注入的优点和缺点，从而更加合理地应用它。