# Outputstream Byte-Array senden



## TX (1. Sep 2010)

Hallo, probiere gerade etwas mit der IO rum.

Client:
- Datei einlesen
- Über Socket senden

Server:
- Über Socket empfangen
- Datei schreiben

Es werden meistens 18Kb oder so übertragen dann
stürzt das Programm mit folgender Meldung ab.

-- Datei gelesen --
-- Datei empfangen --
java.net.SocketException: Software caused connection abort: socket write error
-- Thread Client End --
	at java.net.SocketOutputStream.socketWrite0(Native Method)
	at java.net.SocketOutputStream.socketWrite(Unknown Source)
	at java.net.SocketOutputStream.write(Unknown Source)
	at lesen.ImageReaderClient.readAndSendFile(ImageReaderClient.java:33)
	at lesen.TestFrame$2.run(TestFrame.java:23)
-- Datei geschrieben --
-- Thread Server End --


Ist das Byte Array zuviel auf einmal?
Oder ist meine TestFrame-Klasse mit den Threads unpassend gebaut?
Oder macht localhost Probleme?

TestFrame:

```
package lesen;

import java.util.concurrent.TimeUnit;

public class TestFrame {

	public static void main(String[] args) {
		
		Thread server = new Thread(){
			@Override
			public void run() {
				ImageWriterServer iws = new ImageWriterServer();
				iws.receiveAndWriteFile();
				System.out.println("-- Thread Server End --");
			}
			
		};
		
		Thread client = new Thread(){
			@Override
			public void run() {
				ImageReaderClient irc = new ImageReaderClient();
				irc.readAndSendFile();
				System.out.println("-- Thread Client End --");
			}
			
		};
		
		try {
			
			server.start();
			TimeUnit.SECONDS.sleep(1);
			client.start();
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
```

Client:

```
package lesen;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class ImageReaderClient {
	
	private final static String READFILE= "C:/image.jpg";
	private FileInputStream fis;
	private byte arrayForFile[];
	private Socket csocket;
	
	
	public ImageReaderClient() {
		
		arrayForFile = new byte[515000];
	}
	
	public void readAndSendFile(){
		try {
			fis = new FileInputStream(READFILE);
			int lenght;
			lenght = fis.read(arrayForFile);
			fis.close();
			System.out.println("-- Datei gelesen --");
			
			csocket = new Socket( "localhost", 5000 );
			OutputStream os = csocket.getOutputStream();
			
			os.write(arrayForFile, 0, lenght);
			System.out.println("-- Datei gesendet --");
			
			os.close();
			csocket.close();
			
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
			
		} catch (IOException e) {
	
			e.printStackTrace();
			
		}
		
	}
	
}
```

Server:

```
package lesen;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ImageWriterServer {
	private final static String SAVEFILE= "C:/image2.jpg";
	private FileOutputStream fos;
	private byte arrayForFile[];
	private ServerSocket serverSocket;
	private Socket ssocket;
	
	
	public ImageWriterServer() {
		
		arrayForFile = new byte[515000];
	}
	
	public void receiveAndWriteFile(){
		try {
			int length;
			
			serverSocket = new ServerSocket( 5000 );
			ssocket = serverSocket.accept();
			
			InputStream is = ssocket.getInputStream();
			length = is.read(arrayForFile);
			System.out.println("-- Datei empfangen --");
			
			is.close();
			ssocket.close();
			
			fos = new FileOutputStream(SAVEFILE);
			fos.write(arrayForFile, 0, length);
			fos.close();
			
			System.out.println("-- Datei geschrieben --");
			
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
			
		} catch (IOException e) {
	
			e.printStackTrace();
			
		}
		
	}
}
```


----------



## Marco13 (1. Sep 2010)

Hm. Bei InputStream#read(byte[]) wird nicht notwendigerweise so viel gelesen, wie in den Array passt. Es kann sein, dass bei

```
read = is.read(arrayForFile);
System.out.println("Gelesen: "+read);
```
erstmal "0" ausgegeben wird, oder 153, oder so. Meinem Halbwissen nach muss das in einer Schleife stehen, wie grob diese Struktur hat

```
InputStream is = ...
OutputStream os = ..
byte buffer[] = new byte[8192];
while (true)
{
    int read = is.read(buffer);
    if (read == -1) break;
    os.write(buffer, 0, read);
}
```


----------



## TX (2. Sep 2010)

Jo, du hattest recht.
Habe das erstmal so gelöst, auch wenn ich das noch nicht so elegant finde.


```
package lesen;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ImageWriterServer {
	private final static String SAVEFILE= "C:/image2.jpg";
	private FileOutputStream fos;
	private byte arrayForFile[];
	private ServerSocket serverSocket;
	private Socket ssocket;
	
	
	public ImageWriterServer() {
		
		arrayForFile = new byte[515000];
	}
	
	public void receiveAndWriteFile(){
		try {
			int length = 0;
			int pufferPointer = 0;
			byte puffer[] = new byte[50000];
			
			serverSocket = new ServerSocket( 5000 );
			ssocket = serverSocket.accept();
			
			InputStream is = ssocket.getInputStream();
			while(true){
				length = is.read(puffer);
				if(length==-1){
					break;
				}
				System.out.println("-- Inputstream -- " + length);
				
				for(int i = 0; i < length; i++){
					arrayForFile[pufferPointer + i] = puffer[i];
				}
				pufferPointer += length;
			}
			System.out.println("-- Daten empfangen --");
			
			
			is.close();
			ssocket.close();
			
			fos = new FileOutputStream(SAVEFILE);
			fos.write(arrayForFile, 0, pufferPointer);
			fos.close();
			
			System.out.println("-- Datei geschrieben --");
			
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
			
		} catch (IOException e) {
	
			e.printStackTrace();
			
		}
		
	}
}
```

Außerdem sollte man noch im Testframe mit
client.join();
server.join();
darauf warten, bis sich die Threads beenden.


----------

