Problema nao identificado em java

Boa tarde,

Estou com um problema para implementar um chat dentro de uma tela, o servidor do meu chat por socket já está rodando porem quando tento me conectar ao chat ele me volta esse erro no servidor:
Exception in thread “Thread-2” java.lang.ClassCastException: modelo.ChatMessage cannot be cast to modelo.ChatMessageServidor
at controle.ServidorService$ListenerSocket.run(ServidorService.java:63)
at java.lang.Thread.run(Thread.java:748)

se executo fora da tela somente o chat e o servidor ambos funcionam.

a linha que me retorna quando clico no ServidorService.java63 é esta:

while ((message = (ChatMessageServidor) input.readObject()) != null) {
Action action = message.getAction();

Alguem poderia me ajudar?

Falai @bzendron, seria uma boa voce postar o codigo inteiro do arquivo “ServidorService.java” para que os demais colegas pudessem analisar e auxilia-lo.
Abraços
Max

Opa, beleza, obrigado pela dica.

package controle;

import modelo.ChatMessageServidor;
import modelo.ChatMessageServidor.Action;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

public class ServidorService {

private ServerSocket serverSocket;
private Socket socket;
private Map<String, ObjectOutputStream> mapOnlines = new HashMap<String, ObjectOutputStream>();

public ServidorService() {
    try {
        serverSocket = new ServerSocket(1208);

        JOptionPane.showMessageDialog(null,"Servidor Iniciado com Sucesso");

        while (true) {
            socket = serverSocket.accept();

            new Thread(new ListenerSocket(socket)).start();
        }

    } catch (IOException ex) {
        Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
    }
}

private class ListenerSocket implements Runnable {

    private ObjectOutputStream output;
    private ObjectInputStream input;

    public ListenerSocket(Socket socket) {
        try {
            this.output = new ObjectOutputStream(socket.getOutputStream());
            this.input = new ObjectInputStream (socket.getInputStream());
        } catch (IOException ex) {
            Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    @Override
    public void run() {
        ChatMessageServidor message = null;
        try {
            while ((message = (ChatMessageServidor) input.readObject()) != null) {
                Action action = message.getAction();

                if (action.equals(Action.CONNECT)) {
                    boolean isConnect = connect(message, output);
                    if (isConnect) {
                        mapOnlines.put(message.getName(), output);
                        sendOnlines();
                    }
                } else if (action.equals(Action.DISCONNECT)) {
                    disconnect(message, output);
                    sendOnlines();
                    return;
                } else if (action.equals(Action.SEND_ONE)) {
                    sendOne(message);
                } else if (action.equals(Action.SEND_ALL)) {
                    sendAll(message);
                }
            }
        } catch (IOException ex) {
            ChatMessageServidor cm = new ChatMessageServidor();
            cm.setName(message.getName());
            disconnect(cm, output);
            sendOnlines();
            System.out.println(message.getName() + " deixou o chat!");
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

private boolean connect(ChatMessageServidor message, ObjectOutputStream output) {
    if (mapOnlines.size() == 0) {
        message.setText("YES");
        send(message, output);
        return true;
    }

    if (mapOnlines.containsKey(message.getName())) {
        message.setText("NO");
        send(message, output);
        return false;
    } else {
        message.setText("YES");
        send(message, output);
        return true;
    }
}

private void disconnect(ChatMessageServidor message, ObjectOutputStream output) {
    mapOnlines.remove(message.getName());

    message.setText(" até logo!");

    message.setAction(Action.SEND_ONE);

    sendAll(message);

    System.out.println("User " + message.getName() + " sai da sala");
}

private void send(ChatMessageServidor message, ObjectOutputStream output) {
    try {
        output.writeObject(message);
    } catch (IOException ex) {
        Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
    }
}

private void sendOne(ChatMessageServidor message) {
    for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) {
        if (kv.getKey().equals(message.getNameReserved())) {
            try {
                kv.getValue().writeObject(message);
            } catch (IOException ex) {
                Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

private void sendAll(ChatMessageServidor message) {
    for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) {
        if (!kv.getKey().equals(message.getName())) {
            message.setAction(Action.SEND_ONE);
            try {
                kv.getValue().writeObject(message);
            } catch (IOException ex) {
                Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

private void sendOnlines() {
    Set<String> setNames = new HashSet<String>();
    for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) {
        setNames.add(kv.getKey());
    }

    ChatMessageServidor message = new ChatMessageServidor();
    message.setAction(Action.USERS_ONLINE);
    message.setSetOnlines(setNames);

    for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) {
        message.setName(kv.getKey());
        try {
            kv.getValue().writeObject(message);
        } catch (IOException ex) {
            Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

}

O seu servidor tenta ler objetos do tipo ChatMessageServidor mas o cliente está enviando objetos do tipo ChatMessage.

Eu não sei a demanda de usuarios que seu chat suportara.
Mas se for grande, uma Thread para cada usuario consome muito recurso.
Nesse caso, canais não bloqueantes é excelente veja no java.nio.
Em relação a seu problema, se até o final da semana vc não tiver conseguido resolver dou uma olhada.