Socket Problem mit Objektübertragung

[Spitfire777]

Hi,

ich lese mich im Augenblick in die Netzwerkprogrammierung ein und will mir einen Chat bauen. Dazu sollen nicht einfach nur Strings übertragen werden, sondern Nachrichtenbjekte.

Jetzt habe ich folgende zwei Messageklassen. Haben noch wenig Inhalt, trotzdem soll schon einmal das Senden funktionieren.

public abstract class ServerMessage implements Serializable {
    private long time;

...
}

public class UserMessage extends ServerMessage {
    private String username = null;
    private String text = null;

...

Beide Klassen verwende ich für die Clientanwendung und für die Serveranwendung.

So wird bei mir eine Nachricht vom Server an den Client gesendet:

                    UserMessage message = new UserMessage();
                    message.setTime(System.currentTimeMillis());
                    message.setUsername("Spitfire777");
                    message.setText("Hello World!");

                    oos.writeObject(message);
                    oos.flush();

Und so wird die Nachricht vom Client empfangen:

ServerMessageHandler.handleMessage((ServerMessage) getObjectInputStream().readObject());

Die ServerMessageHandler-Klasse soll schauen, was für eine Art Nachricht gesendet wurde und behandelt dann die Weiterverarbeitung der Nachricht (Anzeige in der GUI o.ä.):

public class ServerMessageHandler {

    public static void handleMessage(ServerMessage sm) {
        if (sm instanceof UserMessage) {
            UserMessage message = (UserMessage) sm;
            System.out.println(message.getUsername() + " sagt: " + message.getText());
        }
        else if (sm instanceof UserInvitationMessage) {
            UserInvitationMessage message = (UserInvitationMessage) sm;
            System.out.println("Es wurde eine Einladung gesendet.");
        }
        else if (sm instanceof AdminMessage) {
            //...
        }
    }

}

Jetzt gehts um den instanceof-Teil. Der Compiler spuckt mir folgenden Fehler aus:

java.lang.ClassNotFoundException: server.UserMessage

Jetzt liegt wohl das Problem an den unterschiedlichen Paketen der Server- und Clientseite.

Wie kann ich das angehen?

 

[SlaterB]

mit Übertragung hat das doch nichts zu tun, schreibe im Client-Programm
> System.out.println(UserMessage.class);
und die Fehlermeldung wird genauso kommen,

jede verwendete Klasse muss bekannt sein, eigentlich logisch oder?
wie programmierst du denn die unterschiedlichen Programme, wie werden sie später gestartet?
am einfachsten wäre, alles in einer Entwicklungsumgebung wie Eclipse in einem Projekt reinzusetzen,

später haben Client und Server, ob als jar oder Dateisystem, dieselben Klassen, nur werden unterschiedliche Programmteile gestartet,
ansonsten gemeinsame Klasse/ jars in CLASSPATH oder so, bei Eclipse Projekte importieren,

 

[Spitfire777]

Hi,

habs mit der serialVersionUID-Konstanten gelöst. Klappt nun.
Jedoch hab ich damit noch nie gearbeitet und deshalb wollte ich fragen, ob es egal ist, was ich dort als Wert eintrage, ich mir da eine Zahl ausdenken soll oder das ganze nach einem Schema funktioniert?

edit: Neues Problem.
Bekomme nun folgende Exception:

java.io.StreamCorruptedException: invalid type code: AC
at java.i😵bjectInputStream.readObject0(ObjectInputStream.java:1356)
at java.i😵bjectInputStream.readObject(ObjectInputStream.java:351)
at com.michaelkunzmann.chat.core.ServerConnection.run(ServerConnection.java:50)
at com.michaelkunzmann.chat.core.Main.main(Main.java:24)

Wird an selber Stelle wie oben geworfen!

 

[SlaterB]

soweit ich weiß ist es egal, an was anderes kann ich mich zumindest nicht erinnern,
es ist nur günstig bei neuen Versionen die Zahl zu ändern, eben um den Unterschied festzustellen

benutze ich aber nicht

 

[ARadauer]

habs mit der serialVersionUID-Konstanten gelöst. Klappt nun.

warum? hast du slaters post gelesen?
ich bin mir zwar auch nicht 100%ig sicher wie das genau abläuft aber ich denke, dass du im moment java was vormogelst im dem du im mit der id sagst das diese klassen die selben sind, obwohl sie es gar nicht sind. darum hast du auch probleme beim lesen. Server und Client müssen die beiden Klassen kennen!

 

[Spitfire777]

Ja, was meint ihr denn genau? Sollen beide Projekte denn auf die selbe Source-Datei zugreifen?

 

[SlaterB]

nein, auf dieselber kompilierte .class-Datei oder ein .jar mit .class drin,
wie man das macht hängt von den Umständen ab, wie gesagt: welche Entwicklungsumgebung, welche Art des Starts,

letztlich gilt immer: die .class-Datei muss bei beiden in den CLASSPATH, aber gibt verschiedene Einstellungen dafür

 

[Spitfire777]

Sorry, dass ich nochmal nerven muss xD

Also hab nun das Server-Projekt mit dem Client-Projekt verknüpft. (=JAR-File hinzugefügt)
Jetzt holt sich NetBeans auch die Klassen von dort.

Trotzdem hat sich die Konsolenausgabe nach wie vor nicht verändert. Scheint somit daran nicht zu liegen.
Meine Chatnachricht wird wie mit der serialVersionUID ausgegeben, die StreamCorruptedException wird immer noch geworfen.

run:
Spitfire777 sagt: Hallo, wie geht es dir?
java.io.StreamCorruptedException: invalid type code: AC
        at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1356)
        at java.io.ObjectInputStream.readObject(ObjectInputStream.java:351)
        at com.michaelkunzmann.chat.client.core.ServerConnection.run(ServerConnection.java:51)
        at com.michaelkunzmann.chat.client.core.Main.main(Main.java:24)
