Eigenes Protokoll zur Übermittlung von Daten zum Webserver?

[RayYago]

Hallo liebe Forumuser,

es gibt ja verschiedene Protokoll typen wie http etc. Ich habe nun in einem Artikel gelesen das man sowas wie ein costum Protokoll machen kann. Vorteil von sowas soll wohl sein das es deutlich schneller ist.

Was ich gerne machen würde ist: Meine Android App soll mit einem Webserver kommunizieren können. Erstmal wollte ich das mit http Requests umsetzen habe aber dann von den eigenen Protokollen gelesen.

Ein Beispiel was ich gesehen habe:
Field 0:
Byte: 0-32
Type: singed int
Description: Unique number of the packet

Leider versteh ich nicht mal das Beispiel bzw. wie so etwas umgesetzt werden soll. Wie kann ich mir den so ein eigenes Protokoll definieren und es dann an den Webserver schicken?

Ich versteh das leider nicht

Wieso ich das machen möchte? Ich finde es total interessant und möchte gerne Tiefer in die Materie.

Die konkrete Frage wäre nun: Wie definiere ich so ein Protokoll und versende es an den Webserver?

Ich danke jedem schon mal für die Hilfe. Ich lerne gerne aber manchmal fühle ich mich total dumm :|

 

[httpdigest]

Ich habe nun in einem Artikel gelesen das man sowas wie ein costum Protokoll machen kann.

In welchem Artikel genau? Und was meint dieser Artikel genau mit "custom Protokoll"?

Wie dem auch sei:
Punkt eins: Du willst kein eigenes Protokoll entwickeln, sondern HTTP verwenden.
Punkt zwei: siehe Punkt eins.

Ausnahme: Wenn deine App harte Echtzeitanforderungen hat (also sehr geringe Latenz). In diesem Fall kannst du reine TCP oder UDP Sockets verwenden, um beliebige Daten zu übertragen, die dein Webserver (ich würde ihn dann aber nicht mehr Webserver nennen, denn "Web"server suggeriert irgendwie HTTP) dann ausliest.
(Hinweis: HTTP verwendet als Transportschicht ebenfalls TCP)

Mache dich hier aber auf mehrere Monate Arbeit gefasst, um eine Lösung zu implementieren, die tatsächlich eine geringere Latenz hat als HTTP und genauso robust ist.
Kannst ja zum Anfang schon mal diverse Sachen googlen, wie etwa "Java Socket tutorial" oder "Java network programming" etc.

 

[Tarrew]

Mal vorab:
Man kann jetzt nicht pauschal sagen, dass ein eigenes Protokoll schneller ist als irgendein bekanntes. Warum sollte es auch? An deiner Stelle würde ich auch bei etwas bekanntem bleiben.

Wenn du trotzdem irgendwas eigenes machen willst, ist ein Protokoll auch nichts weiter als irgendeine Art der Kommunikation, sodass der Server weiß, was du ihm sendest und damit auch umgehen kann.
Wenn du irgendwelche Daten senden willst, musst du dem Server also eventuell irgendwelche Metadaten über Länge und Art der Daten schicken etc. Das kannst du dir aber alles selbst ausdenken.

Hier mal ein Beispiel:

Spoiler

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Server()).start();

        Thread.sleep(1000);

        new Thread(new Client()).start();
    }
}

