Cómo enviar una imagen desde un servicio web en Spring

Question

Tengo un problema al enviar una imagen usando Spring Web Service. controlador

he escrito como abajo

@Controller 
public class WebService { 

    @RequestMapping(value = "/image", headers = "Accept=image/jpeg, image/jpg, image/png, image/gif", method = RequestMethod.GET) 
    public @ResponseBody byte[] getImage() { 
     try { 
      InputStream inputStream = this.getClass().getResourceAsStream("myimage.jpg"); 
      BufferedImage bufferedImage = ImageIO.read(inputStream); 
      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
      ImageIO.write(bufferedImage , "jpg", byteArrayOutputStream); 
      return byteArrayOutputStream.toByteArray(); 

     } catch (IOException e) { 
      throw new RuntimeException(e); 
     } 
    } 
} 

@ResponseBody convierte respuesta en JSON.

Estoy utilizando RestClient para probar el servicio web.

Pero cuando estoy golpeando con http://localhost:8080/my-war-name/rest/image URL.

Header 
Accept=image/jpg 

que enfrenta siguiente error en RESTClient

conversión cuerpo de la respuesta a la cadena mediante la codificación de Windows-1252 fracasado. ¡Cuerpo de respuesta no configurado!

cuando estoy usando navegadores Chrome y Firefox

se añaden por lo que no se esperaba que el error

encabezados (Por favor, me guía en este)

 
HTTP Status 405 - Request method 'GET' not supported 

type Status report 

message Request method 'GET' not supported 

description The specified HTTP method is not allowed for the requested resource (Request method 'GET' not supported). 

también se han enfrentado a continuación el error una vez

El recurso identificado por esta solicitud solo es capaz de generar respuestas con características no aceptables accordi ng a la solicitud "aceptar" cabeceras()

he seguido http://krams915.blogspot.com/2011/02/spring-3-rest-web-service-provider-and.html tutorial.

Mi requerimiento es enviar imágenes en formato de bytes a Android Client.

Answer 1

Cambie la conversión a json y envíe la matriz de bytes tal como está.

El único inconveniente es que envía el tipo de contenido application/octet-stream de forma predeterminada.

Si eso no le sirve, puede usar BufferedImageHttpMessageConverter que puede enviar cualquier tipo de imagen compatible con los lectores de imágenes registrados.

A continuación, puede cambiar el método de:

@RequestMapping(value = "/image", headers = "Accept=image/jpeg, image/jpg, image/png, image/gif", method = RequestMethod.GET) 
public @ResponseBody BufferedImage getImage() { 
    try { 
     InputStream inputStream = this.getClass().getResourceAsStream("myimage.jpg"); 
     return ImageIO.read(inputStream); 


    } catch (IOException e) { 
     throw new RuntimeException(e); 
    } 
} 

mientras que tener:

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
    <property name="order" value="1"/> 
    <property name="messageConverters"> 
     <list> 
      <bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/> 
     </list> 
    </property> 
</bean> 

en su configuración primavera.

Answer 2

Aquí está el método que escribí para esto.

Necesitaba mostrar la imagen en línea en una página y, opcionalmente, descargarla al cliente, por lo que tomo un parámetro opcional para establecer el encabezado apropiado para eso.

Document es mi modelo de entidad para representar documentos. Tengo los archivos almacenados en el disco que lleva el nombre del ID del registro que almacena ese documento.El nombre de archivo original y el tipo de mime se almacenan en el objeto de documento.

@RequestMapping("/document/{docId}") 
public void downloadFile(@PathVariable Integer docId, @RequestParam(value="inline", required=false) Boolean inline, HttpServletResponse resp) throws IOException { 

    Document doc = Document.findDocument(docId); 

    File outputFile = new File(Constants.UPLOAD_DIR + "/" + docId); 

    resp.reset(); 
    if (inline == null) { 
     resp.setHeader("Content-Disposition", "attachment; filename=\"" + doc.getFilename() + "\""); 
    } 
    resp.setContentType(doc.getContentType()); 
    resp.setContentLength((int)outputFile.length()); 

    BufferedInputStream in = new BufferedInputStream(new FileInputStream(outputFile)); 

    FileCopyUtils.copy(in, resp.getOutputStream()); 
    resp.flushBuffer(); 

} 

