Java 用于单元测试的Google guice模块配置

我正在尝试使用GoogleGuice进行依赖注入，但我似乎无法将所有内容连接在一起

在my web.xml中，我定义了guiceFilter和guiceListener，如下所示：

   <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>

<listener>
    <listener-class>backend.listener.GuiceConfigListener</listener-class>
</listener>

此时的ArtsModule只有一个绑定，如下所示：

@Override
protected void configure(){
    bind(ArtsDAO.class).to(ArtsDAOGae.class);
}

然后，我继续在服务类中进行ArtsDao的现场注入：

@Inject
private ArtsDAO artsDAO;

但是当我尝试构建我的项目（这是一个maven构建）时，我在artsDAO字段上得到了一个NPE，这很可能是因为单元测试没有在web环境中运行

有谁能给我建议如何配置guice投标，以便在单元测试期间获得它们吗

谢谢你，皮普

这不是一项琐碎的任务，但你肯定能实现你想要的

首先，我们来看看Tadedon项目 特别是

tadedon guice servlet mock

您需要一些类似于假容器的东西来进行测试。我的假容器还包含

apacheshiro

集成，因此您可以将其扔掉，它看起来像：

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
import com.xemantic.tadedon.guice.servlet.mock.FakeServletContainer;
import com.xemantic.tadedon.guice.servlet.mock.FakeServletContainerModule;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.subject.support.SubjectThreadState;
import org.apache.shiro.web.subject.WebSubject;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;

import javax.servlet.ServletException;
import java.io.IOException;
import java.util.Arrays;
public class FakeTestContainerInit {

    private final FakeServletContainer servletContainer;
    private final Injector internalInjector;
    private Subject internalSubject;

    public FakeTestContainerInit() {
        this(new Module[] {});
    }

    public FakeTestContainerInit(Module... modules) {
        super();

        modules = Arrays.copyOf(modules, modules.length + 1);
        modules[modules.length-1] = new FakeServletContainerModule();
        internalInjector = Guice.createInjector(modules);
        servletContainer = internalInjector.getInstance(FakeServletContainer.class);
    }

    public void start() throws ServletException, IOException {
        this.start(true);
    }

    public void start(boolean initializeSecurityContext) throws ServletException, IOException {

        getServletContainer().start();

        MockHttpServletRequest request = servletContainer.newRequest("GET","/");
        MockHttpServletResponse response = new MockHttpServletResponse();

        if(initializeSecurityContext) {
            SecurityManager scm = internalInjector.getInstance(SecurityManager.class);
            internalSubject = new WebSubject.Builder(scm, request, response).buildWebSubject();
            SubjectThreadState sts = new SubjectThreadState(internalSubject);
            sts.bind();
        } else { internalSubject = null; }

        getServletContainer().service(request, response);

    }

    public void stop() {
        servletContainer.stop();
    }

    public FakeServletContainer getServletContainer() {
        return servletContainer;
    }

    public <T> T getInstance(final Class<T> type) throws IOException, ServletException {
        return getServletContainer().getInstance(type);
    }

    public <T> T getInstance(final Key<T> key) throws IOException, ServletException {
        return getServletContainer().getInstance(key);
    }

    public Subject getSubject() {
        return internalSubject;
    }
}

import com.google.inject.Guice；
导入com.google.inject.Injector；
导入com.google.inject.Key；
导入com.google.inject.Module；
导入com.xemantic.tadedon.guice.servlet.mock.FakeServletContainer；
导入com.xemantic.tadedon.guice.servlet.mock.FakeServletContainerModule；
导入org.apache.shiro.mgt.SecurityManager；
导入org.apache.shiro.subject.subject；
导入org.apache.shiro.subject.support.SubjectThreadState；
导入org.apache.shiro.web.subject.WebSubject；
导入org.springframework.mock.web.MockHttpServletRequest；
导入org.springframework.mock.web.MockHttpServletResponse；
导入javax.servlet.ServletException；
导入java.io.IOException；
导入java.util.array；
公共类faketestcontainerint{
专用最终FakeServletContainer servletContainer；
私人最终注射器；
私人主体；
公共faketestcontainerint（）{
这个（新模块[]{}）；
}
公共FaketTestContainerInit（模块…模块）{
超级（）；
modules=Arrays.copyOf（modules，modules.length+1）；
modules[modules.length-1]=新的FakeServletContainerModule（）；
internalInjector=Guice.createInjector（模块）；
servletContainer=internalInjector.getInstance（FakeServletContainer.class）；
}
public void start（）引发ServletException，IOException{
这个。开始（true）；
}
public void start（boolean initializeSecurityContext）抛出ServletException、IOException{
getServletContainer（）.start（）；
MockHttpServletRequest-request=servletContainer.newRequest（“GET”、“/”；
MockHttpServletResponse=新的MockHttpServletResponse（）；
if（初始化安全上下文）{
SecurityManager scm=internalInjector.getInstance（SecurityManager.class）；
internalSubject=newWebSubject.Builder（scm、请求、响应）.buildWebSubject（）；
SubjectThreadState sts=新SubjectThreadState（internalSubject）；
sts.bind（）；
}else{internalSubject=null；}
getServletContainer（）.service（请求、响应）；
}
公共停车场（）{
servletContainer.stop（）；
}
公共FakeServletContainer getServletContainer（）{
返回servletContainer；
}
public T getInstance（最终类类型）抛出IOException、ServletException{
返回getServletContainer（）.getInstance（类型）；
}
public T getInstance（最终密钥）抛出IOException、ServletException{
返回getServletContainer（）.getInstance（键）；
}
公共主题getSubject（）{
回归主体；
}
}

依赖项：

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
    </dependency>
    <dependency>
        <groupId>org.sonatype.sisu</groupId>
        <artifactId>sisu-guice</artifactId>
    </dependency>
    <dependency>
        <groupId>com.xemantic.tadedon</groupId>
        <artifactId>tadedon-guice-servlet-mock</artifactId>
    </dependency>

org.springframework
弹簧试验
org.sonatype.sisu
斯苏圭斯
com.xemantic.tadedon
tadedon guice servlet模拟

而Apache Shiro则不需要：

    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-web</artifactId>
    </dependency>

org.apache.shiro
西罗岩芯
org.apache.shiro
西罗网

您只需创建

FakeTestContainerInit

并调用

start（）

和

stop（）

方法。此外，所有对象创建都必须通过测试内部的

FakeTestContainerInit.getInstance

方法完成

---

嗯，我用它来测试Vaadin应用程序，所以我不需要发送请求和检查响应。所以，您需要实现这个。可以通过

getServletContainer（）服务（请求、响应）完成。但我想你会明白的。希望它能对你有所帮助。
哇，非常感谢，伙计，shiro是一种奖励，因为这将在稍后阶段实施，所以再次感谢你
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-web</artifactId>
    </dependency>