ERSTELLEN ERFOLGREICH (Gesamtzeit: 0 Minuten 0 Sekunden)

 

[SlaterB]

von der Exception höre ich in diesem Thread zum ersten Mal,
bei einem vorherigen Posting hast du editiert, wie ich jetzt sehe,
immer vorsichtig mit solchen Aktionen falls du nicht verschmerzen kannst, dass sie überlesen werden 😉

diese Exception hat nichts mit der Serialisierung, CLASSPATH oder jar zu tun, falls du das dachtest

--------

also 'StreamCorruptedException: invalid type code: AC' kann man sehr gut in google eintippen und findet viele Probleme,
was genau bei dir auch zutrifft weiß ich nicht aber mal allgemein:

ein ObjectStream sieht vereinfacht z.B. so aus:
START-Token, Objekt, ZWISCHEN-Token, Objekt, END-Token

wenn du über einen Stream zweimal ObjektOutputStream öffnest, dann wird vielleicht
START, Objekt, START, Objekt
gesendet, kein END weil du vielleicht das close() vergessen hast,

der Client liest das erste Objekt, und kommt dann zu einem START-Token, was an der Stelle keinen Sinn macht -> Exception,
so in der Art irgendein Problem hast du,
poste bisschen mehr Code von Sender und Empfänger, was wird in welcher Reihenfolge wie oft aufgerufen

für die Exception musst du nichtmal übers Netzwerk gehen, du könntest auch Server + Client in einem Java-Programm laufen lassen, was generell immer ein gute Vereinfachung zum testen ist,
der Server sendet seine Daten, die landen in einem PipedOutputStream, darauf dann einen PipedInputStream öffnen und daraus liest der Client

 

[Spitfire777]

Ah, gut, tut mir Leid. 🙁
Ich weiß nicht, wie das hier im Forum mit Doppelpostings gehandhabt wird, von den Regeln her.

