Newsgroup: it.comp.java
Titolo: Socket al parserXML, fine parsing-> socket chiuso

Il concetto è questo:
ricevo via socket testo xml che devo passare al SaxParser.
Aperto il socket lo passo al parser:
// STREAM
BufferedOutputStream out=new BufferedOutputStream(client.getOutputStream());
// READER
XMLReader xr=new org.apache.xerces.parsers.SAXParser();
// ISTANZA
MyXML gestoreXml=new MyXML(out);
dove MyXML è il DefaultHandler del doc XML
Due problemi:
1) Quando il parsing del documento è terminato, il documento (ovvero il
socket) viene chiuso
2) Vorrei loggate tutto ciò che ricevo sul socket  in modo indipendente dal
DefaultHandler
in modo che anche se il doc XML è mal formattato o sbagliato, io possa
comunque tenere traccia di quello che ho ricevuto
Avete consigli/idee ?

Scusate, ho pastato il pezzo sbagliato :-)
xr.parse( new InputSource(client.getInputStream())); // Passo al lettore XML
il socket per leggere
J

DefaultHandler
IMHO la via è disaccoppiare lettura dal socket e input al parser.
Ad esempio leggendo quanto c'è da leggere dal socket e memorizzandolo in 
una String (attenzione alle dimensioni!). Puoi usarla per loggare.
Poi potresti costruire la tua InputSource su uno StringReader a sua volta 
costruito sulla String di prima.
Un'altra strada è quella di implementare un proprio InputStream (o Reader) 
che "decori" (nel senso del Design Pattern Decorator) l'InputStream 
ottenuto dal Socket aggiungendo funzioni di logging e gestione della 
connessione.
Se vuoi un po' d'ispirazione... eccoti una bozza :-)
import java.io.*;
public class JJReader extends Reader {
    private Reader src = null;
    private Writer dest = null;
    public JJReader(Reader source, Writer side) {
        if (source == null) {
            // magari solleva una Exception
        }
        src = source;
        dest = side;
    }
    public int read(char[] cbuf, int off, int len) throws IOException {
        int res = src.read(cbuf, off, len);
        if ((dest != null) && (res != -1)) {
            dest.write(cbuf, off, res);
        }
        return res;
    }
    public void close() throws IOException {
        src.close();
        if (dest != null) {
            dest.close();
        }
    }
    public void mark(int readAheadLimit) throws IOException {
        src.mark(readAheadLimit);
    }
    public boolean markSupported() {
        return src.markSupported();
    }
    public int read() throws IOException {
        int ch = src.read();
        if ((dest != null) && (ch != -1)) {
            dest.write(ch);
        }
        return ch;
    }
    public int read(char[] cbuf) throws IOException {
        int res = src.read(cbuf);
        if (dest != null && res != -1) {
            dest.write(cbuf, 0, res);
        }
        return res;
    }
    public boolean ready() throws IOException {
        return src.ready();
    }
    public void reset() throws IOException {
        src.reset();
    }
    public long skip(long n) throws IOException {
        return src.skip(n);
    }
 
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("JJReader.java");
        StringWriter sw = new StringWriter();
        JJReader dr = new JJReader(fr, sw);
        while (dr.read() != -1) {}
        dr.close();
        System.out.println(sw.toString());
    }
}
HTH
-- 
Ciao
	Fabrizio C.

 Un'altra strada č quella di implementare un proprio InputStream (o Reader)


Leggerò bene domani e vediamo cosa combino :-)
Già che ci sei, domani, leggi un po' di netiquette per imparare a quotare 
meglio.
-- 
Ciao
	Fabrizio C.

"Fabrizio Camera" <f.came...@Mtiscali.it> ha scritto nel messaggio
news:MPG.17f2f9385...@powernews.libero.it...

Che noia, dai non fare il pignolo per un "appuntino veloce" ...se guardi gli
altri post non vedrai problemi... forse facevo prima a non ringraziare
nemmeno.
J

nemmeno.
Ok, capita a tutti di... distrarsi.
Ma riportare 100 righe per aggiungerne 2...
Sei d'accordo? ;-)
Adesso però facci sapere che soluzione hai adottato. :-)
-- 
Ciao
	Fabrizio C.

 indipendente dal DefaultHandler
La tecnica piu' semplice e' di usare un wrapper: un handler che contenga 
l'handler originale, e le cui implementazioni dei vari metodi di reazione 
agli eventi SAX sono tutte del tipo:
    	metodo blahBlahBlah(..) {
     	    	...fai il trace...
    	    	originalHandler.blahBlahBlah(..);
    	}
 
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

    	}
Stai proponendo un modo di fare il trace "sulle azioni" svolte, mentre io 
avevo interpretato il messaggio come richiesta di loggare ciň che arriva al 
parser attraverso la stream. :-)
A parte questo, credi che una soluzione come quella da me proposta (magari 
un po' rivista) possa essere accettabile?
Ci vedi grossi problemi?
Sono molto interessato a sentire qualche parere autorevole. :-)
-- 
Ciao
	Fabrizio C.

 Sono molto interessato a sentire qualche parere autorevole. :-)
Assolutamente si'. E' un wrapping a livello di stream. :-)
