De retour de fichier à partir du Printemps @Contrôleur OutputStream

Obtenir le OutputStream de la HttpServletResponse et écrire le fichier (dans cet exemple à l'aide de IOUtils de Apache Commons)

@RequestMapping(value = "/download", method = RequestMethod.GET)
public void download(HttpServletResponse response) {
    ...
    InputStream inputStream = new FileInputStream(new File(PATH_TO_FILE)); //load the file
    IOUtils.copy(inputStream, response.getOutputStream());
    response.flushBuffer();
    ...
}

Assurez-vous d'utiliser un try/catch pour la fermeture du flux dans le cas d'une exception.

OriginalL'auteur John Smith

Je recommande la lecture de cette réponse

@ResponseBody
@RequestMapping("/photo2", method = RequestMethod.GET, produces = MediaType.IMAGE_JPEG_VALUE)
public byte[] testphoto() throws IOException {
    InputStream in = servletContext.getResourceAsStream("/images/no_image.jpg");
    return IOUtils.toByteArray(in);
}

répondu par michal.kreuzman

J'allais écrire quelque chose de semblable à moi mais bien sûr qu'il a déjà été répondu.

Si vous voulez juste passer le flux à la place de premier de tout dans la mémoire vous pouvez utiliser cette réponse
Je n'ai pas testé (pas au travail), mais il semble légitime 🙂

@RequestMapping(value = "report1", method = RequestMethod.GET, produces = "application/pdf")
@ResponseBody
public void getReport1(OutputStream out) {
    InputStream in; //retrieve this from wherever you are receiving your stream
    byte[] buffer = new byte[1024];
    int len;
    while ((len = in.read(buffer)) != -1) {
        out.write(buffer, 0, len);
    }
    in.close();
    out.flush(); //out.close? 
}

La chose est, c'est à peu près le même que IOUtils.copie /IOUtils.copyLarge. ligne: 2128
Qui vous disent que des copies de la mauvaise direction.

Cependant tout d'abord assurez-vous de comprendre ce que vous demandez. Si vous voulez lire un outputstream(objet de l'écriture) et les écrire dans un flux d'entrée (objet à lire à partir de) alors je pense que ce que vous voulez vraiment est d'écrire à un objet qui fournit également une option de lecture.

pour que vous pourriez utiliser un PipedInputStream et PipedOutputStream. Ceux-ci sont connectés ensemble afin d'octets écrits dans le outputstream sont disponibles pour être lu à partir de la correspondante du flux d'entrée.

donc à l'endroit où vous recevez les octets je suppose que vous êtes l'écriture d'octets à un outputstream.
il y a cela:

//set up the input/output stream so that bytes written to writeToHere are available to be read from readFromhere
PipedInputStream readFromHere = new PipedInputStream();
PipedOutputStream writeToHere = new PipedOutputStream(readFromHere);

//write to the outputstream as you like
writeToHere.write(...)

//or pass it as an outputstream to an external method
someMather(writeToHere);

//when you're done close this end.
writeToHere.close();


//then whenever you like, read from the inputstream
IOUtils.copy(readFromHere, out, new byte[1024]); 

Si vous utilisez IOUtils.copie il continue à lire jusqu'à ce que le outputstream est fermé. donc, assurez-vous qu'il est déjà fermé avant de commencer (si vous lancez la lecture/écriture sur le même thread) ou utiliser un autre thread pour écrire dans la mémoire tampon de sortie et de le fermer à la fin.

Si ce n'est pas ce que vous cherchez, alors vous aurez à affiner votre question.

OriginalL'auteur Joeblade

Le plus efficace de la mémoire de la solution dans votre cas, serait de passer la réponse OutputStream droit à l'API Dropbox:

@GetMapping(value = "download/{name}")
public void getFileByName(@PathVariable("name") final String name, HttpServletResponse response)
        throws IOException, DbxException {
    response.setContentType("audio/mpeg3");
    response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + name + "\"");
    response.setContentLength(filesize); //if you know size of the file in advance

    new DbxClient().getFile("/" + name, null, response.getOutputStream());
}

Les données lues par l'API sera envoyé directement à l'utilisateur. Aucune autre octets de la mémoire tampon n'est requise.

Comme pour PipedInputStream/PipedOutputStream, ils sont conçus pour le blocage de la communication entre les 2 threads. PipedOutputStream blocs thread d'écriture après 1024 octets (par défaut) jusqu'à ce qu'un autre thread commencer la lecture à partir de la fin de la pipe (PipedInputStream).

OriginalL'auteur Lu55