Kopierte Dateien nicht identisch

[Morgyr]

Guten Tag.

Ich möchte ein Programm schreiben, mit dem ich Dateien über Internet verschicken kann.
Weil die Dateien scheinbar nicht 1 zu 1 übertragen werden, habe ich einfach mal zum testen ein Programm geschrieben, mit dem ich eine Datei ohne Internet "verschicken" kann, also kopieren. Doch auch da sind die Dateien nicht identisch. Ich habe das ganze an .xcf und .bmp getestet. GIMP kann die kopiert Datei nicht öffnen und bei der .bmp ist das Bild nahezu identisch, doch ist auf dem kopierten Bild noch sowas, wie wenn man über GIMP mit der Sprühdose, falls das so heißen sollte, über das Bild geht. Das komische daran ist, dass das alles nach System aussieht.

Wie ich kopieren will:
Ich lese aus einer Datei den Inhalt aus, öffne eine neue Datei mit anderem Namen und schreibe dort den Inhalt der vorherigen Datei rein.

String readFile(){  
		String content = new String();
	    try{
	        File fileToLoad = new File("...und noch einer^^.bmp");
	        char contentChars[] = new char[(int)fileToLoad.length()];
	        Reader reader = new FileReader(fileToLoad);
	        reader.read(contentChars);
	        StringBuffer stringBuffer = new StringBuffer();
	        stringBuffer.append(contentChars);
	        content = stringBuffer.toString();
	        	
	        reader.close();   
	    }
	    catch(IOException io){JOptionPane.showMessageDialog(null, "Fehler beim Laden der Dateien!", "Fehler", JOptionPane.ERROR_MESSAGE);}
	    return content;
	}

boolean writeFile(String stringToWrite){
	    File fileToWrite = new File("...und noch einer^^test.bmp");
	    try{
	    	fileToWrite.createNewFile();
	    	FileWriter fileWriter = new FileWriter(fileToWrite);
	    	fileWriter.write(stringToWrite);
	    	fileWriter.flush();
	    	fileWriter.close();
	    	return true;
	    }catch(IOException io){
	        return false;
	    }
	}

Meine Überlegung wäre, ob es Zeichen gibt, die String, char oder StringBuffer nicht einlesen kann und somit irgendwas verändert. Ist das möglich und wie könnte ich es vermeiden? Denn am String wird ja kaum was verändert.

Ich hoffe, mir kann jemand helfen.
Mit freundlichen Grüßen
Morgyr

 

[@x.l]

Kopiere Byte für Byte... da biste auf der sicheren Seite!

 

[Wildcard]

Writer sind nur für Zeichenbasierte Inhalte gedacht. Bei binären Dateien musst du mit Streams arbeiten.

 

[Der Müde Joe]

ein FileChannel bietet sich an
http://www.rgagnon.com/javadetails/java-0064.html

EDIT:
oder hier:
http://www.java2s.com/Tutorial/Java/0180__File/0420__FileChannel.htm
http://java-forum.org/de/viewtopic.php?t=66216&highlight=filechannel

 

[FArt]

Denn am String wird ja kaum was verändert.

Doch.

http://java.sun.com/j2se/1.3/docs/guide/intl/encoding.doc.html

 

[Morgyr]

So, danke an euch 4.
Ich bekomme die Dateien verschoben, bzw. auch übers Internet verschickt. Allerdings hänge ich seit 2 Tagen an einem Problem fest. Teilweise existiert das Problem nicht, teilweise schon. Aber ich habe nicht die geringste Ahnung warum das so ist.

Ich verschicke die Bytes über eine while()-Schleife, die stoppt sobald keine Bytes mehr einzulesen sind. Das macht der Absender auch richtig. Ich schicke dem Empfänger immer noch einen integer mit, damit er weiß, ob noch Bytes geschickt werden oder nicht. 1 ist dabei true, und 0 false. Bekommt der Empfänger eine 0 bricht die while()-Schleife, die ich über einen integer regle, der 0 sein muss, um zu weiterzulaufen. Bei einer 0 wird diese Variable also auf 1 gesetzt, bzw. eine beliebige andere Zahl.
Das Problem ist allerdings, es kommt nie eine 0 an.

Hier erstmal die entsprechenden Schleifen.

Absender

	byte[] buffer = new byte[1024];
	int length = 0;
	int firstLoop = 0;

	while((length = fileIn.read(buffer)) != -1){
	    if(firstLoop == 0){
	    	output.writeInt(1);
	    	output.flush();
	    	firstLoop = 1;
	    }
	   output.writeInt(1);
      output.flush();
	   output.write(buffer, 0, length);    	
	   output.flush();
	} 			
	output.writeInt(0);
	output.flush();

Empfänger

    		  byte[] buffer = new byte[1024];
    			int endOfString = 0;

    			if(input.readInt() == 1){   
    				while(endOfString == 0){
    					int bytesSended = input.readInt();		

    					if(bytesSended == 1){
    						input.read(buffer);
    						fileOutputStream.write(buffer);	   						
    					}
    					else if(bytesSended == 0){
    						endOfString = 1;    						
    					}   			
    				}				
    			}

