# Mehrere Dateien über einen Socket senden



## ReaX (5. August 2008)

Hi,

ich sitze schon länger an einem Projekt und hab hier ein Problem, dass ich nicht in den Griff bekomme.

Und zwar will ich einfach mehrere Dateien über einen einzigen Socket versenden. Will also nicht für jede Datei ein neuen Socket öffnen, da dass ja sehr langsam sein würde...
Eine einzelne Datei ist nicht das Problem, dass bekomme ich hin, aber ich weiß nicht wie ich mehrere versenden soll.

Mit google hab ich ein etwas älteren Thread hier gefunden - http://www.tutorials.de/forum/java/303254-mehrere-dateien-ueber-socket-senden.html - der das gleiche Problem hatte. 

Ich hab es, wie auch in diesem Thread beschrieben, versucht, in dem ich einfach immer das erste Byte des Buffers ( buffer[0] )mit 1 belege und wenn die Datei endet, einfach eine 0 in dem Buffer[0], sende, sodass der Client weiß, dass die Datei fertig ist und eine neue beginnt. Aber das hat irgendwie nicht geklappt..

Hat einer von euch eine Idee oder kann mir sagen, wie ich mehrere Dateien über einen Socket senden und empfangen kann..

Schon mal Danke im Vorraus


----------



## Looky (5. August 2008)

poste doch bitte deinen bisherigen code, womit du dateien versendest.


----------



## ReaX (5. August 2008)

also einzelne dateien sende ich so:

empfangen

```
FileOutputStream fileOut = new FileOutputStream( f );
			
byte[] buffer = new byte[1024];
			
while ( socket.isConnected() ) {
	int bytesRead = in.read(buffer);
	if (bytesRead == -1) break;
				
	fileOut.write(buffer, 0, bytesRead);
}
fileOut.close();
```

und senden:

```
OutputStream out = s.getOutputStream();				
InputStream fileIn = new FileInputStream( file );
				
byte[] buffer = new byte[1024];
				
while (fileIn.available() > 0) {
	out.write(buffer, 0, fileIn.read(buffer));
}				
fileIn.close();
```

und das klappt auch für einzelne dateien.. und mein ansatz für mehrere war jettz einfach dieser:

beim senden:

```
...
byte[] buffer = new byte[1024];
int bRead = 0;
			
while (fileIn.available() > 0) {
	bRead = fileIn.read(buffer, 1, 1023);
				
	buffer[0] = 1;
				
	dos.write(buffer, 0, bRead+1);
	dos.flush();				
}
			
buffer[0] = 0;
outStream.write(buffer, 0, 1);
outStream.flush();
...
```

und nochmal empfangen:

```
..
while(true) {
	bRead = dis.read(buffer);
								
	if ( bRead == -1 || buffer[0] == 0 ) break;
				
	fileOut.write(buffer, 1, bRead-1 );
	fileOut.flush();
}
..
```

die zwei untern Codeblöcke sind nun halt nochmals in Schleifen für mehrere Dateien/Durchgänge verschachtelt.. nur klappt das nicht. das "Zeichen" das ich mir gesetzt habe, wann eine Datei fertig ist (buffer[0]), wird irgendwann trotz buffer[0] = 1 plötzlich irgend ne Zahl... ich habe keine Ahnung warum das so ist..


----------



## Looky (6. August 2008)

Tja und hier liegt das Problem.

Du bindest einen Outputstream an den Server. Das ist ja auch gut so. Allerdings, sobald ud den Outputstream schließt, schließt du automatisch auch den Socket.

Ich hatte mal ein ähnliches Problem in unserer Firma. Ich habe es anschließend so gelöscht, dass ich den Stream einfach nicht zugemacht habe sondern immer wieder verwedet habe.

Das Problem das hierbei entsteht ist, wann weiß der Empfänger, dass die Datei konmplett ist? Hier half bei mir nur, einen definierten Dateiendpunkt zu setzen. Wenn dieser übertragen wird, dann ist die Datei komplett.

Wie dieser Endpunkt aussieht kannst du selber bestimmen. Ist sicherlich nicht die schönste Methode und wenn einer was besseres weiß, dann immer rauß damit, aber für mich funktioniert es erstmal gut 

HF
Chriz


----------



## ReaX (6. August 2008)

Aber ich schließe ja den OutputStream gar nicht. Das einzige was ich schließe sind die In und OutputStreams für die Files und die hängen ja nicht mit den Streams des Sockets zusammen.. oder?

Und das mit dem Endepunkt wollt ich ja eigentlich mit dem buffer[o] = 1 machen


----------



## ReaX (6. August 2008)

Ich habe gerade etwas überprüft und zwar..
..wenn ich beim Empfangen das erste Byte der Buffers und die Anzahl der eingelesenen Byte ausgebe, ist es bei kleinen Dateien so wie es sein sollte, also buffer[0] = 1 aber sobald die Datei länger wird, kann sein, dass der Reader nicht mehr die volle Anzahl Bytes einließt und durcheinadner kommt, sodass das buffer[0] Byte nichtmehr 1 oder am Schluss 0 ist..

(erste Zahl ist der Wert von buffer[0] und die hintere Zahl bRead, also wieviele Bytes eingelesen wurden)


```
..
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 1024
1 - 284        <---- ab hier spinnt er..
102 - 1024
91 - 1024
112 - 1024
48 - 1024
13 - 1024
-125 - 1024
84 - 1024
-4 - 1024
..
```


----------



## Looky (18. August 2008)

hilft dir das?
http://www.tutorials.de/forum/java/...datei-und-dann-wieder-objekte-ubertragen.html


----------



## schnuffie (18. August 2008)

Ich habe dieses Problem "umschifft", indem ich die zu übertragenden Dateien als ZIP gepackt habe. Das hat nicht nur den Charm, daß ich jetzt nur eine Datei hatte, sondern auch die zu übertragende Menge an Bytes sich dadurch reduzierte = bessere Übertragungsrate. Die Zeit für das Packen und Entpacken übrigends war weniger, als wenn ich die unkomprimierten Bytes übertragen hätte.


----------