--
So, gut, also ich denke mal, dass ich auf dem richtigen Weg bin.

So sieht nun die Threadklasse aus, der auf die Sendung von Objekten wartet:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.michaelkunzmann.chat.client.core;

import com.michaelkunzmann.chat.server.core.ServerMessage;
import java.net.*;
import java.io.*;

/**
 *
 * @author Spitfire777
 */
public class ServerConnection extends Thread {

    private Socket s = null;

    private InputStream is = null;
    private ObjectInputStream  ois = null;
    private InputStreamReader isr = null;
    private BufferedReader br= null;
    
    private OutputStream os = null;
    private ObjectOutputStream  oos = null;
    private OutputStreamWriter osw = null;
    private BufferedWriter bw = null;

    public ServerConnection(Socket s) {
        setSocket(s);
    }

    public void open() throws IOException {
        setInputStream(s.getInputStream());
        setInputStreamReader(new InputStreamReader(getInputStream()));
        setBufferedReader(new BufferedReader(getInputStreamReader()));
        setObjectInputStream(new ObjectInputStream(getInputStream()));

        setOutputStream(s.getOutputStream());
        setOutputStreamWriter(new OutputStreamWriter(getOutputStream()));
        setBufferedWriter(new BufferedWriter(getOutputStreamWriter()));
        setObjectOutputStream(new ObjectOutputStream(getOutputStream()));
    }

    public void close() throws IOException {
        getInputStream().close();
        getInputStreamReader().close();
        getBufferedReader().close();
        getObjectInputStream().close();

        getOutputStream().close();
        getOutputStreamWriter().close();
        getBufferedWriter().close();
        getObjectOutputStream().close();
    }

    @Override
    public void run() {
        try {
            int i = 0;

            while (s.isConnected()) {
                i++;
                open();
                System.out.println("Streams geöffnet, " + i + "stes Mal");
                ServerMessageHandler.handleMessage((ServerMessage) getObjectInputStream().readObject());
                close();
                System.out.println("Streams geschlossen, " + i + "stes Mal");
            }
        }
        catch (IOException exc) {
            exc.printStackTrace();
        }
        catch (ClassNotFoundException exc) {
            exc.printStackTrace();
        }
    }

    /**
     * @return the s
     */
    public Socket getSocket() {
        return s;
    }

    /**
     * @param s the s to set
     */
    public void setSocket(Socket s) {
        this.s = s;
    }

    /**
     * @return the is
     */
    public InputStream getInputStream() {
        return is;
    }

    /**
     * @param is the is to set
     */
    public void setInputStream(InputStream is) {
        this.is = is;
    }

    /**
     * @return the isr
     */
    public InputStreamReader getInputStreamReader() {
        return isr;
    }

    /**
     * @param isr the isr to set
     */
    public void setInputStreamReader(InputStreamReader isr) {
        this.isr = isr;
    }

    /**
     * @return the br
     */
    public BufferedReader getBufferedReader() {
        return br;
    }

    /**
     * @param br the br to set
     */
    public void setBufferedReader(BufferedReader br) {
        this.br = br;
    }

    /**
     * @return the os
     */
    public OutputStream getOutputStream() {
        return os;
    }

    /**
     * @param os the os to set
     */
    public void setOutputStream(OutputStream os) {
        this.os = os;
    }

    /**
     * @return the osw
     */
    public OutputStreamWriter getOutputStreamWriter() {
        return osw;
    }

    /**
     * @param osw the osw to set
     */
    public void setOutputStreamWriter(OutputStreamWriter osw) {
        this.osw = osw;
    }

    /**
     * @return the bw
     */
    public BufferedWriter getBufferedWriter() {
        return bw;
    }

    /**
     * @param bw the bw to set
     */
    public void setBufferedWriter(BufferedWriter bw) {
        this.bw = bw;
    }

