if (outboundEvent.getComment() != null) { for (final String comment : outboundEvent.getComment().split("\n")) { entityStream.write(COMMENT_LEAD); entityStream.write(comment.getBytes(charset)); entityStream.write(EOL); final MessageBodyWriter messageBodyWriter = workersProvider.get().getMessageBodyWriter(outboundEvent.getType(), outboundEvent.getGenericType(), annotations, eventMediaType); messageBodyWriter.writeTo(
@Override public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return workers.get().getMessageBodyReader(type, genericType, annotations, mediaType); }
private void ensureMediaType() { if (getMediaType() == null) { // Content-Type is not present choose a default type final GenericType<?> entityType = new GenericType(getEntityType()); final List<MediaType> mediaTypes = workers.getMessageBodyWriterMediaTypes( entityType.getRawType(), entityType.getType(), getEntityAnnotations()); setMediaType(getMediaType(mediaTypes)); } }
private boolean fillMediaTypes(final Set<MediaType> effectiveTypes, final ResourceMethod resourceMethod, final List<MediaType> methodTypes, final boolean inputTypes) { // Add method types to the resulting list iff there is more than just */* if (methodTypes.size() > 1 || !methodTypes.contains(MediaType.WILDCARD_TYPE)) { effectiveTypes.addAll(methodTypes); } boolean mediaTypesFromWorkers = effectiveTypes.isEmpty(); if (mediaTypesFromWorkers) { final Invocable invocableMethod = resourceMethod.getInvocable(); // If not predefined from method - get it from workers. if (inputTypes) { fillInputTypesFromWorkers(effectiveTypes, invocableMethod); } else { fillOutputTypesFromWorkers(effectiveTypes, invocableMethod.getRawResponseType()); } mediaTypesFromWorkers = !effectiveTypes.isEmpty(); // If still empty - get all available. if (!mediaTypesFromWorkers) { if (inputTypes) { effectiveTypes.addAll(workers.getMessageBodyReaderMediaTypesByType(Object.class)); } else { effectiveTypes.addAll(workers.getMessageBodyWriterMediaTypesByType(Object.class)); } mediaTypesFromWorkers = true; } } return mediaTypesFromWorkers; }
MessageBodyWriter writer = messageBodyWorkers.getMessageBodyWriter(entityClass, entityType, EMPTY_ANNOTATIONS, MediaType.APPLICATION_FORM_URLENCODED_TYPE); MessageBodyReader reader = messageBodyWorkers.getMessageBodyReader(MultivaluedMap.class, MultivaluedMap.class, EMPTY_ANNOTATIONS, MediaType.APPLICATION_FORM_URLENCODED_TYPE);
@Override public int read() throws IOException { if (byteArrayInputStream == null) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); OutputStream stream = null; try { try { stream = requestContext.getWorkers().writeTo( entity, entity.getClass(), null, null, response.getMediaType(), response.getMetadata(), requestContext.getPropertiesDelegate(), baos, Collections.<WriterInterceptor>emptyList()); } finally { if (stream != null) { stream.close(); } } } catch (IOException e) { // ignore } byteArrayInputStream = new ByteArrayInputStream(baos.toByteArray()); } return byteArrayInputStream.read(); } };
try { try { entityStream = writeWorkers.writeTo( getEntity(), entityType.getRawType(), entityType.getType(), getEntityAnnotations(), getMediaType(), if (entityStream != null) { try { entityStream.close(); } catch (final IOException e) { ExceptionUtils.conditionallyReThrow(e, !runtimeException, LOGGER,
entityType = new GenericType(((GenericEntity) requestEntity).getType()); } else { entity = requestEntity; entityType = new GenericType(requestEntity.getClass()); stream = workers.writeTo(entity, entity.getClass(), entityType.getType(), new Annotation[0], getMediaType(), if (stream != null) { try { stream.close(); } catch (final IOException e) {
@Override public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return workers.get().getMessageBodyWriter(type, genericType, annotations, mediaType); }
@Override public TokenResult readFrom(final Class<TokenResult> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException, WebApplicationException { final GenericType<Map<String, Object>> mapType = new GenericType<Map<String, Object>>() { }; final Map<String, Object> map = (Map<String, Object>) workers.get().readFrom(mapType.getRawType(), mapType.getType(), annotations, mediaType, httpHeaders, propertiesDelegateProvider.get(), entityStream, EMPTY_INTERCEPTORS, false); return new TokenResult(map); } }
types = workersProvider.get() .getMessageBodyWriterMediaTypes( responseContext.getEntityClass(), responseContext.getEntityType(), responseContext.getEntityAnnotations()); } else if (responseContext.getStatus() == 415) { types = workersProvider.get() .getMessageBodyReaderMediaTypes( responseContext.getEntityClass(), responseContext.getEntityType(),
private List<MediaType> getEffectiveInputTypes(final ResourceMethod resourceMethod) { if (!resourceMethod.getConsumedTypes().isEmpty()) { return resourceMethod.getConsumedTypes(); } List<MediaType> result = new LinkedList<>(); if (workers != null) { for (Parameter p : resourceMethod.getInvocable().getParameters()) { if (p.getSource() == Parameter.Source.ENTITY) { result.addAll(workers.getMessageBodyReaderMediaTypes( p.getRawType(), p.getType(), p.getDeclaredAnnotations())); } } } return result.isEmpty() ? StarTypeList : result; }
private List<MediaType> getEffectiveOutputTypes(final ResourceMethod resourceMethod) { if (!resourceMethod.getProducedTypes().isEmpty()) { return resourceMethod.getProducedTypes(); } List<MediaType> result = new LinkedList<>(); if (workers != null) { final Invocable invocable = resourceMethod.getInvocable(); result.addAll(workers.getMessageBodyWriterMediaTypes( invocable.getRawResponseType(), invocable.getResponseType(), invocable.getHandlingMethod().getAnnotations())); } return result.isEmpty() ? StarTypeList : result; }
private void fillInputTypesFromWorkers(final Set<MediaType> effectiveInputTypes, final Invocable invocableMethod) { for (Parameter p : invocableMethod.getParameters()) { if (p.getSource() == Parameter.Source.ENTITY) { effectiveInputTypes.addAll(workers.getMessageBodyReaderMediaTypesByType(p.getRawType())); // there's at most one entity parameter break; } } }
/** * Read event data as a given generic type. * * @param type generic type to be used for event data de-serialization. * @param mediaType {@link MediaType media type} to be used for event data de-serialization. * @return event data de-serialized as an instance of a given type. * @throws javax.ws.rs.ProcessingException when provided type can't be read. The thrown exception wraps the original cause. * @since 2.3 */ public <T> T readData(GenericType<T> type, MediaType mediaType) { final MediaType effectiveMediaType = mediaType == null ? this.mediaType : mediaType; final MessageBodyReader reader = messageBodyWorkers.getMessageBodyReader(type.getRawType(), type.getType(), annotations, mediaType); if (reader == null) { throw new MessageBodyProviderNotFoundException(LocalizationMessages.EVENT_DATA_READER_NOT_FOUND()); } return readAndCast(type, effectiveMediaType, reader); }
@Override public Object apply(ContainerRequest request) { final List<FormDataBodyPart> parts = getEntity(request).getFields(parameter.getSourceName()); MessageBodyReader reader = messageBodyWorkers.getMessageBodyReader( parameter.getRawType(), parameter.getType(), parameter.getAnnotations(), mediaType); if (part != null) { for (final FormDataBodyPart p : parts) { reader = messageBodyWorkers.getMessageBodyReader( String.class, String.class,
workers.getMessageBodyWriter(bean.getClass(), bean.getClass(), new Annotation[0], MediaType.APPLICATION_JSON_TYPE);
return (T) messageBodyWorkers.readFrom( getRawType(), getType(),
/** * Returns the entity after appropriate conversion to the requested type. This is useful only when the containing * {@link MultiPart} instance has been received, which causes the {@code providers} property to have been set. * * @param clazz desired class into which the entity should be converted. * @return entity after appropriate conversion to the requested type. * * @throws ProcessingException if an IO error arises during reading an entity. * @throws IllegalArgumentException if no {@link MessageBodyReader} can be found to perform the requested conversion. * @throws IllegalStateException if this method is called when the {@code providers} property has not been set or when the * entity instance is not the unconverted content of the body part entity. */ public <T> T getEntityAs(final Class<T> clazz) { if (entity == null || !(entity instanceof BodyPartEntity)) { throw new IllegalStateException(LocalizationMessages.ENTITY_HAS_WRONG_TYPE()); } if (clazz == BodyPartEntity.class) { return clazz.cast(entity); } final Annotation[] annotations = new Annotation[0]; final MessageBodyReader<T> reader = messageBodyWorkers.getMessageBodyReader(clazz, clazz, annotations, mediaType); if (reader == null) { throw new IllegalArgumentException(LocalizationMessages.NO_AVAILABLE_MBR(clazz, mediaType)); } try { return reader.readFrom(clazz, clazz, annotations, mediaType, headers, ((BodyPartEntity) entity).getInputStream()); } catch (final IOException ioe) { throw new ProcessingException(LocalizationMessages.ERROR_READING_ENTITY(String.class), ioe); } }