Java can'；t在运动衫测试中进行模拟

我正在从过滤器中的上下文获取

提供者

，以定义

对象映射器

 public class Filter implements ContainerRequestFilter, ContainerResponseFilter {

    @Context
    private Providers providers;
    @Context
    private HttpServletRequest request;

    private ObjectMapper getObjectMapper() {
        ContextResolver<ObjectMapper> contextResolver = providers.getContextResolver(ObjectMapper.class, MediaType.APPLICATION_JSON_TYPE);
        if (contextResolver == null) {
            return new ObjectMapper();
        }
        return contextResolver.getContext(null);
    }
}

---

为什么

HttpServletRequest

在筛选器中是模拟的，而

提供程序

不是模拟的？

不应该模拟提供程序。它由框架处理。要添加任何提供程序，只需向

ResourceConfig

注册即可。我不知道您在尝试这一点时是否在意做错了什么，但下面是一个完整的工作示例，其中

ContextResolver

发现得很好

如果您仍然无法理解，请提供一个完整的工作单类示例（没有任何mock或Spring内容），就像我所做的那样

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.ext.Providers;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Assert;
import org.junit.Test;

public class ContextResolverTest extends JerseyTest {

    @Provider
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    public static class OMContextResolver implements ContextResolver<ObjectMapper> {

        private final ObjectMapper mapper = new ObjectMapper();

        @Override
        public ObjectMapper getContext(Class<?> type) {
            return mapper;
        }
    }

    @Provider
    public static class Filter implements ContainerRequestFilter  {

        @Context
        private Providers providers;

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException { 
            ContextResolver<ObjectMapper> contextResolver 
                    = providers.getContextResolver(ObjectMapper.class, 
                            MediaType.APPLICATION_JSON_TYPE);
            if (contextResolver == null) {
                requestContext.abortWith(
                            Response.serverError().entity("no resolver").build());
            } else {
                ObjectMapper mapper = contextResolver.getContext(null);
                if (mapper == null) {
                    requestContext.abortWith(
                            Response.serverError().entity("no mapper").build());
                    return;
                }
                requestContext.abortWith(
                            Response.ok("resolver found").build());
            }
        }
    }

    @Path("test")
    public static class TestResource {
        @GET
        public String dummyGet() {
            return "Boo";
        }
    }

    @Override
    public Application configure() {
        ResourceConfig config = new ResourceConfig();
        config.register(TestResource.class);
        config.register(OMContextResolver.class);
        config.register(Filter.class);
        return config;
    }

    @Test
    public void contextResolverIsOk() {
        Response response = target("test").request().get();
        Assert.assertEquals(200, response.getStatus());
        Assert.assertEquals("resolver found", response.readEntity(String.class));
        response.close();
    }
}