    /**
     * @return the oos
     */
    public ObjectOutputStream getObjectOutputStream() {
        return oos;
    }

    /**
     * @param oos the oos to set
     */
    public void setObjectOutputStream(ObjectOutputStream oos) {
        this.oos = oos;
    }

    /**
     * @return the ois
     */
    public ObjectInputStream getObjectInputStream() {
        return ois;
    }

    /**
     * @param ois the ois to set
     */
    public void setObjectInputStream(ObjectInputStream ois) {
        this.ois = ois;
    }
}

Zur Übersichtlichkeit, wie oft die Schleife durchläuft, hab ich das Ding mit dem Inkrement in die Schleife eingebaut. Und zwar entsteht hier das Problem, wenn das erste Objekt empfangen wurde, dann aber auf das nächste gewartet wird.
Hier ist nun komischerweise mein Socket auf einmal zu.

Konsolenausgabe:

run:
Streams geöffnet, 1stes Mal
Spitfire777 sagt: Hallo, wie geht es dir?
Streams geschlossen, 1stes Mal
java.net.SocketException: Socket is closed
        at java.net.Socket.getInputStream(Socket.java:788)
        at com.michaelkunzmann.chat.client.core.ServerConnection.open(ServerConnection.java:35)
        at com.michaelkunzmann.chat.client.core.ServerConnection.run(ServerConnection.java:65)
        at com.michaelkunzmann.chat.client.core.Main.main(Main.java:23)
ERSTELLEN ERFOLGREICH (Gesamtzeit: 0 Minuten 0 Sekunden)

 

[SlaterB]

das ist ja nicht dieselbe Fehlermeldung wie zuvor,
wenn einmal Streams von einem Socket geschlossen sind, lassen sie sich nicht mehr neu öffnen,
du brauchst neuen ServerSocket.accept()-Socket oder als Client new Socket(adresse,port)

 

[Spitfire777]

Ja, also ich habe jetzt das so rumgewurschtelt, dass direkt die Streams geöffnet werden und nach dem Empfangen geschlossen werden, sodass es evtl. dieses Problem

wenn du über einen Stream zweimal ObjektOutputStream öffnest, dann wird vielleicht
START, Objekt, START, Objekt

lösen könnte.

Siehe open() und close(), das war beides vorher nicht. open() war vorher an einer anderen Stelle ausgeführt.

War das somit richtig gedacht?

das ist ja nicht dieselbe Fehlermeldung wie zuvor,
wenn einmal Streams von einem Socket geschlossen sind, lassen sie sich nicht mehr neu öffnen,
du brauchst neuen ServerSocket.accept()-Socket oder als Client new Socket(adresse,port)

Ich will ja den Socket nicht schließen, er soll ja offen bleiben.

 

[Spitfire777]

Und auf der Serverseite kommt folgende Exception:

java.io.EOFException
        at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281)
        at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2750)
        at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:780)
        at java.io.ObjectInputStream.<init>(ObjectInputStream.java:280)
        at com.michaelkunzmann.chat.server.core.ClientConnection.run(ClientConnection.java:35)

 

[SlaterB]

offener Stream und nicht close() klingt sinnvoll, open() dann auch nur einmal vor der Schleife,
für den Rest ist nach wie vor genaue Kenntnis von Sender, Empfänger (fehlt bisher komplett!), Reihenfolge der Aufrufe usw. nötig

 

[Spitfire777]

offener Stream und nicht close() klingt sinnvoll, open() dann auch nur einmal vor der Schleife

So hatte ichs vorher gehabt. Ich häng am besten mal alle Klassen an.

Server:

Main

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.michaelkunzmann.chat.server.core;

import java.net.*;
import java.io.*;
import java.util.*;

/**
 *
 * @author Spitfire777
 */
public class Main {

    private static Main instance;

    private MainFrame frame = null;
    private Console console = null;

