# Datei übertragen ja String + datei übertragen nein



## java66 (5. Jan 2010)

Hallo zusammen habe folgendes problem
ich verschicke ein file in einem netzwerk.
Cliend sendet datei zum server, server soll daraufhin eine meldung zurückgeben erhalten.

client->sende einen String an server
server->verarbeitet erhaltenen String vom client
client ->sende ein File
server->empfange File vom client
server->sende einen String an client

Nur die datei verschicken klappt bei mir ja aber einen String und danach das File das funktioniert nicht vileicht hat jemand mal kurz zeit und kann mal schauen was ich falsch mache 
Danke euch.
Main des Clients

```
import java.io.File;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ClientMain 
{
 public static void main(String[] args) 
 {
  File file = new File("c:/test3.txt");
  Client client = new Client("localhost", 4711,file);
  client.start.start();
 }
}
```

Client Klasse

```
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;


	public class Client implements Runnable {
		 
        String serverName;
        Thread start=new Thread(this);
        File file;
        int port;
        Socket socket;
        String fileName;
    	InputStream is=null;
    	OutputStream os=null;
        public Client(String serverName, int port, File file) 
        {
            this.serverName = serverName;
            this.port = port;
            this.file = file;
        }
 
        private void sendInformation(String FileName,String Type)
        {
        	try {
				DataOutputStream outstream=new DataOutputStream(socket.getOutputStream());
				outstream.writeUTF(FileName+","+Type);
				outstream.flush();
				outstream.close();
			} catch (IOException e) {
				System.out.println("Send Information Fehler");
				e.printStackTrace();
			}
        	
        }
        private void send(File file)
		{
        	if(socket==null)System.out.println("send(File) socket==null");

			try 
			{
				os = socket.getOutputStream();
			} catch (IOException e1) {System.out.println("os init in sendFile"); e1.printStackTrace();}
			
			
        	System.out.println("Datei wird gesendet");
        	byte[] buffer = new byte[16384];
		
		 
		 try 
		 {
			 is = new FileInputStream(this.file);
	      while (is.available() > 0) 
          {
           os.write(buffer, 0, is.read(buffer));
          }
          os.flush();
          System.out.println("Datei gesendet");
		 } 
		 catch (FileNotFoundException e) {System.out.println("FILENOTFOUND in sendFile");e.printStackTrace();} 
		 catch (IOException e) {System.out.println("IO in sendFile");e.printStackTrace();}
		 
		 finally
		 {
		  try 
		  {
		   is.close();
		  } 
		  catch (IOException e) {e.printStackTrace();}
		 }
		}
		public void disconnect()
		{
          try {
			os.close();
			socket.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
        public void run() {
            try {
            	//verbindungsaufbau
               socket = new Socket(this.serverName, this.port);
                if(socket.isConnected())
                {
                	System.out.println("Berbunden zu.."+socket.getRemoteSocketAddress());
                }
                File file = new File("c:/"+fileName);
                System.out.println("Starte übertragung der Datei...."+file.getName());
                sendInformation("Filename.sql","someInformation");
                send(file);
               }  catch (IOException e) {e.printStackTrace();}
        } 
    }
```

ServerMain
	
	
	
	





```
import java.io.File;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;

	public class ServerMain 
	{
	 public static void main(String[] args) 
	 {
	  File file = new File("c:/new.txt");
	  Server server = new Server(file, 4711);
	  server.serverThread.start();
	 }
	}
```

Server Klasse

```
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Server implements Runnable 
{
 File file;
 final int port;
 Thread serverThread=new Thread(this);
 Socket socket ;
 public Server(File file, int port) 
 {
  this.file = file;
  this.port = port;
 }
 public void initInformation()
 {
	 try 
	 {
		DataInputStream is=new DataInputStream(socket.getInputStream());
		String information=is.readUTF();
		System.out.println(information);
		
	} catch (IOException e) {System.out.println("initInformation failed");e.printStackTrace();}
	 
 }
 public void run() 
 {
  try 
  {
   System.out.println(getClass() + " run Server...");
   ServerSocket serverSocket = new ServerSocket(this.port);
   System.out.println("Warte auf Verbindung...........");
   socket= serverSocket.accept();
   System.out.println("Verbindung hergestellt");
   System.out.println("Initialisiere informationen....");
   initInformation();
   System.out.println(getClass() + " Verbunden hat sich: "
                      + socket.getRemoteSocketAddress());
   
   System.out.println(getClass() + " empfange Datei... " + file);
   OutputStream outputStream = new FileOutputStream(file);
   InputStream inputStream = socket.getInputStream();
   byte[] buffer = new byte[16384];
   int len = 0;
   while ((len = inputStream.read(buffer)) > 0) {
	   outputStream.write(buffer, 0, len);
 }

   System.out.println(getClass() + " Datei empfangen....100%");
   inputStream.close();
   outputStream.close();
//   socket.close();
  } 
  catch (IOException e) {e.printStackTrace();}
  }
 }
```


