# ByteBuffer - Client/Server



## aknayirp (8. Mai 2015)

Hey,

ich weiß nicht genau wie ich dir Frage formulieren soll, aber ich versuche es mal so: ich blicke beim ByteBuffer nicht ganz durch. Ok, das war nicht sehr aufschlussreich... 

Also wenn ich mit Sockets arbeite und ein Client-Server Verbindung aufstellen möchte, dann ist es, so weit ich weiß, möglich mit dem ByteBuffer diese Nachrichten umzuwandeln dann mit put() in den Buffer zu tun und abzuschicken. 
Jetzt ist erstmal meine Frage ob das soweit richtig wäre?

Ich verstehe auch nicht wieso man überhaupt ByteBuffer benutzen sollte, da ich doch für Nachrichten z.B. BufferedReader benutzen könnte, oder?

MFG
Aknayirp


----------



## MisterBu (8. Mai 2015)

Die Frage ist was du tun willst? Willst du einen Client oder einen Server programmieren? Falls Client, bist du davon abhängig, was der Server dir anbietet. Es werden in jeden Fall Bytes übertragen. Wenn du die mit einem BufferedReader einliest, interpretierst du die Bytes bereits als ASCII Zeichen und gibst einen Zeichensatz vor.


----------



## aknayirp (8. Mai 2015)

Also ich will erstmal den Client programmieren. Der Server hat auf einer Datenbank Daten gespeichert, z.b. Adressen. Und der Client schickt Anfragen, z.B. alle Adressen an Client schicken, eine Adresse modifizieren, löschen oder neuen Eintrag hinzufügen. 
Also wenn du was anderes meintest mit "Server anbietet", dann sach Bescheid. 

Wenn ich einen Eintrag hinzufügen möchte, dann habe ich ein Objekt von der Klasse Adresse und dieses hat Integer, Strings usw als Variablen, wie würde ich das jetzt per Socket und ByteBuffer senden?

Edit: Vllch sollten wir mal etwas kleiner Anfangen. Wenn ich jetzt einen String habe z.B. "Hallo" oder so. Wie verschicke ich das dann per ByteBuffer? Ich schreibe später mal ein Beispiel rein, wie ich es mir denke.


----------



## InfectedBytes (8. Mai 2015)

Im Grunde musst du nur den String in ein Byte Array umwandeln und in den buffer stecken. Ganz simpel kann es z.B. so aussehen:

```
buffer.put(myString.getBytes());
```
Allerdings musst du bedenken, dass der Empfänger gar nicht weiß wie lang denn der String sein soll. 
Um das zu beheben, kannst du z.B. die Länge des Strings voranstellen:

```
buffer.putInt(myString.length());
buffer.put(myString.getBytes());
```
Der Empfänger kann dann erst einmal die Länge auslesen und anschließend entsprechend viele Bytes für den String. 


Für dich könnte vielleicht auch Google Protocol Buffers interessant sein. 
Man definiert in einer DSL wie denn Nachrichten aussehen und protoc erzeugt daraus Java Code der effizient diese Nachrichten (de-)serialisieren kann.
ProtoBuf


----------



## aknayirp (8. Mai 2015)

Hey, 

danke für deine Hilfe erstmal.

Also den Client habe ich zum Testen erstmal so: 


```
public class App_Client {
	public static void main(String[] args) throws UnknownHostException, IOException {
		String test = "Hallo";
		
		int length;
	
		length = test.getBytes("UTF-8").length;
		ByteBuffer buf = ByteBuffer.allocate(length);
		
		buf.putInt(test.length());
		buf.put(test.getBytes());
		
		Socket s = new Socket("127.0.0.1", 8080);
		InputStream in = s.getInputStream();
		OutputStream out =  s.getOutputStream();
		
		out.write(buf.array());
		
		s.close();
		in.close();
		out.close();
		
	}
}
```

So jetzt habe ich noch versucht den Server zu schreiben, aber bin mir da bei der Vorgehensweise nicht ganz sicher. 
Das sieht grad so aus:


```
public class App_Server {
	public static void main(String[] args) throws IOException{
		ServerSocket s = new ServerSocket(8080);
		
		Socket connection = s.accept();
		
		InputStream in = connection.getInputStream();
		OutputStream out = connection.getOutputStream();
		
		ByteBuffer buf = ByteBuffer.allocate(capacity) // ???
		
		in.read(buf.array()) // ???

		
		in.close();
		out.close();
		s.close();
	}
}
```