Das was also passieren sollte ist, dass der Absender beim ersten Schleifen-Durchlauf eine 1 sendet, wenn die Datei überhaupt bytes hat (Z.7). Dies nimmt der Empfänger in Zeile 4 auf. Hat die Datei keinen Inhalt, wird eine 0 gesendet (Z.17). Damit wird die Schleife nie betreten.
Wie bereits beschrieben wird ein weiterer Integer gesendet, der dem Empfänger mitteilt, ob noch Bytes gesendet werden. Eine 0 wird also nur gesendet, wenn die Schleife beendet ist, somit alle Bytes gesendet sind, und das Programm in Zeile 17 angelangt ist. Darüber wird dann die Schleife beim Empfänger beendet (Z.12).
Aber wieso kommt keine 0 an? Ich habe über System.out.println(bytesSended); getestet, ob irgendwann mal eine 0 ankommt, aber es kommt lediglich durchgängig 1 an, somit werden weitere bytes erwartet, da diese nicht gesendet werden, bleibt das Programm hängen. Die Datei ist letztlich komplett, doch kann ich keine mehreren Dateien verschicken und die Verbindung wird auch nicht geschlossen. Ein Abbruch ist nur über den Task-Manager möglich.

Wahrscheinlich wird das irgendein dummer Fehler sein, auf den ich seit 2 Tagen nicht komme.
Ich hoffe, mir kann jemand helfen.

Mit freundlichen Grüßen
Morgyr

 

[Morgyr]

Hat keiner eine Idee?
Oder hatte nur noch keiner die Zeit/Lust sich das anzugucken?

Mit freundlichen Grüßen
Morgyr

 

[KSG9|sebastian]

Warum machst du das überhaupt so kompliziert?

Die einfachste Variante wäre wohl folgende:

Client-Seite (Empfänger der Datei):

- Verbindung zum Server aufbauen
- am InputStream byte-für-byte lesen

Server-Seite (Sender der Datei)

- an nem Port hören (ServerSocket)
- sobald ne Verbindung besteht nen neuen Thread mit dem Socket aufmachen und im Thread die zu sendende Datei Byte-für-Byte übertragen

Sieht dann so aus:

Client:

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.Socket;

public class Client {
	public static void main(String[] args) throws Exception{
		Socket socket = new Socket("localhost", 5511);
		InputStream input = socket.getInputStream();
		File outputFile = new File("C:\\file_received.zip");
		if(outputFile.exists()){
			outputFile.delete();
		}
		FileOutputStream output = new FileOutputStream(outputFile);
		
		byte[] buffer = new byte[1024];
		int len = -1;
		
		while((len = input.read(buffer)) != -1){
			output.write(buffer, 0, len);
		}
		output.flush();
		output.close();
		input.close();
		socket.close();
	}
}

Server

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
	public static void main(String[] args) throws Exception {
		ServerSocket serverSocket = new ServerSocket(5511);
		Socket socket = null;
		while (true) {
			socket = serverSocket.accept();
			ServerRunner runner = new ServerRunner(socket);
			new Thread(runner).start();
		}
	}

	static class ServerRunner implements Runnable {
		private Socket clientSocket;

		public ServerRunner(Socket clientSocket) {
			this.clientSocket = clientSocket;
		}

		public void run() {
			try {
				OutputStream output = clientSocket.getOutputStream();
				// hier den InputStream der zu senden Datei holen
				InputStream input = Server.class
						.getResourceAsStream("testSend.zip");
				byte[] buffer = new byte[1024];
				int len = -1;
				while ((len = input.read(buffer)) != -1) {
					output.write(buffer, 0, len);
				}
				output.flush();
				output.close();
				clientSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Gruß Sebastian

 

[Morgyr]

Okay. Dank dir. Habe es jetzt nach einigen, leider unmotivierten, Tagen geschafft, das ganze mit Dateinamen zu verschicken und insgesamt auch mehrere Dateien zu verschicken.

Warum machst du das überhaupt so kompliziert?

Weil ich immer dachte, dass ein read()-Befehl nunmal blockend ist und ich 1. nicht die dokumentation richtig gelesen habe, und somit nicht wusste, dass der Stream bei -1 gestoppt ist, und 2. nicht wusste, dass ich bei output.close() diese -1 mitschicke.

Gibt es eine Lösung, mehrere Dateien zu verschicken, ohne für jede neue Datei ein neue Verbindung zu öffnen? Wenn ich den Stream schließe, kann ich über die selber Verbindung keinen neuen Öffnen. Da ich in aber schließen müsste, damit der Empfänger nicht in der while()-Schleife hängen bleibt, blieb mir erstmal nichts anderes übrig, als pro Datei eine Verbindung einzugehen.

Und noch eine kurze, allgemeine Frage. Ist die Blockierung von accept() und read() von der Zeit her unbegrenzt, oder wird es irgendwann nach x-Sekunden zu einem Abbruch kommen, wenn in dieser Zeit nichts zu lesen ist?


Danke an alle die mir soweit schonmal geholfen haben.

Mit freundlichen Grüßen
Morgyr