@Override //Object就是springmvc返回值 protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { // 从threadLocal中获取当前的Request对象 HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder .currentRequestAttributes()).getRequest(); String callbackParam = request.getParameter(callbackName); if (StringUtils.isEmpty(callbackParam)) { // 没有找到callback参数,直接返回json数据 super.writeInternal(object, outputMessage); } else { JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType()); try { //将对象转换为json串,然后用回调方法包括起来 String result = callbackParam + "(" + super.getObjectMapper().writeValueAsString(object) + ");"; IOUtils.write(result, outputMessage.getBody(), encoding.getJavaName()); } catch (JsonProcessingException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex); } } }
protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { Charset charset = this.getCharset(outputMessage.getHeaders()); OutputStreamWriter writer = new OutputStreamWriter(outputMessage.getBody(), charset); try { if(this.jsonPrefix != null) { writer.append(this.jsonPrefix); } this.gson.toJson(o, writer); writer.close(); } catch (JsonIOException var7) { throw new HttpMessageNotWritableException("Could not write JSON: " + var7.getMessage(), var7); } }
private void writeForm(MultiValueMap<String, String> form, MediaType contentType, HttpOutputMessage outputMessage) throws IOException { Charset charset; if (contentType != null) { outputMessage.getHeaders().setContentType(contentType); charset = contentType.getCharset() != null ? contentType.getCharset() : this.defaultCharset; } else { outputMessage.getHeaders().setContentType(MediaType.APPLICATION_FORM_URLENCODED); charset = this.defaultCharset; } StringBuilder builder = new StringBuilder(); buildByNames(form, charset, builder); final byte[] bytes = builder.toString().getBytes(charset.name()); outputMessage.getHeaders().setContentLength(bytes.length); if (outputMessage instanceof StreamingHttpOutputMessage) { StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage; streamingOutputMessage.setBody(outputStream -> StreamUtils.copy(bytes, outputStream)); } else { StreamUtils.copy(bytes, outputMessage.getBody()); } }
private void writeMultipart(final MultiValueMap<String, Object> parts, HttpOutputMessage outputMessage) throws IOException { final byte[] boundary = generateMultipartBoundary(); Map<String, String> parameters = Collections.singletonMap("boundary", new String(boundary, "US-ASCII")); MediaType contentType = new MediaType(mixed, parameters); HttpHeaders headers = outputMessage.getHeaders(); headers.setContentType(contentType); if (outputMessage instanceof StreamingHttpOutputMessage) { StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage; streamingOutputMessage.setBody(outputStream -> { writeParts(outputStream, parts, boundary); writeEnd(outputStream, boundary); }); } else { writeParts(outputMessage.getBody(), parts, boundary); writeEnd(outputMessage.getBody(), boundary); } }
@SuppressWarnings("unchecked") private void writePart(String name, HttpEntity<?> partEntity, OutputStream os) throws IOException { Object partBody = partEntity.getBody(); Class<?> partType = partBody.getClass(); HttpHeaders partHeaders = partEntity.getHeaders(); MediaType partContentType = partHeaders.getContentType(); for (HttpMessageConverter<?> messageConverter : this.partConverters) { if (messageConverter.canWrite(partType, partContentType)) { HttpOutputMessage multipartMessage = new MultipartMixedConverter.MultipartHttpOutputMessage(os); multipartMessage.getHeaders().setContentDispositionFormData(name, null); if (!partHeaders.isEmpty()) { multipartMessage.getHeaders().putAll(partHeaders); } ((HttpMessageConverter<Object>) messageConverter).write(partBody, partContentType, multipartMessage); return; } } throw new HttpMessageNotWritableException( "Could not write request: no suitable HttpMessageConverter found for request type [" + partType.getName() + "]"); }
@SuppressWarnings("unchecked") private void writePart(String name, HttpEntity<?> partEntity, OutputStream os) throws IOException { Object partBody = partEntity.getBody(); Class<?> partType = partBody.getClass(); HttpHeaders partHeaders = partEntity.getHeaders(); MediaType partContentType = partHeaders.getContentType(); for (HttpMessageConverter<?> messageConverter : partConverters) { if (messageConverter.canWrite(partType, partContentType)) { HttpOutputMessage multipartOutputMessage = new MultipartHttpOutputMessage(os); multipartOutputMessage.getHeaders().setContentDispositionFormData(name, getFilename(partBody)); if (!partHeaders.isEmpty()) { multipartOutputMessage.getHeaders().putAll(partHeaders); } ((HttpMessageConverter<Object>) messageConverter).write(partBody, partContentType, multipartOutputMessage); return; } } throw new HttpMessageNotWritableException( "Could not write request: no suitable HttpMessageConverter found for request type [" + partType.getName() + "]"); }
@Override protected void writeInternal(Resource resource, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { InputStream in = resource.getInputStream(); try { StreamUtils.copy(in, outputMessage.getBody()); } finally { try { in.close(); } catch (IOException ex) { } } outputMessage.getBody().flush(); }
@Override protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType()); JsonGenerator jsonGenerator = this.objectMapper.getJsonFactory().createJsonGenerator(outputMessage.getBody(), encoding); // A workaround for JsonGenerators not applying serialization features // https://github.com/FasterXML/jackson-databind/issues/12 if (this.objectMapper.getSerializationConfig().isEnabled(SerializationConfig.Feature.INDENT_OUTPUT)) { jsonGenerator.useDefaultPrettyPrinter(); } try { if (this.jsonPrefix != null) { jsonGenerator.writeRaw(this.jsonPrefix); } this.objectMapper.writeValue(jsonGenerator, object); } catch (JsonProcessingException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex); } }
public void handleHttpEntityResponse(HttpEntity<?> responseEntity, ServletWebRequest webRequest) throws Exception { if (responseEntity == null) { return; } HttpInputMessage inputMessage = createHttpInputMessage(webRequest); HttpOutputMessage outputMessage = createHttpOutputMessage(webRequest); if (responseEntity instanceof ResponseEntity && outputMessage instanceof ServerHttpResponse) { ((ServerHttpResponse) outputMessage).setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode()); } HttpHeaders entityHeaders = responseEntity.getHeaders(); if (!entityHeaders.isEmpty()) { outputMessage.getHeaders().putAll(entityHeaders); } Object body = responseEntity.getBody(); if (body != null) { writeWithMessageConverters(body, inputMessage, outputMessage); } else { outputMessage.getBody(); } }
@Override protected void writeInternal(Object o, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { Charset charset = getCharset(outputMessage.getHeaders()); try (OutputStreamWriter writer = new OutputStreamWriter(outputMessage.getBody(), charset)) { if (ignoreType) { gsonForWriter.toJson(o, writer); return; } if (type != null) { gsonForWriter.toJson(o, type, writer); return; } gsonForWriter.toJson(o, writer); } catch (JsonIOException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex); } }
/** * Calls the conversion chain actually used by * {@link org.springframework.web.client.RestTemplate}, filling the body of the request * template. * * @param value * @param requestHeaders * @param template * @throws EncodeException */ private void encodeRequest(Object value, HttpHeaders requestHeaders, RequestTemplate template) throws EncodeException { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); HttpOutputMessage dummyRequest = new HttpOutputMessageImpl(outputStream, requestHeaders); try { Class<?> requestType = value.getClass(); MediaType requestContentType = requestHeaders.getContentType(); for (HttpMessageConverter<?> messageConverter : converters) { if (messageConverter.canWrite(requestType, requestContentType)) { ((HttpMessageConverter<Object>) messageConverter).write( value, requestContentType, dummyRequest); break; } } } catch (IOException ex) { throw new EncodeException("Cannot encode request.", ex); } HttpHeaders headers = dummyRequest.getHeaders(); if (headers != null) { for (Entry<String, List<String>> entry : headers.entrySet()) { template.header(entry.getKey(), entry.getValue()); } } /* we should use a template output stream... this will cause issues if files are too big, since the whole request will be in memory. */ template.body(outputStream.toByteArray(), UTF_8); }
@Override protected void writeInternal(CSVHttpResponse response, HttpOutputMessage output) throws IOException { final Charset charset = getCharset(response); output.getHeaders().setContentType(createMediaType(charset)); output.getHeaders().set("Content-Disposition", "attachment; filename=\"" + response.getFilename() + "\""); try (final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(output.getBody(), charset); final CSVWriter writer = new CSVWriter(outputStreamWriter, ';')) { if (response.getHeaderRow() != null) { writer.writeNext(response.getHeaderRow()); } writer.writeAll(response.getRows()); writer.flush(); } }
private void handleHttpEntityResponse(HttpEntity<?> responseEntity, ServletWebRequest webRequest) throws Exception { if (responseEntity == null) { return; } HttpInputMessage inputMessage = createHttpInputMessage(webRequest); HttpOutputMessage outputMessage = createHttpOutputMessage(webRequest); if (responseEntity instanceof ResponseEntity && outputMessage instanceof ServerHttpResponse) { ((ServerHttpResponse) outputMessage).setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode()); } HttpHeaders entityHeaders = responseEntity.getHeaders(); if (!entityHeaders.isEmpty()) { outputMessage.getHeaders().putAll(entityHeaders); } Object body = responseEntity.getBody(); if (body != null) { writeWithMessageConverters(body, inputMessage, outputMessage); } else { // flush headers outputMessage.getBody(); } }
@Test public void handleReturnValueMediaTypeSuffix() throws Exception { String body = "Foo"; MediaType accepted = MediaType.APPLICATION_XHTML_XML; List<MediaType> supported = Collections.singletonList(MediaType.valueOf("application/*+xml")); servletRequest.addHeader("Accept", accepted); given(messageConverter.canWrite(String.class, null)).willReturn(true); given(messageConverter.getSupportedMediaTypes()).willReturn(supported); given(messageConverter.canWrite(String.class, accepted)).willReturn(true); processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest); assertTrue(mavContainer.isRequestHandled()); verify(messageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.class)); }
@Test public void handleReturnValue() throws Exception { String body = "Foo"; ResponseEntity<String> returnValue = new ResponseEntity<String>(body, HttpStatus.OK); MediaType accepted = MediaType.TEXT_PLAIN; servletRequest.addHeader("Accept", accepted.toString()); given(messageConverter.canWrite(String.class, null)).willReturn(true); given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN)); given(messageConverter.canWrite(String.class, accepted)).willReturn(true); processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest); assertTrue(mavContainer.isRequestHandled()); verify(messageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.class)); }
@SuppressWarnings("unchecked") @Test public void handleReturnValueWithResponseBodyAdvice() throws Exception { ResponseEntity<String> returnValue = new ResponseEntity<>(HttpStatus.OK); servletRequest.addHeader("Accept", "text/*"); servletRequest.setAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML)); ResponseBodyAdvice<String> advice = mock(ResponseBodyAdvice.class); given(advice.supports(any(), any())).willReturn(true); given(advice.beforeBodyWrite(any(), any(), any(), any(), any(), any())).willReturn("Foo"); HttpEntityMethodProcessor processor = new HttpEntityMethodProcessor( Collections.singletonList(messageConverter), null, Collections.singletonList(advice)); reset(messageConverter); given(messageConverter.canWrite(String.class, MediaType.TEXT_HTML)).willReturn(true); processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest); assertTrue(mavContainer.isRequestHandled()); verify(messageConverter).write(eq("Foo"), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.class)); }
@Test public void responseHeaderAndBody() throws Exception { HttpHeaders responseHeaders = new HttpHeaders(); responseHeaders.set("header", "headerValue"); ResponseEntity<String> returnValue = new ResponseEntity<String>("body", responseHeaders, HttpStatus.ACCEPTED); given(messageConverter.canWrite(String.class, null)).willReturn(true); given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN)); given(messageConverter.canWrite(String.class, MediaType.TEXT_PLAIN)).willReturn(true); processor.handleReturnValue(returnValue, returnTypeResponseEntity, mavContainer, webRequest); ArgumentCaptor<HttpOutputMessage> outputMessage = ArgumentCaptor.forClass(HttpOutputMessage.class); verify(messageConverter).write(eq("body"), eq(MediaType.TEXT_PLAIN), outputMessage.capture()); assertTrue(mavContainer.isRequestHandled()); assertEquals("headerValue", outputMessage.getValue().getHeaders().get("header").get(0)); }
private void writeMultipart(final MultiValueMap<String, Object> parts, HttpOutputMessage outputMessage) throws IOException { final byte[] boundary = generateMultipartBoundary(); Map<String, String> parameters = Collections.singletonMap("boundary", new String(boundary, "US-ASCII")); MediaType contentType = new MediaType(MediaType.MULTIPART_FORM_DATA, parameters); HttpHeaders headers = outputMessage.getHeaders(); headers.setContentType(contentType); if (outputMessage instanceof StreamingHttpOutputMessage) { StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage; streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() { @Override public void writeTo(OutputStream outputStream) throws IOException { writeParts(outputStream, parts, boundary); writeEnd(outputStream, boundary); } }); } else { writeParts(outputMessage.getBody(), parts, boundary); writeEnd(outputMessage.getBody(), boundary); } }
@SuppressWarnings("unchecked") private void writePart(String name, HttpEntity<?> partEntity, OutputStream os) throws IOException { Object partBody = partEntity.getBody(); Class<?> partType = partBody.getClass(); HttpHeaders partHeaders = partEntity.getHeaders(); MediaType partContentType = partHeaders.getContentType(); for (HttpMessageConverter<?> messageConverter : this.partConverters) { if (messageConverter.canWrite(partType, partContentType)) { HttpOutputMessage multipartMessage = new MultipartHttpOutputMessage(os); multipartMessage.getHeaders().setContentDispositionFormData(name, getFilename(partBody)); if (!partHeaders.isEmpty()) { multipartMessage.getHeaders().putAll(partHeaders); } ((HttpMessageConverter<Object>) messageConverter).write(partBody, partContentType, multipartMessage); return; } } throw new HttpMessageNotWritableException("Could not write request: no suitable HttpMessageConverter " + "found for request type [" + partType.getName() + "]"); }
@Override protected void writeInternal(Object o, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { Charset charset = getCharset(outputMessage.getHeaders()); OutputStreamWriter writer = new OutputStreamWriter(outputMessage.getBody(), charset); try { if (this.jsonPrefix != null) { writer.append(this.jsonPrefix); } if (type != null) { this.gson.toJson(o, type, writer); } else { this.gson.toJson(o, writer); } writer.close(); } catch (JsonIOException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex); } }
@Override protected void writeInternal(T wireFeed, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String wireFeedEncoding = wireFeed.getEncoding(); if (!StringUtils.hasLength(wireFeedEncoding)) { wireFeedEncoding = DEFAULT_CHARSET.name(); } MediaType contentType = outputMessage.getHeaders().getContentType(); if (contentType != null) { Charset wireFeedCharset = Charset.forName(wireFeedEncoding); contentType = new MediaType(contentType.getType(), contentType.getSubtype(), wireFeedCharset); outputMessage.getHeaders().setContentType(contentType); } WireFeedOutput feedOutput = new WireFeedOutput(); try { Writer writer = new OutputStreamWriter(outputMessage.getBody(), wireFeedEncoding); feedOutput.output(wireFeed, writer); } catch (FeedException ex) { throw new HttpMessageNotWritableException("Could not write WireFeed: " + ex.getMessage(), ex); } }
@Override public void write(final BufferedImage image, final MediaType contentType, final HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { if (outputMessage instanceof StreamingHttpOutputMessage) { StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage; streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() { @Override public void writeTo(OutputStream outputStream) throws IOException { writeInternal(image, contentType, outputMessage.getHeaders(), outputStream); } }); } else { writeInternal(image, contentType, outputMessage.getHeaders(), outputMessage.getBody()); } }
@Override public void write(Object body, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { outputMessage.getHeaders().setContentType(JSON_MEDIA_TYPE); // outputMessage.getHeaders().setAccessControlAllowOrigin("*");// FIXME 暂时的写法 if (corsConfig.isEnable()) { HttpServletRequest request = RequestUtil.getCurrentRequest(); String allowOrigin = corsConfig.getAccessControlAllowOrigin(request); if (StringUtils.isNotEmpty(allowOrigin)) { outputMessage.getHeaders().set("Access-Control-Allow-Origin", allowOrigin); outputMessage.getHeaders().set("Access-Control-Allow-Credentials", "true"); // outputMessage.getHeaders().set("Access-Control-Allow-Methods", "GET, POST"); // outputMessage.getHeaders().set("Access-Control-Allow-Headers", "x_requested_with,content-type"); } } // System.err.println("ok"); outputMessage.getBody().write(((String) body).getBytes()); }
@Override public void write(final GenericEntity entity, final MediaType contentType, final HttpOutputMessage outputMessage) throws IOException { final HierarchicalStreamWriter writer = new CompactWriter(new OutputStreamWriter(outputMessage.getBody())); writer.startNode("Entity"); writer.addAttribute("Type", entity.getType()); writer.startNode("Fields"); for (final Field field : entity.getFields()) { writer.startNode("Field"); writer.addAttribute("Name", field.getName()); if (field.getValues().size() == 0) { writer.startNode("Value"); writer.endNode(); } else { for (final String value : field.getValues()) { writer.startNode("Value"); writer.setValue(value); writer.endNode(); } } writer.endNode(); } writer.endNode(); writer.endNode(); }
private void decorateNextVersionHeader(OAAnnotationHistory oaAnnotationHistory, HttpOutputMessage outputMessage) { String collectionId = oaAnnotationHistory.getCollectionId(); String annotationId = oaAnnotationHistory.getAnnotationId(); int version = oaAnnotationHistory.getVersion(); ServiceResponse<OAAnnotationHistory> serviceResponse = oaAnnotationHistoryService.getNextAnnotationVersion(collectionId, annotationId, version); Status status = serviceResponse.getStatus(); if (status.equals(Status.OK)) { oaAnnotationHistory = serviceResponse.getObj(); String urlStr = iriBuilderService.buildOAAnnotationHistoryIri(collectionId, annotationId, oaAnnotationHistory.getVersion()); String dateStr = MEMENTO_DATE_FORMAT.format(oaAnnotationHistory.getCreatedDateTime()); outputMessage.getHeaders().add(HttpHeaders.LINK, String.format("<%s>; rel=\"next memento\"; datetime=\"%s\"", urlStr, dateStr)); } }
private void decoratePreviousVersionHeader(OAAnnotationHistory oaAnnotationHistory, HttpOutputMessage outputMessage) { String collectionId = oaAnnotationHistory.getCollectionId(); String annotationId = oaAnnotationHistory.getAnnotationId(); int version = oaAnnotationHistory.getVersion(); ServiceResponse<OAAnnotationHistory> serviceResponse = oaAnnotationHistoryService.getPreviousAnnotationVersion(collectionId, annotationId, version); Status status = serviceResponse.getStatus(); if (status.equals(Status.OK)) { oaAnnotationHistory = serviceResponse.getObj(); String urlStr = iriBuilderService.buildOAAnnotationHistoryIri(collectionId, annotationId, oaAnnotationHistory.getVersion()); String dateStr = MEMENTO_DATE_FORMAT.format(oaAnnotationHistory.getCreatedDateTime()); outputMessage.getHeaders().add(HttpHeaders.LINK, String.format("<%s>; rel=\"prev memento\"; datetime=\"%s\"", urlStr, dateStr)); } }
private void decoratePreviousVersionHeader(W3CAnnotationHistory w3cAnnotationHistory, HttpOutputMessage outputMessage) { String collectionId = w3cAnnotationHistory.getCollectionId(); String annotationId = w3cAnnotationHistory.getAnnotationId(); int version = w3cAnnotationHistory.getVersion(); ServiceResponse<W3CAnnotationHistory> serviceResponse = w3cAnnotationHistoryService.getPreviousAnnotationVersion(collectionId, annotationId, version); Status status = serviceResponse.getStatus(); if (status.equals(Status.OK)) { w3cAnnotationHistory = serviceResponse.getObj(); String urlStr = iriBuilderService.buildW3CAnnotationHistoryIri(collectionId, annotationId, w3cAnnotationHistory.getVersion()); String dateStr = MEMENTO_DATE_FORMAT.format(w3cAnnotationHistory.getCreatedDateTime()); outputMessage.getHeaders().add(HttpHeaders.LINK, String.format("<%s>; rel=\"prev memento\"; datetime=\"%s\"", urlStr, dateStr)); } }
@Override protected void writeInternal(CatalogMetadata metadata, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String result; try { result = MetadataUtils.getString(metadata, format); } catch (MetadataException e) { throw new HttpMessageNotWritableException("", e); } OutputStreamWriter writer = new OutputStreamWriter( outputMessage.getBody(), StandardCharsets.UTF_8); writer.write(result); writer.close(); }
@Override protected void writeInternal(DatasetMetadata metadata, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String result; try { result = MetadataUtils.getString(metadata, format); } catch (MetadataException e) { throw new HttpMessageNotWritableException("", e); } OutputStreamWriter writer = new OutputStreamWriter( outputMessage.getBody(), StandardCharsets.UTF_8); writer.write(result); writer.close(); }
@Override protected void writeInternal(DistributionMetadata metadata, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String result; try { result = MetadataUtils.getString(metadata, format); } catch (MetadataException e) { throw new HttpMessageNotWritableException("", e); } OutputStreamWriter writer = new OutputStreamWriter( outputMessage.getBody(), StandardCharsets.UTF_8); writer.write(result); writer.close(); }
@Override protected void writeInternal( RootNode rootNode, HttpOutputMessage outputMessage ) throws IOException, HttpMessageNotWritableException { List<String> callbacks = Lists.newArrayList( contextService.getParameterValues( DEFAULT_CALLBACK_PARAMETER ) ); String callbackParam; if ( callbacks.isEmpty() ) { callbackParam = DEFAULT_CALLBACK_PARAMETER; } else { callbackParam = callbacks.get( 0 ); } rootNode.getConfig().getProperties().put( Jackson2JsonNodeSerializer.JSONP_CALLBACK, callbackParam ); nodeService.serialize( rootNode, "application/json", outputMessage.getBody() ); }
@Override public void write(MultiValueMap<String, ?> map, MediaType contentType, HttpOutputMessage outputMessage) throws IOException { // only do special escaping if this is a non-multipart request if (!isMultipart(map, contentType)) { super.write(map, contentType, new TwitterEscapingHttpOutputMessage(outputMessage)); } else { super.write(map, contentType, outputMessage); } }
@Bean public HttpMessageConverter customJackson2HttpMessageConverter() { return new FastJsonHttpMessageConverter4() { @Override protected void writeInternal(Object obj, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { if (obj instanceof ResultModel) { super.writeInternal(obj, type, outputMessage); } else { super.writeInternal(ResultResolver.sendNormalResult(obj), type, outputMessage); } } }; }
public void write(UploadApplicationPayload t, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { setOutputContentType(contentType, outputMessage); FileCopyUtils.copy(t.getInputStream(), outputMessage.getBody()); outputMessage.getBody().flush(); writeApplicationZipToFile(t.getInputStream()); }
private void setOutputContentType(MediaType contentType, HttpOutputMessage outputMessage) { HttpHeaders headers = outputMessage.getHeaders(); if (contentType == null || contentType.isWildcardType() || contentType.isWildcardSubtype()) { contentType = MediaType.APPLICATION_OCTET_STREAM; } if (contentType != null) { headers.setContentType(contentType); } }
@Test public void shouldWrite() throws Exception { UploadApplicationPayload payload = mock(UploadApplicationPayload.class); given(payload.getInputStream()).willReturn(new ByteArrayInputStream(CONTENT)); HttpOutputMessage outputMessage = mock(HttpOutputMessage.class); HttpHeaders headers = mock(HttpHeaders.class); given(outputMessage.getHeaders()).willReturn(headers); ByteArrayOutputStream out = new ByteArrayOutputStream(); given(outputMessage.getBody()).willReturn(out); converter.write(payload, null, outputMessage); verify(headers).setContentType(MediaType.APPLICATION_OCTET_STREAM); assertThat(out.toByteArray(), is(equalTo(CONTENT))); }
@Override protected void writeInternal(Object obj, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { /** * FastJson 1.1.42之前的版本反序列化对象时父对象属性无法被设值 * 但是之后的版本Enum序列化使用的是toString方法 * 临时解决方法强制使用Enum.name()方法序列化 */ List<String> classFilters = new ArrayList<String>(); ClassPathScanHandler handler = new ClassPathScanHandler(true, true,classFilters); Set<Class<?>> calssList = handler.getPackageAllClasses("com.mobanker", true); // logger.debug("writeInternal calssList:{}",calssList); if(calssList!=null){ for (Class<?> clazz : calssList) { if(clazz.isEnum() || (clazz.getSuperclass() != null && clazz.getSuperclass().isEnum())){ if(SerializeConfig.getGlobalInstance().get(clazz)==null) { SerializeConfig.getGlobalInstance().put(clazz, EnumSerializer.instance); } } } } // logger.debug("fastJson write object:{}",obj); try { super.writeInternal(obj, outputMessage); }catch (Exception e){ logger.error(e.getMessage(),e); } }
@Override protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String jsonString = JSON.toJSONString(o, serializerFeature); OutputStream out = outputMessage.getBody(); out.write(jsonString.getBytes(DEFAULT_CHARSET)); out.flush(); }
@Override protected void writeInternal(T t, HttpOutputMessage hom) throws IOException, HttpMessageNotWritableException, FileNotFoundException { try { objectToCSV(hom.getBody(), t.t); } catch (IllegalAccessException ex) { Logger.getLogger(CSVProcessor.class.getName()).log(Level.SEVERE, null, ex); } }