    private ServerSocket server = null;
    private Vector<ClientConnection> connections;


    public static void main(String[] args) {

        try {
            javax.swing.UIManager.setLookAndFeel(javax.swing.UIManager.getSystemLookAndFeelClassName());
        }
        catch (Exception exc) {}
        
        instance = new Main();
        instance.setFrame(new MainFrame());
        instance.getFrame().setVisible(true);
    }

    public Main() {
        console = new Console();
    }

    public static Main get() {
        return instance;
    }

    public MainFrame getMainFrame() {
        return getFrame();
    }

    public Vector getConnections() {
        if (connections == null) {
            connections = new Vector();
        }
        return connections;
    }

    public ClientConnection getConnection(String ip) {

        ClientConnection connection = null;

        for (int i = 0; i < getConnections().size(); i++) {
            if (((ClientConnection) getConnections().get(i)).getSocket().getInetAddress().getHostAddress().equals(ip)) {
                 connection = ((ClientConnection) getConnections().get(i));
            }
        }

        return connection;
    }
    
    public void start() {
        try {
            server = new ServerSocket(1337);
            getConsole().printMessage("Server gestartet.");
            waitForConnections();
        }
        catch (IOException exc) {
            getConsole().printError(exc.getMessage());
        }
    }

    public void waitForConnections() {
        try {
            while (!server.isClosed()) {
                
                Socket s = getServer().accept();

                System.out.println("Verbindungsanfrage von " + s.getInetAddress().getHostAddress());

                if (getConnection(s.getInetAddress().getHostAddress()) == null) {
                    getConsole().printMessage(s.getInetAddress().getHostAddress() + " ist nun verbunden.");
                    
                    ClientConnection currentConnection = new ClientConnection(s);
                    connections.add(currentConnection);
                    currentConnection.start();
                }
                else {
                    getConsole().printError("Verbindungsanfrage von " + s.getInetAddress().getHostAddress() + " abgelehnt. Client bereits verbunden.");
                }
            }
        }
        catch (IOException exc) {
            exc.printStackTrace();
        }
    }

    public void stop() {
        try {
            getServer().close();
        }
        catch (IOException exc) {
            exc.printStackTrace();
        }
    }

    /**
     * @return the console
     */
    public Console getConsole() {
        return console;
    }

    /**
     * @return the server
     */
    public ServerSocket getServer() {
        return server;
    }

    /**
     * @return the frame
     */
    public MainFrame getFrame() {
        return frame;
    }

    /**
     * @param frame the frame to set
     */
    public void setFrame(MainFrame frame) {
        this.frame = frame;
    }
}

ClientConnection

package com.michaelkunzmann.chat.server.core;

import java.net.*;
import java.io.*;

public class ClientConnection extends Thread {
    private Socket socket = null;
    
    private InputStream is = null;
    private ObjectInputStream  ois = null;
    private InputStreamReader isr = null;
    private BufferedReader br= null;

    private OutputStream os = null;
    private ObjectOutputStream  oos = null;
    private OutputStreamWriter osw = null;
    private BufferedWriter bw = null;

    
    public ClientConnection(Socket s) {
        socket = s;
    }

    @Override
    public void run() {

        try {
            while (true) {
                    os = socket.getOutputStream();
                    oos = new ObjectOutputStream(os);
                    osw = new OutputStreamWriter(os);
                    bw = new BufferedWriter(osw);

                    is = socket.getInputStream();
                    ois = new ObjectInputStream(is);
                    isr = new InputStreamReader(is);
                    br = new BufferedReader(isr);

                    System.out.println(UserMessage.class);
                    UserMessage message = new UserMessage();
                    message.setTime(System.currentTimeMillis());
                    message.setUsername("Spitfire777");
                    message.setText("Hallo, wie geht es dir?");

                    System.out.println(message.getClass());
                    oos.writeObject(message);
                    oos.flush();

                    oos.close();
            }
        }
        catch (IOException exc) {
            exc.printStackTrace();
        }
    }

