Come inviare un'immagine dal servizio Web in primavera

Question

Ho riscontrato un problema durante l'invio di un'immagine tramite Spring Web Service. Controller

ho scritto come di seguito

@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 converte la risposta in JSON.

Sto utilizzando RestClient per testare il servizio Web.

Ma quando sto colpendo con l'URL http://localhost:8080/my-war-name/rest/image.

Header 
Accept=image/jpg 

ho rivolto seguente errore sul RestClient

conversione corpo risposta a stringa utilizzando la codifica windows-1252 non è riuscita. Corpo della risposta non impostato!

quando sto utilizzando i browser Chrome e Firefox

non sono aggiunti in modo era previsto errore

intestazioni (per favore mi guida su questo)

 
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). 

ho anche affrontato sotto l'errore una volta

La risorsa identificata da questa richiesta è valida solo per di generare risposte con caratteristiche non accettabili. ng alla richiesta "accettare" headers()

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

Il mio requirment consiste nell'inviare un'immagine in formato byte al client Android.

Answer 1

Rilascia la conversione in json e ha inviato l'array di byte così com'è.

L'unico inconveniente è che invia il tipo di contenuto application/octet-stream per impostazione predefinita.

Se non è disponibile, è possibile utilizzare BufferedImageHttpMessageConverter che può inviare qualsiasi tipo di immagine supportata dai lettori di immagini registrati.

Quindi è possibile cambiare il metodo di:

@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); 
    } 
} 

pur avendo:

<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> 

nella vostra configurazione di primavera.

Answer 2

Ecco il metodo che ho scritto per questo.

Avevo bisogno di visualizzare l'immagine in linea su una pagina e, facoltativamente, di scaricarla sul client, quindi prendo un parametro facoltativo per impostare l'intestazione appropriata per quello.

Document è il mio modello di entità per rappresentare i documenti. Ho i file stessi memorizzati sul disco chiamato dopo l'ID del record che memorizza quel documento.Il nome file originale e il tipo mime sono memorizzati nell'oggetto Document.

@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

Oltre alla risposta fornita da soulcheck. La primavera ha aggiunto produce proprietà a annotazione @RequestMapping. Pertanto soluzione è più facile ora:

@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 risposta di #soulcheck è parzialmente ragione. La configurazione non funzionerà nell'ultima versione di Spring in quanto si scontrerebbe con l'elemento mvc-annotation. Prova la configurazione qui sotto.

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

Una volta completata la configurazione nel file di configurazione. Il codice seguente funzionerà:

@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

Vedere this article on the excellent baeldung.com website.

È possibile utilizzare il seguente codice nel tuo controller 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); 
} 

Note: IOUtils proviene dalla libreria apache common-io. Sto usando un servizio Spring per recuperare i BLOB img/pdf da un database.

Gestione simile per i file PDF, ad eccezione del fatto che è necessario utilizzare MediaType.APPLICATION_PDF_VALUE nel tipo di contenuto. E si può fare riferimento il file di immagine o il file PDF da una pagina 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> 

... oppure è possibile chiamare il metodo di servizio Web direttamente dal browser.