----------



## java66 (5. Jan 2010)

ok es klappt allerdings bekomme ich eine meldung das die connecion resettet wurde


----------



## SlaterB (5. Jan 2010)

kommt die Meldung erst nach dem Senden oder wie past das reset zu 'es klappt'?

wenn du im Client den DataOutputStream schließt, dann kann danach nichts mehr gesendet werden, die Verbindung ist mindestens halbtot,
generell auf SocketStreams oder sonstige Verknüpfungen immer nur genau einen Stream drüber initialisieren und diesen genau so lange offen halten, wie die gesamte Verbindung steht,

verschiedene Daten senden ist dann nicht leicht, das verstehe ich schon,
aber in diesem Fall kann doch ein DataStream auch byte-Array schreiben und lesen, oder?


----------



## java66 (5. Jan 2010)

Hi Slater

ja die Meldung kommt nachdem alles vorbei ist.
Habe hier die neuere fassung "funktioniert auch so" bis auf die tatsache das er am ende stets einen reset macht.
Bin wie gesagt seit kurzer zeit im bereich sockets wäre dankbar wenn du dir die anhänge mal anschauen bzw. ausführen könntest um vileicht eine aussage zur meldung machen zu können.



```
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Client implements Runnable {

	String serverName;
	String FileName="deafult";
	Thread start = new Thread(this);
	File file;
	int port;
	Socket socket;
	String fileName;
	InputStream is = null;
	OutputStream os = null;
	DataOutputStream outstream=null ;
	DataInputStream dos=null;
	// -----------------------------------------------------------
	public Client(String serverName, int port, File file) {
		this.serverName = serverName;
		this.port = port;
		this.file = file;
	}

	// -----------------------------------------------------------
	private void sendInformation(String FileName, String Type) {
		try {
			outstream= new DataOutputStream(socket
					.getOutputStream());
			outstream.writeUTF(FileName + "," + Type);
		} catch (IOException e) {
			System.out.println("Send Information Fehler");
			e.printStackTrace();
		}

	}

	// -----------------------------------------------------------
	private void closePorts() {

		try {
			os.close();
			is.close();
			socket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	// -----------------------------------------------------------
	private void send(File file) {
		if (socket == null)
			System.out.println("send(File) socket==null");

		try {
			os = socket.getOutputStream();
		} catch (IOException e1) {
			System.out.println("os init in sendFile");
			e1.printStackTrace();
		}

		System.out.println("Datei wird gesendet");
		byte[] buffer = new byte[16384];

		try {
			is = new FileInputStream(this.file);
			while (is.available() > 0) {
				os.write(buffer, 0, is.read(buffer));
			}
			os.flush();
			System.out.println("Datei gesendet");
		} catch (FileNotFoundException e) {
			System.out.println("FILENOTFOUND in sendFile");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("IO in sendFile");
			e.printStackTrace();
		}

//		finally {
//			try {
////				is.close();
////			} catch (IOException e) {
////				e.printStackTrace();
////			}
////		}
	}
public void getResult()
{
	try 
	{
		dos=new DataInputStream(socket.getInputStream());
		String result = dos.readUTF();
		System.out.println("result");
	}catch (IOException e) {e.printStackTrace();}
	
	
	
}
	// -----------------------------------------------------------
	public void run() {
		try {
			// verbindungsaufbau
			socket = new Socket(this.serverName, this.port);
			if (socket.isConnected()) {
				System.out.println("Verbunden zu.."
						+ socket.getRemoteSocketAddress());
			}
//			this.file = new File("c:/" + fileName);
			System.out.println("Starte übertragung der Datei...."
					+ file.getName());
			sendInformation(this.file.getName(), "CMD");
			send(this.file);
			getResult();

		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
```


```
import java.io.File;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.swing.JFileChooser;


public class ClientMain 
{
 public static void main(String[] args) 
 {
	 JFileChooser choos=new JFileChooser(".");
	 choos.showDialog(null, null);
	 
  File file = choos.getSelectedFile();
  Client client = new Client("localhost", 4711,file);
  client.start.start();
 }
}
```


