Java JaxRs客户端没有'；不执行MessageBodyReader

我在设置MessageBodyReader时遇到问题-我尝试根据一些教程进行设置，但从未调用过它的函数。我正在使用球衣2.27

这是我的MessageBodyReader实现：

@Provider
public class MyMsgBodyReader implements MessageBodyReader<Object> {

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return true;
    }

    @Override
    public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
        HashMap<String, String> hash = new HashMap<>();
        hash.put("replaced", "true");
        return hash;
    }

}

虽然receivedEntity应该是带有一个条目的hashmap，但它仍然是我从测试api收到的原始实体。我甚至尝试在MyMsgBodyReader方法内部设置断点，并确认它们甚至没有被调用一次

我还尝试用多种方式扫描它：

@ApplicationPath("v1")
public class App extends Application {

    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<>();
        classes.add(MyMsgBodyReader.class);
        classes.add(
        return classes;
    }

    @Override
    public Set<Object> getSingletons() {
        Set<Object> singletons = new HashSet<>();
        singletons.add(new MsgBodiReader());
        return singletons;
    }
}

@ApplicationPath（“v1”）
公共类应用程序扩展应用程序{
@凌驾
public Set>classes=new HashSet（）；
添加（MyMsgBodyReader.class）；
类。添加(
返回类；
}
@凌驾
公共集getSingleton（）{
Set singleton=newhashset（）；
添加（新的MsgBodiReader（））；
返回单身人士；
}
}

---

我不知道还有什么可以尝试。

您需要决定的第一件事是读取器将处理什么类型的数据。您可以使用

@Consumes

注释来执行此操作。您可以将其放在reader类的顶部。Jersey将根据响应的

内容类型选择正确的读取器与
@中的媒体类型匹配的将消耗
。如果有多个读卡器匹配，则下一步是测试
isReadable（）
方法。如果有多个读卡器通过此检查，则Jersey将检查优先级。您可以添加
@优先级（int）
读取器上的注释。或者您可以将优先级作为第二个参数传递给
寄存器（）
方法。优先级越高，优先级越高。如果您在
@Consumes
中使用的媒体类型已经有标准读取器，那么您可能希望使用
@priority
以便使用您的媒体类型

如果仍然没有调用读卡器，您应该检查响应的类型，并确保响应符合预期。您还可以设置标头（可以通过将媒体类型传递给
request（）
方法来隐式设置标头）

下面是一个例子，您的读者将被称为

@Provider
@Conumes("application/custom")
public class MyReader implements MessageBodyReader<String> {
}

Response res = client.target("test")
        .register(MyReader.class)
        .request("application/custom")
        .get();

这里有一个完整的测试使用

import java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.lang.annotation.annotation；
导入java.lang.reflect.Type；
导入java.nio.charset.StandardCharset；
导入javax.ws.rs.Consumes；
导入javax.ws.rs.GET；
导入javax.ws.rs.Path；
导入javax.ws.rs.products；
导入javax.ws.rs.WebApplicationException；
导入javax.ws.rs.core.MediaType；
导入javax.ws.rs.core.MultivaluedMap；
导入javax.ws.rs.core.Response；
导入javax.ws.rs.ext.MessageBodyReader；
导入org.glassfish.jersey.server.ResourceConfig；
导入org.glassfish.jersey.test.JerseyTest；
导入org.junit.Test；
导入静态org.assertj.core.api.Assertions.assertThat；
公共类CustomReaderTest扩展了JerseyTest{
私有静态最终字符串DATA=“uselessstaticata”；
私有静态最终字符串自定义\u媒体\u TYPE=“应用程序/无用”；
@使用（自定义\媒体\类型）
公共静态类UselessReader实现MessageBodyReader{
@凌驾
公共布尔值可读取（类aClass，类型Type，
注释[]注释，MediaType（MediaType）{
返回true；
}
@凌驾
从中读取公共字符串（类aClass、类型Type、注释[]注释、，
MediaType MediaType，多值映射多值映射，
InputStream（InputStream）引发IOException、WebApplicationException{
返回数据；
}
}
@路径（“测试”）
公共静态类TestResource{
@得到
@生产（自定义媒体类型）
公共输入流post（字符串数据）{
返回新的ByteArrayInputStream（“Test”.getBytes（StandardCharsets.UTF_8））；
}
}
@凌驾
公共资源配置（）{
返回新的ResourceConfig（）
.register（TestResource.class）；
}
@试验
公开无效测试（）{
响应res=目标（“测试”）
.register（UselessReader.class）
.请求（自定义\媒体\类型）
.get（）；
assertThat（res.readEntity（String.class））.isEqualTo（DATA）；
}
}
我建议您启用jersey跟踪，看看这是否显示了什么。唯一的另一件事是……您没有@Consumes注释……我也尝试使用@Consumes获得相同的结果，我将研究jersey跟踪，但我必须承认，我不明白的部分是：@路径或资源定义在哪里？这样的读者会很生气在将内容传递给资源之前……换句话说：请考虑在这里放置一个真的！我省略了它的清晰度，现在我编辑的代码也包含了这一点。
@Provider
@Conumes("application/custom")
public class MyReader implements MessageBodyReader<String> {
}

Response res = client.target("test")
        .register(MyReader.class)
        .request("application/custom")
        .get();

Map<String, String> data = res.readEntity(new GenericType<Map<String, String>>(){});

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.MessageBodyReader;

import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class CustomReaderTest extends JerseyTest {

    private static final String DATA = "UselessStaticData";
    private static final String CUSTOM_MEDIA_TYPE = "application/useless";

    @Consumes(CUSTOM_MEDIA_TYPE)
    public static class UselessReader implements MessageBodyReader<String> {

        @Override
        public boolean isReadable(Class<?> aClass, Type type,
                                  Annotation[] annotations, MediaType mediaType) {
            return true;
        }

        @Override
        public String readFrom(Class<String> aClass, Type type, Annotation[] annotations,
                               MediaType mediaType, MultivaluedMap<String,String> multivaluedMap,
                               InputStream inputStream) throws IOException, WebApplicationException {
            return DATA;
        }
    }


    @Path("test")
    public static class TestResource {

        @GET
        @Produces(CUSTOM_MEDIA_TYPE)
        public InputStream post(String data) {
            return new ByteArrayInputStream("Test".getBytes(StandardCharsets.UTF_8));
        }
    }

    @Override
    public ResourceConfig configure() {
        return new ResourceConfig()
                .register(TestResource.class);
    }

    @Test
    public void testIt() {
        Response res = target("test")
                .register(UselessReader.class)
                .request(CUSTOM_MEDIA_TYPE)
                .get();

        assertThat(res.readEntity(String.class)).isEqualTo(DATA);
    }
}