# Rmi Dateiabruf von Server



## itstata (16. Apr 2008)

Hallo,
ich möchte gerne über RMI von einem Server eine Datei an den Client senden lassen. Ich Benutze Rmi, weil ich später über HTTP Tunneln möchte. Hier im Forum habe ich gelesen, dass man dies am einfachsten mit einem byte-array macht. Das hat soweit auch funktioniert, allerdings kann man nur Dateien mit begrenzter Größe versenden.
Daher meine Frage: Wo wäre ein einfacher Weg um die Datei an den Client zu senden. Meine Notlösung wäre ansonsten, dass ich die Datei in einzelne arrays aufsplitte. ich gehe davon aus, dass java hierfür eine methode bereitstellt.

so sieht der Code momentan aus. Die Methode liegt auf dem Server und liefert das Ergebnis an den Client zurück.es handelt sich dabei erstmal nur um tests.


```
public byte[] getFile() throws RemoteException, IOException,
		UnsupportedEncodingException, Exception {
	try {
		File file = new File("C:\\temp\\test2.zip");
		FileInputStream fileInputStream = new FileInputStream(file);
		byte[] data = new byte[(int) file.length()];
		fileInputStream.read(data);
		fileInputStream.close();
		System.out.println("Datei gelesen " + file.length());
		return data;
	} catch (Exception e) {
		System.out.println(e.getMessage());
		return null;
	}
}
```

ich hoffe jemand hat eine idee?


----------



## Niki (16. Apr 2008)

Am einfachsten ist du schreibst drei Methoden: openFile, readFromFile, closeFile:


Zunächst einmal brauchst du ein WrapperObject

```
public class ByteBuffer implements Serializable{
  private int length = -1;
  private byte[] bytes = null;

  //getter/setter

}
```


```
//irgendwo ein FileInputStream attribut....
private FileInputStream fis = null;

public void openFile(String name) throws RemoteException{
  File f = new File(name);
  try{
    fis = new FileInputStream(f);
  }catch(IOException ex){
    //Exception an Client weiter werfen...
    throw new RemoteException("Datei konnte nicht geöffnet werden", ex);
  }
}

public ByteBuffer readBytes() throws RemoteException{
  //10k Blöcke
  byte[] b = new byte[10 * 1024]
  ByteBuffer bb = new ByteBuffer();
  try
    int length = fis.read(b);
    bb.setLength(length);
    bb.setBytes(b);
  }catch(IOException ex){
    //Exception an Client weiter werfen...
    throw new RemoteException("Datei konnte nicht gelesen werden", ex);
  }
  return bb;
}

public void close() throws RemoteException{
  try
    fis.close();
  }catch(IOException ex){
    //Exception an Client weiter werfen...
    throw new RemoteException("Datei konnte nicht geschlossen werden", ex);
  }
}
```

Am Client schaut das dann so aus:

```
FileOutputStream fos = new ....
//Lookup....
FileDownload fd = ....

fd.openFile("test.txt");
ByteBuffer bb = fd.readBytes();
while(bb.getLength() != -1){
  //mach was mit dem byte-Array. z.B. write....
  fos.write(bb.getBytes(), 0, bb.getLength());
  bb = fd.readBytes();
}
fd.closeFile();
```


----------



## itstata (16. Apr 2008)

Vielen Dank, werd das gleich mal testen :###


Edit-> das scheint geklappt zu haben! Danke! :toll:


----------



## itstata (16. Apr 2008)

eine frage hätte ich da noch, nach welchen kriterien wählt man den buffer? gibt es da tipps für?


----------



## Niki (16. Apr 2008)

Ist eine gute Frage und kann ich dir leider nicht beantworten. Ich nehm gerne 4-10k Blöcke, geht aber sicher auch mit 100k Blöcken. Je nachdem muss er halt die Schleife öfter durchlaufen. Ich würds einmal so sagen, wenn du kleine Dateien sendest, solltest du einen kleinen Buffer nehmen, bei größeren Dateien schon 50 - 100k. Ist aber nur eine Theorie und habe keine Ahnung ob das sinnvoll ist.


----------



## itstata (16. Apr 2008)

ok, macht den braten vielleicht auch nicht mehr fett


----------



## itstata (28. Jul 2008)

ist jetzt zwar schon länger her, aber ich hab ein Verständnisproblem mit dem Wapper. Kann mir jemand erklären, warum man diesen Wrapper überhaupt benötigt? Aus welchem Grund kann Java nicht vom entfernten Objekt den FileinputStream alleine beziehen. Durch den Buffer wird ja praktisch manuell jedes Byte übertragen (bzw. gebuffert).


----------



## SlaterB (28. Jul 2008)

ein Stream ist kein Zauberstab,
ein Stream braucht z.B. eine Verbindung zur Datei im Betriebssystem,
das geht lokal gut, aber natürlich nicht remote,

der Buffer sorgt für den Remote-Zugriff, der Stream bleibt auf dem Server und jeder read-Zugriff wird dort ausgeführt,
die fertigen Bytes übertragen,

das ist auch keine Extraaufwand, 
selbst wenn der Stream selber regeln würde, vom Server- statt vom Client-Dateisystem zu lesen, 
müsste der ja auch jedes Byte einlesen und zum Client übertragen


----------



## itstata (28. Jul 2008)

das hört sich natürlich logisch an. ich kann ja nicht vom client auf die serverdatei direkt zugreifen. danke


----------