Du hast geschrieben ich könnte erstmal die Länge auslesen um dann entsprechen viele Bytes auslesen zu können. 
Aber muss ich nicht vorher den buf allocaten um buf.array() beim in.read() zu benutzen, wie oben dargestellt? Aber woher soll ich vorher die Größe für das allocate wissen?
Reicht dann am Ende ein, buf.getInt(); ?
Danke schonmal,
Ihr seid ne super Hilfe


----------



## InfectedBytes (8. Mai 2015)

Die ersten vier Byte enthalten die Länge des Strings, d.h. du kannst erstmal nur die ersten vier Byte lesen, daraus dann die Textlänge bestimmen und anschließend einen Buffer erstellen der groß genug für den Text ist. 

Häufig dimensioniert man jedoch bereits ein Array vor, welches groß genug ist, um die Daten zu halten. Dies geht natürlich nur, wenn man bereits ne grobe Schätzung hat, wie groß die Daten werden können. 
Du könntest nun z.B. einen 1KB großen Buffer erstellen und erstmal füllen. 
Dann kannst du dir deine Daten aus dem Buffer holen


----------



## aknayirp (9. Mai 2015)

Moin, 

also ich habe noch eine generelle Frage. Wenn ich eine Klasse habe mit mehreren Variablen, die Integer und String beinhalten, kann ich die dann alle in einem Buffer unterbringen? 
Du meintest die ersten 4 Byte geben die Länge des Strings an, aber wenn ich mehrere Strings habe und Integer, ist das dann überhaupt möglich, die in ein ByteBuffer unterzubringen?


----------



## InfectedBytes (9. Mai 2015)

Natürlich, du kannst in dein ByteBuffer reinschreiben was du willst. 
Du kannst mit put solange beliebige Sachen in den Buffer legen, wie dieser noch nicht voll ist. 
Natürlich müssen Sender und Empfänger beide wissen wie so eine Nachricht aufgebaut ist. D.h. sie müssen beide wissen in welcher Reihenfolge die einzelnen Elemente in der Nachricht stehen. 
Angenommen du hast zwei Strings und einen Integer. 
Der Sender legt dann z.B. erst die beiden String (inkl. länge) in den Buffer und danach den int. 
Der Empfänger liest erstmal alles in einen großen Buffer und liest dann zwei Strings aus, und danach den int. 

Falls du mehrere verschiedene Nachrichten hast, sieht das dann noch ein ganz kleines bisschen anders aus.

Aber grundsätzlich würde ich dir schon Google ProtoBuf empfehlen, da all diese Sachen dort schon integriert sind.


----------



## aknayirp (10. Mai 2015)

Yo abend, 

alter, vielen Dank, warst mir bis jetzt echt eine große Hilfe Jetzt blicke ich langsam durch. 
Habe ein Beispiel und dort haben die das mit dem ByteBuffer gemacht und deshalb wollte ich das verstehen und nicht einfach den Google ProtoBuf benutzen. Aber wenn ich mit dem ByteBuffer durch bin, dann zieh ich mir den auch mal rein.

Ich versuche mich jetzt mal mit dem Wissen an eine größere Aufgabe und schreibe nochmal, wenn ich Probleme haben sollte. 

Aber eine Frage habe ich noch, die hat aber nicht unbedingt was mit dem ByteBuffer zu tun. Ich hoffe es ist in Ordnung, wenn ich diese hier kurz stelle und nicht unbedingt einen neuen Thread aufmachen muss. 
Ich möchte mit der Funktion

```
long time = System.currentTimeMillis()
```
, welches ja in einem Long gespeichert ist, die Zeit angeben. Wie funktioniert das genau? Also wenn ich jetzt z.B.

```
System.out.println(TimeUnit.MILLISECONDS.toDays(time));
```

benutze dann berechnet er mir ja die Tage von 1970 bis jetzt, wenn ich mich nicht irre. Aber wie kann ich den heutigen Tag angeben?
Möchte halt in Jahr, Monat usw angeben können. Ist das möglich? Da ich das über den ByteBuffer schicken möchte, wäre long ideal.

Edit: Also für das Jahr könnte ich ja das so schreiben: 


```
System.out.println(TimeUnit.MILLISECONDS.toDays(time)/365+1970);
```

Ist das aber die einzige Möglichkeit oder gibt es einfacherer vorgefertigte Funktionen? Ansonsten könnte ich ja selber Funktionen definieren, die das berechnen für den heutigen Tag usw.


----------



## InfectedBytes (10. Mai 2015)

Mit Java8 ist auch endlich mal eine vernünftige Date/Time API dazu gekommen^^
Falls du also Java8 nutzt, kannst du beispielsweise LocalDate verwenden:

```
LocalDate date = LocalDate.now();
```


----------

