[JAVA] - comunicazione http - migliorare il buffer

[cagnaluia]

Ciao,

un esercizio, che non so da dove cominciare...
Ho questo codice, avviato da un server http e fa certe semplici cose, cioè visualizzare una risorsa.. un file di testo o un immagine.
E' molto grossolano, prende tutta la risorsa e la spedisce al client (il browser).

Vorrei migliorarlo, nel senso che prenda piccole porzioni della risorsa richiesta e la trasferisca a pezzi più piccoli.

ma come?

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package tinyhttpd;
import java.net.*;
import java.io.*;
import java.util.*;

/**
 *
 * @author autore
 */

class tinyhttpdconnection extends Thread
{
    Socket sock;
    tinyhttpdconnection (Socket s)
    {
        sock = s;
        setPriority(NORM_PRIORITY -1);
        start();
    }
    public void run()
    {
        try
        {
            OutputStream out = sock.getOutputStream();
            BufferedReader in=new BufferedReader(new
            InputStreamReader(sock.getInputStream()));
            String req = in.readLine();
            System.out.println( "Request: "+req );
            StringTokenizer st = new StringTokenizer( req );
            if ( (st.countTokens() >= 2) && st.nextToken().equals("GET") )
            {
                if ( (req = st.nextToken()).startsWith("/") ) req = req.substring( 1 );
                if ( req.endsWith("/") || req.equals("") ) req = req + "index.html";
                try
                {
                    FileInputStream fis = new FileInputStream ( req );
                    byte [] data = new byte [ fis.available() ];
                    fis.read( data );
                    out.write( data );
                } catch ( FileNotFoundException e )
                  {
                        new PrintStream( out ).println("404 Not Found");
                  }
            }
            else new PrintStream( out ).println( "400 Bad Request" );
            sock.close();
        }
        catch ( IOException e )
        {
            System.out.println( "I/O error " + e );
        }
    }
}

[andbin]

Originariamente inviato da cagnaluia
E' molto grossolano, prende tutta la risorsa e la spedisce al client (il browser).

Vorrei migliorarlo, nel senso che prenda piccole porzioni della risorsa richiesta e la trasferisca a pezzi più piccoli.

Vedo che stai "parsando" tu la request, il che generalmente non è banale (specialmente se dovessi analizzare anche gli header). Quindi stai realizzando una specie di server HTTP, sebbene davvero minimale.

Ma a parte questo, torniamo alla tua richiesta. Caricare tutto il file in memoria ovviamente non è proprio una buona cosa. La cosa "tipica" che si fa è istanziare un piccolo array di lunghezza predefinita, es. 1024, 2048 o comunque dimensioni del genere (non esagerare però ....) e poi fare un ciclo di lettura in cui leggi un blocco dal file e lo scrivi sul socket. Ovviamente devi anche usare il valore di ritorno della read, in quanto l'ultimo blocco letto può non riempire tutto l'array!

Ah e dovresti anche inviare lo status code e gli header nella response, almeno quello per indicare il content-type. Una cosa è se mandi una immagine, un'altra se mandi una pagina html, ecc...

[cagnaluia]

ok,

intanto ho fatto questa modifica: all'interno del "try"

                try
                {
                    FileInputStream fis = new FileInputStream ( req );
                    byte [] data = new byte [1024];
                    while(fis.available()>0)
                        {
                            fis.read(data);
                            out.write(data);
                        }
                }

[LordSaga640]

non proprio. Come dice andbin devi verificare all'ultima lettura del ciclo quanti byte leggi. Difficilmente ci saranno byte necessari per riempire l'array di byte. Se leggi solo 50 byte e lo invii. Invii anche una serie di dati in piu' spazzatura. Spero di essermi spiegato.

la soluzione e' di specificare l'offset e la lunghezza quando scrivi in uscita in base ai byte letti nell'ultima lettura.

[andbin]

Originariamente inviato da cagnaluia

                    byte [] data = new byte [1024];
                    while(fis.available()>0)
                        {
                            fis.read(data);
                            out.write(data);
                        }

No.

byte[] buf = new byte[1024];
int len;

while ((len = fis.read(buf)) != -1) {
    out.write(buf, 0, len);
}