Utiliser ServletOutputStream pour écrire de très gros fichiers dans un servlet Java sans problèmes de mémoire

flush travail sur le flux de sortie.

Vraiment je voulais faire remarquer que vous devez utiliser les trois-arg forme d'écriture que le tampon n'est pas nécessairement entièrement lu (notamment à la fin du fichier(!)). Aussi un try / finally serait en ordre sauf si vous voulez que votre serveur meurt de façon inattendue.

j'ai utilisé une classe qui encapsule le outputstream pour le rendre réutilisable dans d'autres contextes. Cela a bien fonctionné pour moi d'envoyer les données au navigateur plus rapidement, mais je n'ai pas examiné les implications sur la mémoire. (veuillez pardonner mon archaïque m_ l'appellation variable)

import java.io.IOException;
import java.io.OutputStream;

public class AutoFlushOutputStream extends OutputStream {

    protected long m_count = 0;
    protected long m_limit = 4096; 
    protected OutputStream m_out;

    public AutoFlushOutputStream(OutputStream out) {
        m_out = out;
    }

    public AutoFlushOutputStream(OutputStream out, long limit) {
        m_out = out;
        m_limit = limit;
    }

    public void write(int b) throws IOException {

        if (m_out != null) {
            m_out.write(b);
            m_count++;
            if (m_limit > 0 && m_count >= m_limit) {
                m_out.flush();
                m_count = 0;
            }
        }
    }
}

je ne suis pas sûr si flush()ServletOutputStream fonctionne dans ce cas, mais ServletResponse.flushBuffer() doit envoyer la réponse au client (au moins par 2.3 spécifications de servlet).

ServletResponse.setBufferSize() semble prometteur, aussi.

donc, selon votre scénario, ne devriez-vous pas être en boucle(à chaque itération) plutôt qu'en dehors de celle-ci? J'essaierais ça, mais avec un peu plus de tampon.

1. la classe de Kevin devrait fermer le m_out champ si ce n'est pas nul dans l'opérateur close (), nous ne voulons pas divulguer des choses, n'est-ce pas?

2. ainsi Que ServletOutputStream.flush() opérateur HttpServletResponse.flushBuffer() l'opération peut également rincer les tampons. Cependant, il semble qu'il s'agisse d'un détail spécifique à la mise en œuvre quant à savoir si ces opérations ont ou non un effet, ou si le support de la longueur du contenu http interfère. Rappelez-vous, spécifier la longueur du contenu est une option sur HTTP 1.0, donc les choses devraient juste s'échapper si vous tirez la chasse. Mais je ne vois pas ce que

la condition while ne fonctionne pas, vous devez vérifier la -1 avant de l'utiliser. Et s'il vous plaît, utilisez une variable temporaire pour le flux de sortie, son plus agréable à lire et il sécurise en appelant le getOutputStream() de façon répétitive.

OutputStream outStream = resp.getOutputStream();
while(true) {
    int bytesRead = inputStream.read(buffer);
    if (bytesRead < 0)
      break;
    outStream.write(buffer, 0, bytesRead);
}
inputStream.close();
out.close();

sans rapport avec vos problèmes de mémoire, la boucle while devrait être:

while(bytesRead > 0);

votre code a une boucle infinie.

do
{
    bytesRead = inputStream.read(buffer, offset, buffer.length);
    resp.getOutputStream().write(buffer, 0, bytesRead);
}
while (bytesRead == buffer.length);

décalage a la même valeur dans la boucle, donc si au départ décalage = 0, il en sera de même à chaque itération qui causera une boucle infinie et qui conduira à une erreur.

Ibm websphere application server utilise le transfert asynchrone de données pour les servlets par défaut. Cela signifie que les tampons de réponse. Si vous avez des problèmes avec les grandes données et les exceptions OutOfMemory, essayez de changer les paramètres sur était d'utiliser le mode synchrone.

Paramétrage du WebSphere Application Server WebContainer en mode synchrone

vous devez également prendre soin de charger les morceaux et les rincer. Échantillon pour chargement à partir d'un grand fichier.

ServletOutputStream os = response.getOutputStream();
FileInputStream fis = new FileInputStream(file);
            try {
                int buffSize = 1024;
                byte[] buffer = new byte[buffSize];
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    os.write(buffer, 0, len);
                    os.flush();
                    response.flushBuffer();
                }
            } finally {
                os.close();
            }