下面列出了javax.ws.rs.ext.Provider#javax.ws.rs.ext.MessageBodyWriter 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void testSortEntityProviders() throws Exception {
ProviderFactory pf = ServerProviderFactory.getInstance();
pf.registerUserProvider(new TestStringProvider());
pf.registerUserProvider(new PrimitiveTextProvider<Object>());
List<ProviderInfo<MessageBodyReader<?>>> readers = pf.getMessageReaders();
assertTrue(indexOf(readers, TestStringProvider.class)
< indexOf(readers, PrimitiveTextProvider.class));
List<ProviderInfo<MessageBodyWriter<?>>> writers = pf.getMessageWriters();
assertTrue(indexOf(writers, TestStringProvider.class)
< indexOf(writers, PrimitiveTextProvider.class));
}
@SuppressWarnings("unchecked")
@Test
public void retrievesAcceptableWriterMediaTypes() throws Exception {
ObjectFactory<ProviderDescriptor> writerFactory = mock(ObjectFactory.class);
ProviderDescriptor providerDescriptor = mock(ProviderDescriptor.class);
when(providerDescriptor.produces()).thenReturn(newArrayList(new MediaType("text", "*"), new MediaType("text", "plain")));
when(providerDescriptor.getObjectClass()).thenReturn((Class)StringEntityProvider.class);
when(writerFactory.getObjectModel()).thenReturn(providerDescriptor);
MessageBodyWriter<String> writer = mock(MessageBodyWriter.class);
when(writer.isWriteable(eq(String.class), isNull(), any(), eq(WILDCARD_TYPE))).thenReturn(true);
when(writerFactory.getInstance(context)).thenReturn(writer);
providers.addMessageBodyWriter(writerFactory);
assertEquals(newArrayList(new MediaType("text", "plain"), new MediaType("text", "*")),
providers.getAcceptableWriterMediaTypes(String.class, null, null));
}
@Test
public void shouldRegisterAMultiTypedProviderClassWithPriorities() {
Map<Class<?>, Integer> priorities = new HashMap<>();
priorities.put(ClientRequestFilter.class, 500);
priorities.put(ClientResponseFilter.class, 501);
priorities.put(MessageBodyReader.class, 502);
priorities.put(MessageBodyWriter.class, 503);
priorities.put(ReaderInterceptor.class, 504);
priorities.put(WriterInterceptor.class, 505);
priorities.put(ResponseExceptionMapper.class, 506);
priorities.put(ParamConverterProvider.class, 507);
RestClientBuilder builder = RestClientBuilder.newBuilder().register(MultiTypedProvider.class, priorities);
Configuration configuration = builder.getConfiguration();
assertTrue(configuration.isRegistered(MultiTypedProvider.class), MultiTypedProvider.class + " should be registered");
Map<Class<?>, Integer> contracts = configuration.getContracts(MultiTypedProvider.class);
assertEquals(contracts.size(), priorities.size(),
"There should be "+priorities.size()+" provider types registered");
for(Map.Entry<Class<?>, Integer> priority : priorities.entrySet()) {
Integer contractPriority = contracts.get(priority.getKey());
assertEquals(contractPriority, priority.getValue(), "The priority for "+priority.getKey()+" should be "+priority.getValue());
}
}
@Override
public InputStream getContent() {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
final Object entity = clientRequestContext.getEntity();
if (entity == null) {
return null;
} else {
MessageBodyWriter messageBodyWriter = workers.getMessageBodyWriter(entity.getClass(), entity.getClass(),
new Annotation[]{}, clientRequestContext.getMediaType());
try {
// use the MBW to serialize entity into baos
messageBodyWriter.writeTo(entity,
entity.getClass(), entity.getClass(), new Annotation[] {},
clientRequestContext.getMediaType(), new MultivaluedHashMap<String, Object>(),
baos);
} catch (IOException e) {
throw new RuntimeException(
"Error while serializing entity.", e);
}
return new ByteArrayInputStream(baos.toByteArray());
}
}
private Answer<Void> writeEntity() {
return invocation -> {
MessageBodyWriter messageBodyWriter = (MessageBodyWriter)invocation.getArguments()[1];
Object entity = containerResponse.getEntity();
if (entity != null) {
messageBodyWriter.writeTo(entity,
entity.getClass(),
containerResponse.getEntityType(),
null,
containerResponse.getContentType(),
containerResponse.getHttpHeaders(),
entityStream);
}
return null;
};
}
@Test
@UseDataProvider("messageBodyWriterByTypeAndMediaType")
public void retrievesMessageBodyWriterByTypeAndMediaType(boolean singletonOrPerRequest,
Class<?> writeObjectType,
Type writeObjectGenericType,
MediaType mediaType,
Object expectedMessageBodyWriterClassOrInstance) throws Exception {
if (singletonOrPerRequest == SINGLETON) {
registerSingletonMessageBodyWriters();
} else {
registerPerRequestMessageBodyWriters();
}
MessageBodyWriter messageBodyWriter = providers.getMessageBodyWriter(writeObjectType, writeObjectGenericType, null, mediaType);
if (singletonOrPerRequest == SINGLETON) {
assertSame(expectedMessageBodyWriterClassOrInstance, messageBodyWriter);
} else {
if (expectedMessageBodyWriterClassOrInstance == null) {
assertNull(messageBodyWriter);
} else {
assertNotNull(messageBodyWriter);
assertEquals(expectedMessageBodyWriterClassOrInstance, messageBodyWriter.getClass());
}
}
}
@SuppressWarnings("unchecked")
private<T> void writePayloadTo(Class<T> cls, Type type, Annotation[] anns, MediaType mt,
MultivaluedMap<String, Object> headers, Object data, OutputStream os)
throws IOException, WebApplicationException {
MessageBodyWriter<T> writer = null;
if (message != null && factory != null) {
writer = factory.createMessageBodyWriter(cls, type, anns, mt, message);
}
if (writer == null) {
throw new InternalServerErrorException("No suitable message body writer for class: " + cls.getName());
}
writer.writeTo((T)data, cls, type, anns, mt, headers, os);
}
/**
* <p>writeViewable.</p>
*
* @param viewable a {@link org.glassfish.jersey.server.mvc.Viewable} object.
* @param mediaType a {@link javax.ws.rs.core.MediaType} object.
* @param httpHeaders a {@link javax.ws.rs.core.MultivaluedMap} object.
* @param entityStream a {@link java.io.OutputStream} object.
* @throws java.io.IOException if any.
*/
protected void writeViewable(Viewable viewable,
MediaType mediaType,
MultivaluedMap<String, Object> httpHeaders,
OutputStream entityStream) throws IOException {
MessageBodyWriter<Viewable> writer = workers.get().getMessageBodyWriter(Viewable.class, null,
new Annotation[]{}, null);
if (writer != null) {
writer.writeTo(viewable,
Viewable.class,
Viewable.class,
new Annotation[0],
mediaType,
httpHeaders,
entityStream);
}
}
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public void writeTo(Optional<?> entity,
Class<?> type,
Type genericType,
Annotation[] annotations,
MediaType mediaType,
MultivaluedMap<String, Object> httpHeaders,
OutputStream entityStream)
throws IOException {
if (!entity.isPresent()) {
throw new NotFoundException();
}
final Type innerGenericType = (genericType instanceof ParameterizedType) ?
((ParameterizedType) genericType).getActualTypeArguments()[0] : entity.get().getClass();
MessageBodyWriter writer = mbw.get().getMessageBodyWriter(entity.get().getClass(),
innerGenericType, annotations, mediaType);
writer.writeTo(entity.get(), entity.get().getClass(),
innerGenericType, annotations, mediaType, httpHeaders, entityStream);
}
public boolean configure(final FeatureContext context) {
final Configuration config = context.getConfiguration();
final String jsonFeature = CommonProperties.getValue(config.getProperties(), config.getRuntimeType(), InternalProperties.JSON_FEATURE, JSON_FEATURE,
String.class);
// Other JSON providers registered.
if (!JSON_FEATURE.equalsIgnoreCase(jsonFeature)) {
return false;
}
// Disable other JSON providers.
context.property(PropertiesHelper.getPropertyNameForRuntime(InternalProperties.JSON_FEATURE, config.getRuntimeType()), JSON_FEATURE);
// Register FastJson.
if (!config.isRegistered(FastJsonProvider.class)) {
context.register(FastJsonProvider.class, MessageBodyReader.class, MessageBodyWriter.class);
}
return true;
}
@SuppressWarnings("unchecked")
@Override
public <T> ParamConverter<T> getConverter(Class<T> rawType, Type genericType,
Annotation[] annotations) {
if (rawType == Book.class) {
MessageBodyReader<Book> mbr = providers.getMessageBodyReader(Book.class,
Book.class,
annotations,
MediaType.APPLICATION_XML_TYPE);
MessageBodyWriter<Book> mbw = providers.getMessageBodyWriter(Book.class,
Book.class,
annotations,
MediaType.APPLICATION_XML_TYPE);
return (ParamConverter<T>)new XmlParamConverter(mbr, mbw);
} else if (rawType == byte.class) {
return (ParamConverter<T>)new ByteConverter();
} else {
return null;
}
}
private MediaType checkFinalContentType(MediaType mt, List<WriterInterceptor> writers, boolean checkWriters) {
if (checkWriters) {
int mbwIndex = writers.size() == 1 ? 0 : writers.size() - 1;
MessageBodyWriter<Object> writer = ((WriterInterceptorMBW)writers.get(mbwIndex)).getMBW();
Produces pm = writer.getClass().getAnnotation(Produces.class);
if (pm != null) {
List<MediaType> sorted =
JAXRSUtils.sortMediaTypes(JAXRSUtils.getMediaTypes(pm.value()), JAXRSUtils.MEDIA_TYPE_QS_PARAM);
mt = JAXRSUtils.intersectMimeTypes(sorted, mt).get(0);
}
}
if (mt.isWildcardType() || mt.isWildcardSubtype()) {
if ("application".equals(mt.getType()) || mt.isWildcardType()) {
mt = MediaType.APPLICATION_OCTET_STREAM_TYPE;
} else {
throw ExceptionUtils.toNotAcceptableException(null, null);
}
}
return mt;
}
@Test
public void testWriteStringISO() throws Exception {
MessageBodyWriter<String> p = new PrimitiveTextProvider<>();
ByteArrayOutputStream os = new ByteArrayOutputStream();
MultivaluedMap<String, Object> headers = new MetadataMap<>();
String eWithAcute = "\u00E9";
String helloStringUTF16 = "Hello, my name is F" + eWithAcute + "lix Agn" + eWithAcute + "s";
p.writeTo(helloStringUTF16,
String.class, String.class, null, MediaType.valueOf("text/plain;charset=ISO-8859-1"),
headers, os);
byte[] iso88591bytes = helloStringUTF16.getBytes("ISO-8859-1");
String helloStringISO88591 = new String(iso88591bytes, "ISO-8859-1");
assertEquals(helloStringISO88591, os.toString("ISO-8859-1"));
}
@Override
public void writeTo(T t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
MultivaluedMap<String, Object> headers, OutputStream os)
throws IOException, WebApplicationException {
if (!supportSimpleTypesOnly && !InjectionUtils.isPrimitive(type)) {
@SuppressWarnings("unchecked")
MessageBodyWriter<T> next =
(MessageBodyWriter<T>)providers.getMessageBodyWriter(type, genericType, annotations, mediaType);
JAXRSUtils.getCurrentMessage().put(ProviderFactory.ACTIVE_JAXRS_PROVIDER_KEY, this);
try {
next.writeTo(t, type, genericType, annotations, mediaType, headers, os);
} finally {
JAXRSUtils.getCurrentMessage().put(ProviderFactory.ACTIVE_JAXRS_PROVIDER_KEY, null);
}
} else {
os.write(StringUtils.toBytesASCII("{\"" + type.getSimpleName().toLowerCase() + "\":"));
writeQuote(os, type);
primitiveHelper.writeTo(t, type, genericType, annotations, mediaType, headers, os);
writeQuote(os, type);
os.write(StringUtils.toBytesASCII("}"));
}
}
public int compare(ProviderInfo<MessageBodyWriter<?>> p1,
ProviderInfo<MessageBodyWriter<?>> p2) {
MessageBodyWriter<?> e1 = p1.getProvider();
MessageBodyWriter<?> e2 = p2.getProvider();
int result = compareClasses(e1, e2);
if (result != 0) {
return result;
}
List<MediaType> types1 =
JAXRSUtils.sortMediaTypes(JAXRSUtils.getProviderProduceTypes(e1), JAXRSUtils.MEDIA_TYPE_QS_PARAM);
List<MediaType> types2 =
JAXRSUtils.sortMediaTypes(JAXRSUtils.getProviderProduceTypes(e2), JAXRSUtils.MEDIA_TYPE_QS_PARAM);
result = JAXRSUtils.compareSortedMediaTypes(types1, types2, JAXRSUtils.MEDIA_TYPE_QS_PARAM);
if (result != 0) {
return result;
}
result = compareCustomStatus(p1, p2);
if (result != 0) {
return result;
}
return comparePriorityStatus(p1.getProvider().getClass(), p2.getProvider().getClass());
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testWriteTo() throws Exception {
MessageBodyWriter p = new BinaryDataProvider();
ByteArrayOutputStream os = new ByteArrayOutputStream();
p.writeTo(new byte[]{'h', 'i'}, null, null, null, null, null, os);
assertArrayEquals(new String("hi").getBytes(), os.toByteArray());
ByteArrayInputStream is = new ByteArrayInputStream("hi".getBytes());
os = new ByteArrayOutputStream();
p.writeTo(is, null, null, null, null, null, os);
assertArrayEquals(os.toByteArray(), new String("hi").getBytes());
Reader r = new StringReader("hi");
os = new ByteArrayOutputStream();
p.writeTo(r, null, null, null, MediaType.valueOf("text/xml"), null, os);
assertArrayEquals(os.toByteArray(), new String("hi").getBytes());
os = new ByteArrayOutputStream();
p.writeTo(new StreamingOutputImpl(), null, null, null,
MediaType.valueOf("text/xml"), null, os);
assertArrayEquals(os.toByteArray(), new String("hi").getBytes());
}
@Test
public void testRegisterMbrMbwProviderAsMbrOnly() {
ServerProviderFactory pf = ServerProviderFactory.getInstance();
JAXBElementProvider<Book> customProvider = new JAXBElementProvider<>();
pf.registerUserProvider((Feature) context -> {
context.register(customProvider, MessageBodyReader.class);
return true;
});
MessageBodyReader<Book> reader = pf.createMessageBodyReader(Book.class, null, null,
MediaType.TEXT_XML_TYPE, new MessageImpl());
assertSame(reader, customProvider);
MessageBodyWriter<Book> writer = pf.createMessageBodyWriter(Book.class, null, null,
MediaType.TEXT_XML_TYPE, new MessageImpl());
assertTrue(writer instanceof JAXBElementProvider);
assertNotSame(writer, customProvider);
}
@Override
public boolean configure(final FeatureContext context) {
try {
final Configuration config = context.getConfiguration();
final String jsonFeature = CommonProperties.getValue(
config.getProperties()
, config.getRuntimeType()
, InternalProperties.JSON_FEATURE, JSON_FEATURE,
String.class
);
// Other JSON providers registered.
if (!JSON_FEATURE.equalsIgnoreCase(jsonFeature)) {
return false;
}
// Disable other JSON providers.
context.property(
PropertiesHelper.getPropertyNameForRuntime(InternalProperties.JSON_FEATURE, config.getRuntimeType())
, JSON_FEATURE);
// Register FastJson.
if (!config.isRegistered(FastJsonProvider.class)) {
context.register(FastJsonProvider.class, MessageBodyReader.class, MessageBodyWriter.class);
}
} catch (NoSuchMethodError e) {
// skip
}
return true;
}
@Before
public void setUp() throws Exception {
providers = mock(ProviderBinder.class);
containerRequest = mock(ContainerRequest.class);
ApplicationContext applicationContext = mock(ApplicationContext.class);
when(applicationContext.getProviders()).thenReturn(providers);
when(applicationContext.getContainerRequest()).thenReturn(containerRequest);
when(applicationContext.getQueryParameters()).thenReturn(new MultivaluedHashMap<>());
ApplicationContext.setCurrent(applicationContext);
entityStream = new ByteArrayOutputStream();
containerResponseWriter = mock(ContainerResponseWriter.class);
containerResponse = new ContainerResponse(containerResponseWriter);
doAnswer(writeEntity()).when(containerResponseWriter).writeBody(same(containerResponse), any(MessageBodyWriter.class));
}
@Test
public void shouldRegisterAMultiTypedProviderClass() {
Class<?>[] providerTypes = {ClientRequestFilter.class, ClientResponseFilter.class,
MessageBodyReader.class, MessageBodyWriter.class, ReaderInterceptor.class, WriterInterceptor.class,
ResponseExceptionMapper.class, ParamConverterProvider.class};
RestClientBuilder builder = RestClientBuilder.newBuilder().register(MultiTypedProvider.class, providerTypes);
Configuration configuration = builder.getConfiguration();
assertTrue(configuration.isRegistered(MultiTypedProvider.class), MultiTypedProvider.class + " should be registered");
assertEquals(configuration.getContracts(MultiTypedProvider.class).size(), providerTypes.length,
"There should be "+providerTypes.length+" provider types registered");
}
@Test
public void neverCreatesNOT_ACCEPTABLEResponseForHEADRequestEvenWhenNotFoundAnyWriterForEntity() throws Exception {
when(containerRequest.getMethod()).thenReturn("HEAD");
when(containerRequest.getAcceptableMediaTypes()).thenReturn(newArrayList(WILDCARD_TYPE));
MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>();
Response response = mockResponse(200, headers, "foo");
containerResponse.setResponse(response);
containerResponse.writeResponse();
assertEquals(200, containerResponse.getStatus());
verify(containerResponseWriter).writeHeaders(containerResponse);
verify(containerResponseWriter, never()).writeBody(same(containerResponse), any(MessageBodyWriter.class));
}
@SuppressWarnings("unchecked")
protected InputStream serialize(Object obj, MediaType mediaType) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>();
if (obj == null) {
return new ByteArrayInputStream(new byte[0]);
}
return bodyWriters.stream()
.sorted((writer1, writer2) ->
Boolean.compare(
writer1.isWriteable(obj.getClass(), obj.getClass(), null, mediaType),
writer2.isWriteable(obj.getClass(), obj.getClass(), null, mediaType)))
.map(writer -> {
try {
MessageBodyWriter.class.cast(writer).writeTo(obj, obj.getClass(), obj.getClass(), null, mediaType, headers, baos);
return baos.toByteArray();
} catch (IOException e) {
return null;
}
})
.filter(Objects::nonNull)
.map(ByteArrayInputStream::new)
.findFirst()
.orElse(null);
}
@Override
public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
MessageBodyWriter<T> writer = doGetMessageBodyWriter(type, genericType, annotations, mediaType);
if (writer == null) {
writer = getDefaults().getMessageBodyWriter(type, genericType, annotations, mediaType);
}
return writer;
}
@Override
public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
if (genericType instanceof ParameterizedType) {
Class<?> rawType = raw(genericType);
final Type actualTypeArgument = actual(genericType);
final MessageBodyWriter<?> messageBodyWriter
= workers.get().getMessageBodyWriter(raw(actualTypeArgument), actualTypeArgument, annotations, mediaType);
return allowedTypes.contains(rawType) && messageBodyWriter != null;
}
return allowedTypes.contains(genericType);
}
private void verifyProvider(ProviderFactory pf, Class<?> type, Class<?> provider, String mediaType)
throws Exception {
if (pf == null) {
pf = ServerProviderFactory.getInstance();
}
MediaType mType = MediaType.valueOf(mediaType);
MessageBodyReader<?> reader = pf.createMessageBodyReader(type, type, null, mType, new MessageImpl());
assertSame("Unexpected provider found", provider, reader.getClass());
MessageBodyWriter<?> writer = pf.createMessageBodyWriter(type, type, null, mType, new MessageImpl());
assertTrue("Unexpected provider found", provider == writer.getClass());
}
@Test
public void testVerbatimOccurrenceXML() throws IOException{
MessageBodyWriter<VerbatimOccurrence> occurrenceDwcXMLBodyWriter = new OccurrenceVerbatimDwcXMLBodyWriter();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
VerbatimOccurrence occ = new VerbatimOccurrence();
occ.setVerbatimField(DwcTerm.verbatimLocality, "mad");
Term customTerm = TermFactory.instance().findTerm("MyTerm");
occ.setVerbatimField(customTerm, "MyTerm value");
occurrenceDwcXMLBodyWriter.writeTo(occ, null, null, null, null, null, baos);
String expectedContent = IOUtils.toString(new FileInputStream(FileUtils.getClasspathFile("dwc_xml/verbatim_occurrence.xml")));
assertEquals(CharMatcher.WHITESPACE.removeFrom(expectedContent), CharMatcher.WHITESPACE.removeFrom(baos.toString()));
}
@Override
public void writeTo(final T object, final Class<?> type, final Type genericType, final Annotation[] annotations,
final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders,
final OutputStream entityStream) throws IOException, WebApplicationException {
final MessageBodyWriter<T> writer = writers.get(mediaTypeWithoutParams(mediaType));
if (writer != null) {
writer.writeTo(object, type, genericType, annotations, mediaType, httpHeaders, entityStream);
} else {
throw new InternalServerErrorException("unsupported media type");
}
}
private void verifyProvider(ProviderFactory pf, Class<?> type, Class<?> provider, String mediaType)
throws Exception {
if (pf == null) {
pf = ServerProviderFactory.getInstance();
}
MediaType mType = MediaType.valueOf(mediaType);
MessageBodyReader<?> reader = pf.createMessageBodyReader(type, type, null, mType, new MessageImpl());
assertSame("Unexpected provider found", provider, reader.getClass());
MessageBodyWriter<?> writer = pf.createMessageBodyWriter(type, type, null, mType, new MessageImpl());
assertTrue("Unexpected provider found", provider == writer.getClass());
}
@Override
@SuppressWarnings({"unchecked"})
public void writeBody(GenericContainerResponse response, MessageBodyWriter entityWriter) throws IOException {
if (committed) {
return;
}
final ByteArrayOutputStream out = new ByteArrayOutputStream();
final Object entity = response.getEntity();
if (entity != null) {
entityWriter.writeTo(entity, entity.getClass(), response.getEntityType(), null, response.getContentType(),
response.getHttpHeaders(), out);
byte[] body = out.toByteArray();
output.setBody(new String(body));
}
}
@Test
public void createsNOT_ACCEPTABLEResponseWhenNotFoundAnyWriterForEntity() throws Exception {
when(containerRequest.getMethod()).thenReturn("GET");
when(containerRequest.getAcceptableMediaTypes()).thenReturn(newArrayList(WILDCARD_TYPE));
MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>();
Response response = mockResponse(200, headers, "foo");
containerResponse.setResponse(response);
containerResponse.writeResponse();
assertEquals(406, containerResponse.getStatus());
verify(containerResponseWriter).writeHeaders(containerResponse);
verify(containerResponseWriter).writeBody(same(containerResponse), any(MessageBodyWriter.class));
}