import com.fasterxml.jackson.databind.ObjectMapper；
导入java.io.IOException；
导入javax.ws.rs.Consumes；
导入javax.ws.rs.GET；
导入javax.ws.rs.Path；
导入javax.ws.rs.products；
导入javax.ws.rs.container.ContainerRequestContext；
导入javax.ws.rs.container.ContainerRequestFilter；
导入javax.ws.rs.core.Application；
导入javax.ws.rs.core.Context；
导入javax.ws.rs.core.MediaType；
导入javax.ws.rs.core.Response；
导入javax.ws.rs.ext.ContextResolver；
导入javax.ws.rs.ext.Provider；
导入javax.ws.rs.ext.Providers；
导入org.glassfish.jersey.server.ResourceConfig；
导入org.glassfish.jersey.test.JerseyTest；
导入org.junit.Assert；
导入org.junit.Test；
公共类ContextResolverTest扩展了Jersey测试{
@提供者
@产生（MediaType.APPLICATION_JSON）
@使用（MediaType.APPLICATION_JSON）
公共静态类OMContextResolver实现ContextResolver{
私有最终ObjectMapper mapper=新ObjectMapper（）；
@凌驾
公共对象映射器getContext（类类型）{
返回映射器；
}
}
@提供者
公共静态类筛选器实现ContainerRequestFilter{
@上下文
私人供应商；
@凌驾
公共无效筛选器（ContainerRequestContext requestContext）引发IOException{
上下文解析器上下文解析器
=providers.getContextResolver（ObjectMapper.class，
MediaType.APPLICATION_JSON_类型）；
if（contextResolver==null）{
requestContext.abortWith(
Response.serverError（）.entity（“无解析器”）.build（）；
}否则{
ObjectMapper mapper=contextResolver.getContext（null）；
if（映射器==null）{
requestContext.abortWith(
Response.serverError（）.entity（“无映射器”）.build（）；
返回；
}
requestContext.abortWith(
Response.ok（“找到解析程序”）.build（）；
}
}
}
@路径（“测试”）
公共静态类TestResource{
@得到
公共字符串dummyGet（）{
返回“Boo”；
}
}
@凌驾
公共应用程序配置（）{
ResourceConfig=newresourceconfig（）；
config.register（TestResource.class）；
寄存器（OMContextResolver.class）；
配置寄存器（Filter.class）；
返回配置；
}
@试验
public void contextResolverIsOk（）{
响应=目标（“测试”）.request（）.get（）；
Assert.assertEquals（200，response.getStatus（））；
Assert.assertEquals（“找到解析程序”，response.readEntity（String.class））；
response.close（）；
}
}

我猜是因为它是由框架处理的。通常情况下，

HttpServletRequest

将由框架处理，但因为您不是，所以它使用您的mock，因为找不到正常的mock。您可以通过以下链接和设置servlet环境来测试这一理论（我没有这样做），以查看模拟请求是否仍在使用。至于您试图实现的目标，为什么不创建一个虚拟

ContextResolver

并注册它呢。这与试图模拟

提供程序

并返回

上下文解析器

几乎是一样的，我已经有了上下文解析器公共类JerseyObjectMapperProvider实现了上下文解析器{bla bla}。但没有在示例中添加。。。我已经在Resourcece onfig中注册了它，但它没有帮助你说的“没有帮助”是什么意思。你是说它没有被发现吗？providers.getContextResolver（ObjectMapper.class，MediaType.APPLICATION\u JSON\u TYPE）-返回null。谢谢，我真的相信，这个模板工作得很好。。。但在我的情况下（我是这样做的）——不是，（可能是因为Spring的东西），我将尝试删除这个Spring和Mock。但我认为这对我来说是不可能的。我会更新这个问题的状态，如果它有帮助，或者显示我的所有代码示例）它永远不会被知道）这应该在应用程序中，但现在不需要）

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.ext.Providers;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Assert;
import org.junit.Test;

public class ContextResolverTest extends JerseyTest {

    @Provider
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    public static class OMContextResolver implements ContextResolver<ObjectMapper> {

        private final ObjectMapper mapper = new ObjectMapper();

        @Override
        public ObjectMapper getContext(Class<?> type) {
            return mapper;
        }
    }

    @Provider
    public static class Filter implements ContainerRequestFilter  {

        @Context
        private Providers providers;

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException { 
            ContextResolver<ObjectMapper> contextResolver 
                    = providers.getContextResolver(ObjectMapper.class, 
                            MediaType.APPLICATION_JSON_TYPE);
            if (contextResolver == null) {
                requestContext.abortWith(
                            Response.serverError().entity("no resolver").build());
            } else {
                ObjectMapper mapper = contextResolver.getContext(null);
                if (mapper == null) {
                    requestContext.abortWith(
                            Response.serverError().entity("no mapper").build());
                    return;
                }
                requestContext.abortWith(
                            Response.ok("resolver found").build());
            }
        }
    }

    @Path("test")
    public static class TestResource {
        @GET
        public String dummyGet() {
            return "Boo";
        }
    }

    @Override
    public Application configure() {
        ResourceConfig config = new ResourceConfig();
        config.register(TestResource.class);
        config.register(OMContextResolver.class);
        config.register(Filter.class);
        return config;
    }

    @Test
    public void contextResolverIsOk() {
        Response response = target("test").request().get();
        Assert.assertEquals(200, response.getStatus());
        Assert.assertEquals("resolver found", response.readEntity(String.class));
        response.close();
    }
}