class Client implements Runnable {
    @Override
    public void run() {
        try {
            Socket clientSocket = null;

            clientSocket = new Socket("localhost", 45566);

            DataOutputStream outputStream = new DataOutputStream(clientSocket.getOutputStream());
            BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            outputStream.writeBytes("Testnachricht an den Server\n");
            System.out.println("Antwort vom Server: " + reader.readLine());
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Server implements Runnable {
    @Override
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(45566);

            while (true) {
                Socket connectionSocket = serverSocket.accept();
                BufferedReader reader = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
                DataOutputStream outputStream = new DataOutputStream(connectionSocket.getOutputStream());

                String message = reader.readLine();
                System.out.println("Nachricht vom Client: " + message);

                outputStream.writeBytes("Testantwort vom Server\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Verschlüsselung über TLS etc. solltest du natürlich auch noch machen.
Wenn es schneller gehen soll, dann UDP verwenden, dann musste aber selbst drauf achten, dass der Server alle Pakete bekommt.

Also bleib lieber bei irgendwas bekanntem

#Edit: Ups, zu spät. Kann httpdigest nur zustimmen.

 

[RayYago]

In welchem Artikel genau? Und was meint dieser Artikel genau mit "custom Protokoll"?

Wo genau das war weiß ich nicht mehr, das war als ich gerade bei einem Bekannten war. Aber ich habe dannach noch etwas mit ihm geschrieben weil ich das irgendwie nicht verstanden hatte und das war seine Erklärung:

Dein Vorgehen:
1. Du musst den Aufbau deines Protokolls definieren.
Bspw. halt eben:

Field 0:
Byte: 0-32
Type: signed int
Description: Unique number of the packet

Field 1:
Byte: 33-64
Type: signed int
Description: Size of the data array
Stored as: X

Field 2:
Byte: 65-X
Type: bytes / byte array / data
Description: The data [might encrypted]
Stored as: data_field

———

2. Fertigst du eine Liste [bspw. ein Enum] an, welches diese Zahlen vergibt.
Dh. dein 0'tes Packet ist bspw. das "Ping Packet".
# Definition:
PacketNumber: 0 [signed int]
Description: Checks if the host is reachable and reacts on inputs

Das zweite könnte dann bspw. ein Abfrage Packet sein:
# Definition:
PacketNumber: 1 [signed int]
Fields:
- request: String; Name of the object to request
Description: Sends back an 'DataPacket [2]' with the requested packet or an "ErrorPacket [3]"

# DataPacket:
PacketNumber: 2 [signed int]
Fields:
- data: bytes; the requested data
Description: Transpots requested data

# ErrorPacket:
PacketNumber: 3 [signed int]
Fields:
- error_message: String; the error message
Description: Send when an Error occured.

———
3. MUSST du AUCH festlegen, ob ein Packet in beide Richtungen, also S<->C [S=Server, C=Client], oder nur in eine Richtung, also S->C bzw. S<-C, gehen kann.
Kannst theoretisch die Nummern auch auf SC und CS aufteilen, machst dir das leben aber nur schwerer damit (als "beginner").

———
4. Wenn du das hast, musst du den Server schreiben.
'N einfacher SocketServer sollte erstmal reichen.

Wie gehst du nun vor?
A. Zuerst ließt du das erste field aus.
Versuchst das zu 'ner signed int zu konvertieren.
Gelinkt dies nicht -> send Error

B. als nächstes wiederholst du den schritt, ließt diesesmal allerdings das zweite field aus.
[Speichern als X]

C. Nun ließt du einfach X bytes aus und hast die 'data' vom packet.

D. Nun... wird es ein wenig schwieriger.
Da du nun alles hast, was du brauchst [andernfalls wird 'n Fehler zurück geschickt], musst du nun das Packet vernünftig bearbeiten.

Anhand der PacketNumber weißt du nun ob das bspw. das Ping packet ist.
Also Rufst du die klasse "PingPacket" auf und da das ping packet in dem fall keine zusätzlichen fields hat, sendest du das einfach zurück
[-> mehr gleich!]

Wenn das jetzt bspw. das "Abfrage Packet" ist musst du nun noch schauen, dass du 'data' in 'n String umwandelst, die daten irgendwo her nimmst, 'n "DataReturn" aufrufst und zurück sendest.

E. Nun ... kannst du ja nicht einfach die klasse zurück senden.
Du musst jetzt dein neues Packet, also die Antwort, in dein Protokoll umwandeln.
Eigentlich ... genau andersrum:
1. PacketNumber schreiben
2. Data size schreiben
3. Data schreiben

Und dann weg schicken

———
5. nun ... brauchst du den Client.
Wenn das die gleich Sprache ist und du die PacketAPI ordentlich designed hast, kannst du nun einfach 'n SocketClient machen und das ganze nutzen.
Andernfalls musst du das auch noch mal für diese Sprache schreiben.
! GLEICHES VORGEHEN !

Und schon ... hast du ein custom protocol.

-----------------------------
Naja und da dachte ich es wäre vielleicht gut ein eigenes zu machen :|

 

[Tarrew]

Möglich ist das sicher. Aber du schreibst ja schon, dass es um eine Android App geht.

Die paar Millisekunden, die du da vllt. einsparen kannst, sind absolut nicht relevant.
Oder hast du in deiner App irgendeine besondere Anforderung in die Richtung?