Serialisieren mit Progress

[Kruemel]

Guten Abend miteinander!

Normalerweiße findet man in google zu (fast) allem eine Antwort aber ich denke hier brauch ich fachmännische Hilfe ^^

Folgendes "Problem" oder eher Unklarheit:

Ich benutze eine Klasse "Message" in die ein String-Array und mehrere Byte-Arrays als Attachment gespeichert werden können.

Dieses Objekt soll über ein Socket serialisiert werden, klappt auch wunderbar.
Ich will den Fortschritt des Sendevorgangs grafisch ausgeben, also hab ich von FilterOutputStream und FilterInputStream abgeleitet um so die Bytes in einer extra Klasse Progress "mitzuzählen". Für den InputStream klappt das alles wunderbar, auch der OutputStream funktioniert soweit nur bremst er das ganze EXTREM aus. Normalerweiße findet die Serialisierung einer etwa 100mb großen Datei (auf die Festplatte) in weniger als einer Sekunde statt, mit dem ProgressOutputStream dauert es 10 Sekunden bis überhaupt ein Prozent der gesamten Bytes serialisiert wurde.

Ich dachte das Problem mit einem BufferedOutputStream vlt. lösen zu können und hab ihn so in die Streamkette eingefügt:

FileOutputStream fout = new FileOutputStream(new File("message.obj"));
ProgressOutputStream pos = new ProgressOutputStream(fout, p);	
BufferedOutputStream bos = new BufferedOutputStream(pos);		
ObjectOutputStream out = new ObjectOutputStream(bos);

Funktioniert genauso langsam, aber

FileOutputStream fout = new FileOutputStream(new File("message.obj"));
BufferedOutputStream bos = new BufferedOutputStream(fout);	
ProgressOutputStream pos = new ProgressOutputStream(bos, p);		
ObjectOutputStream out = new ObjectOutputStream(pos);

Funktioniert einwandfrei, zwar immer noch leicht zu langsam aber um ein vielfaches besser.

Warum ist das so? Ich denke, dass ich hier irgendwo eine Bremse reingehauen habe, die hätte ich gerne wieder weg.

Der OutputStream:

import java.io.*;

public class ProgressOutputStream extends FilterOutputStream{
	
	private Progress progress=null;
	
	public ProgressOutputStream(OutputStream out, Progress progress){
		super(out);
		this.progress=progress;
	}
	
	public synchronized void write(byte[] b, int off, int len) throws IOException{
		super.write(b, off, len);
		progress.update(len);
	}
}

Sorry für den Roman ^^ Ich hoffe es weiß jemand was hier falsch läuft.

Gruß,
Kruemel

P.S.: "Ganz normal senden" ohne Serialisierung u.s.w. funktioniert auch toll, ich weiß aber so eine Messageklasse in die man einfach alles reinpacken und senden kann ist viel komfortabler finde ich.

 

[SlaterB]

schau dir einfach den Quellcode an, FilterOutputStream write(Array) bringt das Kunststück zustande, in einer Schleife für jedes byte einzeln write() aufrufen, das Buffern ist komplett deaktiviert, alles wird einzein geschrieben

 

[Kruemel]

Vielen Dank Slater B! Das war das Problem ^^ Wer denkt sich denn sowas aus.

Hab jetzt einfach den FilterOutputStream quasi nur noch als "Deko" um in der Klassenhierarchie drin zu sein, der Outputstream verschickt die Pakete jetzt einfach selbst ohne den super Aufruf.

public class ProgressOutputStream extends FilterOutputStream{
	
	private Progress progress=null;
	protected OutputStream out;
	
	public ProgressOutputStream(OutputStream out, Progress progress){
		super(out);
		this.out=out;
		this.progress=progress;
	}
	
	public synchronized void write(byte[] b, int off, int len) throws IOException{
		out.write(b, off, len);
		progress.update(len);
	}
	
	public synchronized void write(byte[] b) throws IOException{
		out.write(b);
		progress.update(b.length);
	}
	
	public synchronized void write(int b) throws IOException{
		super.write(b);
		progress.update(1);
	}
}

Vielen Dank!
Gruß, Kruemel

Edit:
Wäre es besser anstatt selbst den identischen Outputstream in out zu speichern, auf den des FilterOutputStreams, der gezwungenermaßen gesetzt werden muss, über super.out.write(...) zuzugreifen?