# Datei über ObjectInputStream versenden



## Guest (3. Mai 2007)

Mein Problem ist folgendes: 

Ich kommuniziere mit einem Server über ObjectInput- und ObjectOutputStreams.

Den Code fuer das Paket vom Server koennt ihr hier sehen:

```
package Packages;

import java.io.Serializable;
import MusicAdmin.*;
import java.io.File;
/***
 * Nachrichten, die vom Server an den Client gesendet werden.
 * 
 * @author lundner
 *
 */
public class ServerPackage implements Serializable {
	/***
	 * Playlist, die auf dem Server liegt
	 */
	public Tracklist tracklist;
	/***
	 * File[] - Falls Musikdatei angefordert
	 */
	public File file = null;
	/***
	 * Status des Servers
	 * -1 - unbekannter Status
	 * 0 - Client abmelden
	 * 100 - Tracklist angefordert
	 * 101 - Tracklist aktualisiert
	 * 102 - Tracklist geshuffelt
	 * 103 - Tracklist geleert
	 * 104 - Track geloescht (track ist cArray[1])
	 * 105 - Track wird gespielt (track ist cArray[1])
	 * 106 - Track wird uebertragen (track ist cArray[1]);
	 * 906 - Track nicht gefunden
	 */
	public int status;
	/***
	 * Kommentare des Servers - z.b. unbekannter Befehl durch Client.
	 */
	public String comment;
	/***
	 * Erzeugt ein Serverpackage mit Tracklist, Status und Kommando
	 * @param l
	 * @param stat
	 * @param com
	 */
	public ServerPackage(Tracklist l,int stat,String com){
		tracklist = l;
		status = stat;
		comment = com;
	}
	public ServerPackage(Tracklist l,int stat,String com,File f){
		tracklist = l;
		status = stat;
		comment = com;
		file = f;
	}
}
```

Je nachdem, welchen Status der Server dem Client übergibt, verarbeitet der Client die Serverpakete anders.

Das klappt auch bisher wunderbar. Bloss bei Status 106 (Wenn ich eine Datei vom Server runterladen möchte, und diese auf meinem lokalen Rechner gespeichert werden soll) habe ich Probleme. Ich möchte die Datei innerhalb dieses Objektes ServerPackage mitversenden.

Danach soll der Client das komplette ServerPackage entgegenehmen und die Datei abspeichern können.

Hier mal die Clientseite, die das ServerPackage wartet...

```
public void run(){
		while(true){
			try {
				//Objektinputstream abfangen
				ObjectInputStream is = new ObjectInputStream(connection.getServer().getInputStream());
				//Package handlen
				handlePackage(is);
			} catch(IOException e1){
				System.out.println("STAT: Server-Verbindung beendet");
				System.exit(0);
			}
		}
	}
```

Ist es überhaupt möglich, eine komplette Datei über ein ObjectStream zu übergeben?! Performant soll das ganze sowieso nich sein, hauptsache ich kriege es hin! ;-)

MfG Lundner


----------



## Lundner (3. Mai 2007)

Sorry hab vergessen mich einzuloggen :-/


----------



## m@nu (3. Mai 2007)

es nützt dir nichts, wenn du die instanz einer File-klasse verschickst. das ist lediglich ein handle auf die datei. wirklich auslesen kannst du die datei erst über einen entsprechenden stream.

du kannst dir natürlich eine klasse schreiben, welche z.b. dateiname & ein byte-array mit dem inhalt der datei bereithält, und diese dann per objectstream verschicken... aber einlesen musst du das teil immernoch selber.


----------



## Lundner (3. Mai 2007)

ja ne das is schon klar - das hab ich jetzt nur symbolisch hingeschrieben mit file ! ;-)

kannst du mir nen tipp geben, wie ich die datei in ein byte-array packen kann?! mit inputstream etc ging es ja nicht weil das nich serialisierbar ist


----------



## NTB (3. Mai 2007)

öh kannst Du das nicht über die ByteArrayStreams machen?


----------



## Lundner (3. Mai 2007)

Das mit den byte-arrays ging genau in die richtige richtung - DANKE!!
hier mal meine klasse:

```
package Packages;

import java.io.File;
import java.io.IOException;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.*;
import java.io.FileOutputStream;

public class ByteData implements Serializable {
	
	public String filePath;
	public String newName;
	byte[] fileBytes;
	
	
	public ByteData(File f){
		loadData(f.getAbsolutePath());
		newName = f.getName();
	}
	
	public void saveData(String path){
		File file = new File(path);
		try {
			DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
			//System.out.println(fileBytes.length);
			for(int i=0;i<fileBytes.length;i++){
				dos.write(fileBytes[i]);
			}
			dos.flush();
			dos.close();
		} catch(IOException e){
			System.out.println("Speicher-Fehler: "+e);
		}
	}
	
	public void loadData(String path){
		File file = new File(path);
		try {
		DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
                fileBytes = new byte[(int) file.length( )];
                fis.readFully(fileBytes);
                fis.close();
                System.out.println(fileBytes.length);
		} catch(IOException e){
			System.out.println("Lade-Fehler: "+e);

		}		
	}
}
```

edit: ich find den button nicht um diesen Thread als gelöst zu markieren *sry*


----------



## NTB (3. Mai 2007)

Ich hatte an richtige ByteArrayInput und Outout gedacht. So ist doch aber auch schnieke. Schön, dass Du Deine Lösung gepostet hast. Hab ich mir auch gleich gespeichert... wer weiss, wozu man das noch braucht 
Unten links kannst Du den Fred abharken...


----------



## m@nu (4. Mai 2007)

genau sowas habe ich gemeint 

aus reinem interesse: wie geht die performance so? wenn ich eine datei per netzwerk verschickt hab', dann habe ich das ohne denn umweg über ein byte array gemacht.

ps. das häckchen zum "solved"-flag is ganz unten links von deinem thread


----------



## Lundner (4. Mai 2007)

habs bis jetzt nur über meinen localhost gejagt. da gings zügig ;-)

ich glaub ich kann den thread nicht als solved markieren weil ich ja ausversehen als gast den thread eröffnet habe..

und danke nochmal!!

edit: das ganze klappt aber nur mit kleinen dateien, bei grösseren gibt es nen stackerror - relativ logisch, weil das array ja auch dementsprechend gross wird...


----------

