From 3914fae45d23a81ca13482eadf880c8e38a867e7 Mon Sep 17 00:00:00 2001 From: eichehome Date: Sun, 16 May 2021 00:43:36 +0200 Subject: [PATCH] =?UTF-8?q?JavaDoc=20=C3=BCberall=20eingef=C3=BCgt.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/server/ClientPushMessageThread.java | 27 +++-- src/server/ClientReciveMessageThread.java | 26 +++-- src/server/ClientStore.java | 127 +++++++++------------- src/server/MainServer.java | 45 ++++---- src/utils/Client.java | 25 ++++- 5 files changed, 135 insertions(+), 115 deletions(-) diff --git a/src/server/ClientPushMessageThread.java b/src/server/ClientPushMessageThread.java index 5d48848..2058154 100644 --- a/src/server/ClientPushMessageThread.java +++ b/src/server/ClientPushMessageThread.java @@ -20,10 +20,13 @@ import java.io.EOFException; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.util.logging.Level; +import java.util.logging.Logger; import utils.Message; /** - * + * Diese Klasse stellt einen Thread dar, die Nachrichten, die er in einem Stream erhällt an einen Client weiterleitet. + * * @author eichehome */ public class ClientPushMessageThread extends Thread { @@ -32,6 +35,9 @@ public class ClientPushMessageThread extends Thread { private final ObjectInputStream pipedObjectInputStream; private ClientStore clientStore; + /** + * Haupt methode der Threads, in der alles abläuft. + */ public void run() { boolean continueLoop = true; while (continueLoop) { @@ -40,22 +46,29 @@ public class ClientPushMessageThread extends Thread { while ((empfangen = (Message) this.pipedObjectInputStream.readObject()) != null) { this.out.writeObject(empfangen); this.out.flush(); + Logger.getLogger(ClientPushMessageThread.class.getName()).log(Level.INFO, String.format("Pushing Thread %d: Nachricht weitergegeben", this.getId())); } } catch (ClassNotFoundException ex) { - System.err.println("Thread push " + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientPushMessageThread.class.getName()).log(Level.SEVERE, String.format("Pushing Thread %d: Fehler: %s", this.getId(), ex)); } catch (EOFException ex) { - System.err.println("Thread push " + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientPushMessageThread.class.getName()).log(Level.SEVERE, String.format("Pushing Thread %d: Fehler: %s", this.getId(), ex)); continueLoop = false; - clientStore.removeClientByPusher(this); + clientStore.close(this); + clientStore.removeClient(this); } catch (IOException ex) { - System.err.println("Thread push" + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientPushMessageThread.class.getName()).log(Level.INFO, String.format("Pushing Thread %d: Pipe wurde beendet", this.getId())); + clientStore.removeClient(this); continueLoop = false; - clientStore.removeClientByPusher(this); - System.out.println("Thread recive " + this.getId() + ": Pipe wurde beendet"); } } } + /** + * Konstruktor + * @param out Stream, in dem der Thread die Nachrichten an den Client schickt. + * @param pipedObjectInputStream Stream, in dem der Thread die Nachrichten von anderen Threads erhält. + * @param clientStore Zeiger auf das zentrale Verzeichnis der Clients, um sich dort austragen zu können. + */ public ClientPushMessageThread(ObjectOutputStream out, ObjectInputStream pipedObjectInputStream, ClientStore clientStore) { this.out = out; this.pipedObjectInputStream = pipedObjectInputStream; diff --git a/src/server/ClientReciveMessageThread.java b/src/server/ClientReciveMessageThread.java index 0654f53..df5b701 100644 --- a/src/server/ClientReciveMessageThread.java +++ b/src/server/ClientReciveMessageThread.java @@ -20,10 +20,13 @@ import java.io.EOFException; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.util.logging.Level; +import java.util.logging.Logger; import utils.Message; /** - * + * Diese Klasse stellt einen Thread dar, der auf Nachrichten eines Clients lauscht und diese dann weiter gibt. + * * @author eichehome */ public class ClientReciveMessageThread extends Thread { @@ -31,33 +34,40 @@ public class ClientReciveMessageThread extends Thread { private ClientStore clientStore; private final ObjectInputStream in; + /** + * Hauptmethode des Threads, in der alles abläuft. + */ public void run() { - System.out.println("Thread" + this.getId() + ": Gestartet"); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.INFO, String.format("Reciveing Thread %d: Gestartet", this.getId())); boolean continueLoop = true; while (continueLoop) { try { Message empfangen = null; while ((empfangen = (Message) this.in.readObject()) != null) { - System.out.println("Thread" + this.getId() + ": Client: " + empfangen.getMessage() + " from: " + empfangen.getUsername()); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.INFO, String.format("Reciveing Thread %d: Time: %s Client: %s Message: %s", this.getId(), empfangen.getTime(), empfangen.getUsername(), empfangen.getUsername())); for (ObjectOutputStream stream : clientStore.getAllOutputStreams()) { stream.writeObject(empfangen); stream.flush(); - System.out.println("Weitergeleitet"); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.INFO, String.format("Reciveing Thread %d: Weitergeleitet", this.getId())); } } } catch (ClassNotFoundException ex) { - System.err.println("Thread recive " + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.SEVERE, String.format("Reciveing Thread %d: Fehler: %s", this.getId(), ex)); } catch (EOFException ex) { - System.err.println("Thread recive " + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.INFO, String.format("Reciveing Thread %d: Socket wurde beendet", this.getId())); continueLoop = false; - System.out.println("Thread push " + this.getId() + ": Socket wurde beendet"); } catch (IOException ex) { - System.err.println("Thread recive " + this.getId() + ": Fehler: " + ex); + Logger.getLogger(ClientReciveMessageThread.class.getName()).log(Level.SEVERE, String.format("Reciveing Thread %d: Fehler: %s", this.getId(), ex)); continueLoop = false; } } } + /** + * Konstruktor + * @param in Stream, in dem die Nachrichten eines Clients ankommen. + * @param clientStore Zeiger auf das zentrale Verzeichnis der Clients, um alle benachrichtigen zu können. + */ public ClientReciveMessageThread(ObjectInputStream in, ClientStore clientStore) { this.in = in; this.clientStore = clientStore; diff --git a/src/server/ClientStore.java b/src/server/ClientStore.java index 6ca7c75..c971a75 100644 --- a/src/server/ClientStore.java +++ b/src/server/ClientStore.java @@ -16,35 +16,46 @@ */ package server; +import java.io.IOException; import java.io.ObjectOutputStream; +import java.util.logging.Logger; +import java.util.logging.Level; import utils.Client; /** - * + * Diese Klasse Stellt das zentrale Verzeichniss aller Clients dar. + * * @author eichehome */ public class ClientStore { - + private Client[] clients = null; - + + /** + * Diese Funktion fügt einen Client dem Verzeichniss aller Clients hinzu, die Verbunden sind. + * @param newClient Der neue Client, der hinzugefügt werden soll. + */ public void addClient(Client newClient) { if (this.clients != null) { - System.out.println("Weiterer Durchlauf"); - Client [] temp = new Client [this.clients.length + 1]; + Client[] temp = new Client[this.clients.length + 1]; System.arraycopy(clients, 0, temp, 0, clients.length); temp[temp.length - 1] = newClient; - System.out.println(newClient.getPusher() + "/" + newClient.getReciver() + "/" + newClient.getOutputStream()); this.clients = temp; } else { - System.out.println("Erser Durchlauf"); Client[] temp = new Client[1]; temp[0] = newClient; this.clients = temp; } - printAll(); + Logger.getLogger(ClientStore.class.getName()).log(Level.INFO, "ClientStore: Client hinzugefügt"); } - - public Client removeClientByPusher(Thread pusher) throws IllegalArgumentException { + + /** + * Dies Funktion entfernt einen Client aus dem Verzeichnis aller verbundenen Clients. + * @param pusher Der Pusher-Thread des Clients, welcher aus dem Verzeichnis entfernt werden soll. + * @return Gibt die zu dem Client gehörenden Streams und Threads zurück. + * @throws IllegalArgumentException Falls der Thread nicht existiert oder keine Clients vorhanden sind, wird eine Exeption mit der passenden Fehlermeldung geworfen. + */ + public Client removeClient(Thread pusher) throws IllegalArgumentException { if (this.clients != null) { int index = -1; for (int i = 0; i < this.clients.length; i++) { @@ -63,34 +74,7 @@ public class ClientStore { } Client result = this.clients[index]; this.clients = temp; - return result; - } else { - throw new IllegalArgumentException("Element not found" + index); - } - } else { - throw new IllegalArgumentException("No clients present"); - } - } - - public Client removeClientByReciver(Thread reciver) throws IllegalArgumentException { - if (this.clients != null) { - int index = -1; - for (int i = 0; i < this.clients.length; i++) { - if (this.clients[i].getReciver().equals(reciver)) { - index = i; - break; - } - } - if (index != -1) { - Client[] temp = new Client[this.clients.length - 1]; - for (int i = 0; i < index; i++) { - temp[i] = this.clients[i]; - } - for (int i = (index + 1); i < this.clients.length; i++) { - temp[i - 1] = this.clients[i]; - } - Client result = this.clients[index]; - this.clients = temp; + Logger.getLogger(ClientStore.class.getName()).log(Level.INFO, "ClientStore: Client gelöscht"); return result; } else { throw new IllegalArgumentException("Element not found"); @@ -99,50 +83,45 @@ public class ClientStore { throw new IllegalArgumentException("No clients present"); } } - - public Client removeClientByOutputStream(ObjectOutputStream out) throws IllegalArgumentException { - if (this.clients != null) { - int index = -1; - for (int i = 0; i < this.clients.length; i++) { - if (this.clients[i].getOutputStream().equals(out)) { - index = i; - } - } - if (index != -1) { - Client[] temp = new Client[this.clients.length - 1]; - for (int i = 0; i < index; i++) { - temp[i] = this.clients[i]; - } - for (int i = (index + 1); i < this.clients.length; i++) { - temp[i - 1] = this.clients[i]; - } - Client result = this.clients[index]; - this.clients = temp; - return result; - } else { - throw new IllegalArgumentException("Element not found"); - } - } else { - throw new IllegalArgumentException("No clients present"); - } - } - + + /** + * Diese Funktion gibt alle Streams zu den Clients zurück, die derzeit Verbunden sind. + * @return Ein Array aus allen Streams + */ public ObjectOutputStream[] getAllOutputStreams() { ObjectOutputStream[] streams = new ObjectOutputStream[this.clients.length]; for (int i = 0; i < this.clients.length; i++) { streams[i] = this.clients[i].getOutputStream(); } + Logger.getLogger(ClientStore.class.getName()).log(Level.INFO, "ClientStore: Alle Streams zusammengesucht"); return streams; } - public - - private void printAll() { - for (int i = 0; i < clients.length; i++) { - System.out.println("ClientStore" + i + ": " + clients[i].getPusher()); - System.out.println("ClientStore" + i + ": " + clients[i].getReciver()); - System.out.println("ClientStore" + i + ": " + clients[i].getOutputStream()); + /** + * Schließt den zu einem Thread gehörenden OutputStream + * @param thread Der Thread, dessen OutputStream geschlossen werden soll + * @throws IllegalArgumentException Falls der Thread nicht existiert oder keine Clients vorhanden sind, wird eine Exeption mit der passenden Fehlermeldung geworfen. + */ + public void close(Thread thread) throws IllegalArgumentException{ + if (this.clients != null) { + int index = -1; + for (int i = 0; i < this.clients.length; i++) { + if (clients[i].getPusher().equals(thread)) { + index = i; + } + } + if (index != -1) { + try { + this.clients[index].getOutputStream().close(); + } catch (IOException ex) { + Logger.getLogger(ClientStore.class.getName()).log(Level.SEVERE, String.format("ClientStore: Fehler: %s", ex)); + } + } else { + throw new IllegalArgumentException("Element not found"); + } + } else { + throw new IllegalArgumentException("No Clients Present"); } } - + } diff --git a/src/server/MainServer.java b/src/server/MainServer.java index 522af15..1890070 100644 --- a/src/server/MainServer.java +++ b/src/server/MainServer.java @@ -16,17 +16,14 @@ */ package server; -import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; -import java.io.PipedReader; -import java.io.PipedWriter; -import java.lang.invoke.MethodHandles; import java.net.*; +import java.util.logging.Level; +import java.util.logging.Logger; import utils.Client; -import utils.FifoPipe; /** * Hauptklasse des Servers @@ -37,45 +34,43 @@ import utils.FifoPipe; public class MainServer { /** + * Einstiegsklasse des Servers. Diese wartet auf Anfragen der Clients und erstellt dann die nötigen Resourcen (Streams und Threads). * @param args the command line arguments */ public static void main(String[] args) { - boolean continueLoop = true; try (ServerSocket serverSocket = new ServerSocket(1236)) { ClientStore clientStore = new ClientStore(); - while (continueLoop) { - System.out.println("Warte auf Clients"); + while (true) { + Logger.getLogger(MainServer.class.getName()).log(Level.INFO, String.format("Main: Warte auf Clients")); Socket client = serverSocket.accept(); - System.out.println("client connected"); - + Logger.getLogger(MainServer.class.getName()).log(Level.INFO, String.format("Main: Client verbunden")); + PipedOutputStream pipedOutputStream = new PipedOutputStream(); PipedInputStream pipedInputStream = new PipedInputStream(pipedOutputStream); - + ObjectOutputStream pipedObjectOutputStream = new ObjectOutputStream(pipedOutputStream); ObjectInputStream pipedObjectInputStream = new ObjectInputStream(pipedInputStream); - + ObjectInputStream in = new ObjectInputStream(client.getInputStream()); ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream()); - - System.out.println("Streams created"); - + + Logger.getLogger(MainServer.class.getName()).log(Level.INFO, String.format("Main: Streams erstellt")); + Thread threadRecive = new ClientReciveMessageThread(in, clientStore); Thread threadPush = new ClientPushMessageThread(out, pipedObjectInputStream, clientStore); - - System.out.println("Threads created"); - + + Logger.getLogger(MainServer.class.getName()).log(Level.INFO, String.format("Main: Threads erstellt")); + threadPush.start(); threadRecive.start(); + + Logger.getLogger(MainServer.class.getName()).log(Level.INFO, String.format("Main: Threads gestartet")); - System.out.println("Threads started"); - - Client client = new Client(pipedObjectOutputStream, threadPush, threadRecive); - System.out.println(client.getPusher() + "/" + client.getReciver() + "/" + client.getOutputStream()); - clientStore.addClient(client); - + clientStore.addClient(new Client(pipedObjectOutputStream, threadPush, threadRecive)); + } } catch (Exception ex) { - System.err.println("Fehler: " + ex); + Logger.getLogger(MainServer.class.getName()).log(Level.SEVERE, String.format("Main: Fehler: %s", ex)); } } diff --git a/src/utils/Client.java b/src/utils/Client.java index 376059d..3b18770 100644 --- a/src/utils/Client.java +++ b/src/utils/Client.java @@ -20,7 +20,8 @@ import java.io.IOException; import java.io.ObjectOutputStream; /** - * + * Dies Klasse stellt einen Client mit seinen Streams dar. + * * @author eichehome */ public class Client { @@ -29,12 +30,22 @@ public class Client { private final Thread pusher; private final Thread reciver; + /** + * Konstruktor + * @param out Stream, um diesem Client Nachrichten schicken zu können. + * @param pusher Zeiger auf den Thread, der die Nachrichten an den Client sendet. + * @param reciver Zeiger auf den Thread, der die Nachrichten eines Clients empfängt. + */ public Client(ObjectOutputStream out, Thread pusher, Thread reciver) { this.out = out; this.pusher = pusher; this.reciver = reciver; } + /** + * Schreibe eine Nachricht in den OutputStream dieses Clients. + * @param message Die zu verschickende Nachricht. + */ public void writeMessage(Message message) { try { this.out.writeObject(message); @@ -43,14 +54,26 @@ public class Client { } } + /** + * Getter für den OutputStream diese Clients + * @return Zeiger auf den Stream. + */ public ObjectOutputStream getOutputStream() { return this.out; } + /** + * Getter für den Thread, der Nachrichten an diesen Client sendet. + * @return Zeiger auf den Thread. + */ public Thread getPusher() { return this.pusher; } + /** + * Getter für den Thread, der Nchrichten an diesen Client sendet. + * @return Zeiger auf den Thread. + */ public Thread getReciver() { return this.reciver; }