Answer 3

Además de la respuesta proporcionada por soulcheck. Spring ha agregado produce propiedad a @RequestMapping anotación. Por lo tanto, la solución es más fácil ahora:

@RequestMapping(value = "/image", method = RequestMethod.GET, produces = "image/jpg") 
public @ResponseBody byte[] getFile() { 
    try { 
     // Retrieve image from the classpath. 
     InputStream is = this.getClass().getResourceAsStream("/test.jpg"); 

     // Prepare buffered image. 
     BufferedImage img = ImageIO.read(is); 

     // Create a byte array output stream. 
     ByteArrayOutputStream bao = new ByteArrayOutputStream(); 

     // Write to output stream 
     ImageIO.write(img, "jpg", bao); 

     return bao.toByteArray(); 
    } catch (IOException e) { 
     logger.error(e); 
     throw new RuntimeException(e); 
    } 
} 

Answer 4

La respuesta de #soulcheck es parcialmente correcta. La configuración no funcionará en la última versión de Spring ya que entraría en conflicto con el elemento mvc-annotation. Pruebe la configuración a continuación.

<mvc:annotation-driven> 
    <mvc:message-converters register-defaults="true"> 
    <bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/> 
    </mvc:message-converters> 
</mvc:annotation-driven> 

Una vez que tenga la configuración anterior en su archivo de configuración. El siguiente código funcionará:

@RequestMapping(value = "/image", headers = "Accept=image/jpeg, image/jpg, image/png, image/gif", method = RequestMethod.GET) 
public @ResponseBody BufferedImage getImage() { 
    try { 
     InputStream inputStream = this.getClass().getResourceAsStream("myimage.jpg"); 
     return ImageIO.read(inputStream); 
    } catch (IOException e) { 
     throw new RuntimeException(e); 
    } 
} 

Answer 5

Ver this article on the excellent baeldung.com website.

Se puede utilizar el siguiente código en su controlador de primavera:

@RequestMapping(value = "/rest/getImgAsBytes/{id}", method = RequestMethod.GET) 
public ResponseEntity<byte[]> getImgAsBytes(@PathVariable("id") final Long id, final HttpServletResponse response) { 
    HttpHeaders headers = new HttpHeaders(); 
    headers.setCacheControl(CacheControl.noCache().getHeaderValue()); 
    response.setContentType(MediaType.IMAGE_JPEG_VALUE); 

    try (InputStream in = imageService.getImageById(id);) { // Spring service call 
     if (in != null) { 
      byte[] media = IOUtils.toByteArray(in); 
      ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(media, headers, HttpStatus.OK); 
      return responseEntity; 
     } 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return new ResponseEntity<>(null, headers, HttpStatus.NOT_FOUND); 
} 

Notas: IOUtils proviene de la biblioteca Apache Commons-io. Estoy utilizando un servicio de Spring para recuperar blobs img/pdf de una base de datos.

Gestión similar para archivos pdf, excepto que debe utilizar MediaType.APPLICATION_PDF_VALUE en el tipo de contenido. Y se puede hacer referencia al archivo de imagen o el archivo PDF desde una página HTML:

<html> 
    <head> 
    </head> 
    <body> 
    <img src="https://localhost/rest/getImgDetectionAsBytes/img-id.jpg" /> 
    <br/> 
    <a href="https://localhost/rest/getPdfBatchAsBytes/pdf-id.pdf">Download pdf</a> 
    </body> 
</html> 

... o puede llamar al método de servicio web directamente desde su navegador.