    /**
     * @return the socket
     */
    public Socket getSocket() {
        return socket;
    }

    /**
     * @param socket the socket to set
     */
    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

ServerMessage (vom Client ebenfalls verwendet)

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.michaelkunzmann.chat.server.core;

import java.io.*;

/**
 *
 * @author Spitfire777
 */
public class ServerMessage implements Serializable {
    private long time;

    /**
     * @return the time
     */
    public long getTime() {
        return time;
    }

    /**
     * @param time the time to set
     */
    public void setTime(long time) {
        this.time = time;
    }

}

UserMessage (von Client ebenfalls verwendet)

public class UserMessage extends ServerMessage {
    private String username = null;
    private String text = null;

    /**
     * @return the username
     */
    public String getUsername() {
        return username;
    }

    /**
     * @param username the username to set
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * @return the text
     */
    public String getText() {
        return text;
    }

    /**
     * @param text the text to set
     */
    public void setText(String text) {
        this.text = text;
    }

}

Client:

Main

package com.michaelkunzmann.chat.client.core;

import com.michaelkunzmann.chat.client.gui.*;
import javax.swing.*;

/**
 *
 * @author Spitfire777
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            ServerConnection conn = new ServerConnection(new java.net.Socket("localhost", 1337));
            conn.open();
            conn.run();
        }
        catch (Exception exc) {}
    }

}

ServerConnection:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.michaelkunzmann.chat.client.core;

import com.michaelkunzmann.chat.server.core.ServerMessage;
import java.net.*;
import java.io.*;

/**
 *
 * @author Spitfire777
 */
public class ServerConnection extends Thread {

    private Socket s = null;

    private InputStream is = null;
    private ObjectInputStream  ois = null;
    private InputStreamReader isr = null;
    private BufferedReader br= null;
    
    private OutputStream os = null;
    private ObjectOutputStream  oos = null;
    private OutputStreamWriter osw = null;
    private BufferedWriter bw = null;

    public ServerConnection(Socket s) {
        setSocket(s);
    }

    public void open() throws IOException {
        setInputStream(s.getInputStream());
        setInputStreamReader(new InputStreamReader(getInputStream()));
        setBufferedReader(new BufferedReader(getInputStreamReader()));

        setOutputStream(s.getOutputStream());
        setOutputStreamWriter(new OutputStreamWriter(getOutputStream()));
        setBufferedWriter(new BufferedWriter(getOutputStreamWriter()));
        setObjectOutputStream(new ObjectOutputStream(getOutputStream()));
    }

    public void close() throws IOException {
    }

    @Override
    public void run() {
        try {
            int i = 0;

            while (s.isConnected()) {
                ServerMessageHandler.handleMessage((ServerMessage) getObjectInputStream().readObject());
            }
        }
        catch (IOException exc) {
            exc.printStackTrace();
        }
        catch (ClassNotFoundException exc) {
            exc.printStackTrace();
        }
    }

    /**
     * @return the s
     */
    public Socket getSocket() {
        return s;
    }

    /**
     * @param s the s to set
     */
    public void setSocket(Socket s) {
        this.s = s;
    }

    /**
     * @return the is
     */
    public InputStream getInputStream() {
        return is;
    }

    /**
     * @param is the is to set
     */
    public void setInputStream(InputStream is) {
        this.is = is;
    }

    /**
     * @return the isr
     */
    public InputStreamReader getInputStreamReader() {
        return isr;
    }

    /**
     * @param isr the isr to set
     */
    public void setInputStreamReader(InputStreamReader isr) {
        this.isr = isr;
    }

    /**
     * @return the br
     */
    public BufferedReader getBufferedReader() {
        return br;
    }

    /**
     * @param br the br to set
     */
    public void setBufferedReader(BufferedReader br) {
        this.br = br;
    }