```
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.StringTokenizer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Server implements Runnable 
{
 File file;
 final int port;
 Thread serverThread=new Thread(this);
 Socket socket ;
 DataOutputStream dos;
 DataInputStream dis;
 String filename="unknown.dat";
 OutputStream outputStream;
 String clientCMD="0";
 InputStream inputStream;
 String basePath="C:"+File.separator;
 public boolean enable=true;
 ServerSocket serversocket;
 public Server(int port) 
 {
  this.port = port;
 }

//-----------------------------------------------------------
 public void initInformation()
 {
	 try 
	 {
		DataInputStream dis=new DataInputStream(socket.getInputStream());
		String information=dis.readUTF();
		StringTokenizer st=new StringTokenizer(information,",");
		this.filename=st.nextToken();
		this.clientCMD=st.nextToken();
		file=new File(basePath+filename);
		System.out.println(information);
		
	} catch (IOException e) {System.out.println("initInformation failed");e.printStackTrace();}
	 
 }
 public void disconnect()
 {
	 
 }

//-----------------------------------------------------------
 public void sendResult(String result)
 {
	try 
	{
		dos=new DataOutputStream(socket.getOutputStream());
		dos.writeUTF(result);
	} 
	catch (IOException e) {e.printStackTrace();}
	
 }
 public boolean RecievFile()
 {
	 byte[] buffer = new byte[16384];
	   int len = 0;
	try 
	{
		while ((len = inputStream.read(buffer)) > 0) 
		   {
			   outputStream.write(buffer, 0, len);
		   }
		return true;
	} catch (IOException e) {System.out.println(e.getMessage());}
	 return false;
 }
//-----------------------------------------------------------
 public void run() 
 {
  try 
  {
   System.out.println(getClass() + " run Server...");
   serversocket = new ServerSocket(this.port);
   while(enable)
   {
   System.out.println("Warte auf Verbindung...........");
   socket= serversocket.accept();
   System.out.println("Verbindung hergestellt");
   System.out.println("Initialisiere informationen....");
   initInformation();
   System.out.println(getClass() + " Verbunden hat sich: "
                      + socket.getRemoteSocketAddress());
   
   System.out.println(getClass() + " empfange Datei... " + file);
   outputStream = new FileOutputStream(file);
   inputStream = socket.getInputStream();
   RecievFile();
   //   byte[] buffer = new byte[16384];
//   int len = 0;
//   while ((len = inputStream.read(buffer)) > 0) 
//   {
//	   outputStream.write(buffer, 0, len);
//   }
   System.out.println(getClass() + " Datei empfangen....100%");
   sendResult("TEST WURDE ERFOLGREICH AUSGEFÜHRT");
   }
   disconnect();
  } 
  catch (IOException e) {e.printStackTrace();}
  }
 }
```


```
import java.io.File;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;

	public class ServerMain 
	{
	 public static void main(String[] args) 
	 {
	  Server server = new Server(4711);
	  server.serverThread.start();
	 }
	}
```


----------



## SlaterB (5. Jan 2010)

ich bleibe noch bei den Streams:
auch wennn du nun die DataStreams nicht sofort schließt, 
finde ich es immer noch unsauber, quasi gleichzeitig nebenher direkt in den OutputStream zu schreiben,

ein Stream hat mehrere Zwischenstationen und ein Anfang und ein Ende, da kann man nicht zwischendurch was einschmuggeln oder wieder herausnehmen, 
alles genau am Anfang rein und am Ende raus, 

auch nicht zunächst nur den OutputStream für sich verwenden, bevor dann später ein DataOutputStream drauf kommt und dann 'nur noch' über DataOutputStream,
alles geordnet, alles gleich, die ganze Verbindung, 
am besten in beide Richtungen die gleichen Streams, aber das wär nun nicht so wichtig 

den Rest möchte ich nicht ausprobieren, gibt diverse Varianten, sieht grob ok aus, 
wenn was funktioniert, kann es so schlecht nicht sein


Methoden übrigens klein schreiben
> public boolean RecievFile()


----------



## java66 (5. Jan 2010)

OK danke werde dann mal weiter probieren und versuchen eine bessere lösung für das funktionierende und moeglichkeiten für das nicht funktionierende zu finden.

Danke für deine Tips.
THX


----------