    /**
     * @return the os
     */
    public OutputStream getOutputStream() {
        return os;
    }

    /**
     * @param os the os to set
     */
    public void setOutputStream(OutputStream os) {
        this.os = os;
    }

    /**
     * @return the osw
     */
    public OutputStreamWriter getOutputStreamWriter() {
        return osw;
    }

    /**
     * @param osw the osw to set
     */
    public void setOutputStreamWriter(OutputStreamWriter osw) {
        this.osw = osw;
    }

    /**
     * @return the bw
     */
    public BufferedWriter getBufferedWriter() {
        return bw;
    }

    /**
     * @param bw the bw to set
     */
    public void setBufferedWriter(BufferedWriter bw) {
        this.bw = bw;
    }

    /**
     * @return the oos
     */
    public ObjectOutputStream getObjectOutputStream() {
        return oos;
    }

    /**
     * @param oos the oos to set
     */
    public void setObjectOutputStream(ObjectOutputStream oos) {
        this.oos = oos;
    }

    /**
     * @return the ois
     */
    public ObjectInputStream getObjectInputStream() {
        return ois;
    }

    /**
     * @param ois the ois to set
     */
    public void setObjectInputStream(ObjectInputStream ois) {
        this.ois = ois;
    }
}

ServerMessageHandler

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.michaelkunzmann.chat.client.core;

import com.michaelkunzmann.chat.server.core.ServerMessage;
import com.michaelkunzmann.chat.server.core.UserInvitationMessage;
import com.michaelkunzmann.chat.server.core.UserMessage;

/**
 *
 * @author Spitfire777
 */
public class ServerMessageHandler {

    public static void handleMessage(ServerMessage sm) {
        if (sm instanceof com.michaelkunzmann.chat.server.core.UserMessage) {
            UserMessage message = (UserMessage) sm;
            System.out.println(message.getUsername() + " sagt: " + message.getText());
        }
        else if (sm instanceof UserInvitationMessage) {
            UserInvitationMessage message = (com.michaelkunzmann.chat.server.core.UserInvitationMessage) sm;
            System.out.println("Es wurde eine Einladung gesendet.");
        }
        else if (sm instanceof AdminMessage) {
            //...
        }
    }

}

 

[SlaterB]

Zeile 29-37 von ClientConnection muss vor die Schleife,
Streams immer nur genau einmal öffnen, wobei das close() am Ende der Schleife einen zweiten Durchlauf eh obsolet macht,

was funktioniert denn derzeit nicht? kann grad nicht testen

edit:
ok, vorher hattest du ja eine Fehlermeldung gepostet, die soll es mal sein,
ich sehe noch dass du mehrere Streams gleichzeitig öffnest, das geht nicht, socket.getInputStream() darf nur in einen ObjectInputStream gehen oder einen anderen,
nicht zwei gleichzeitig und kann auch nicht wechseln für eine Verbindung, bei out genauso

der Exception nach zu urteilen ist der Client fertig bevor im Server die Verbindungen überhaupt initialisiert werden,
wie sieht es beim Client aus?:
> while (s.isConnected()) {
setze System.out.println() mit Meldungen vor die Schleife, in die Schleife, nach der Schleife, was passiert, wo wird gewartet?
evtl. mit genauer Uhrzeit wenn zusammen mit Server Dinge gleichzeitig passieren,
oder großzügige Wartezeiten mit Thread.sleep() einbauen

im client allgemein steht
> catch (Exception exc) {}
das ist immer schlecht, gib Exceptions aus, sonst übersiehst du sie

 

[Spitfire777]

Hey, vielen Dank für deine Hilfe, Mühe und Geduld! 🙂

Endlich funktioniert alles einwandfrei!
Die Nachricht ist zwar korrekt angekommen, aber aufgrund des oos.close() in der Serverschleife kam die Exception.

Grüße