SocketServer y compañeros

[ChicoTolerante]

¡Hola buenas!
Agradecería un montón (y parte del otro) si me pudieran tender una mano con un problemilla de sockets. Estoy ideando un chat, pero ocurre que lo consigo abrir, consigue recibir UN mensaje, pero no controlo suficiente con los threads (si es que es ahí donde está la clave) como para mantener la comunicación abierta entre cliente y servidor y poder prolongar la conversación. Antaño me funcionó, pero ahora que lo estoy haciendo más "limpio", no recuerdo cómo...

El código que tengo es el siguiente:

Código (java) [Seleccionar] Expandir


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

public class ServidorDelChat extends Thread
{
public static ServerSocket socketServidor;
public static Socket socketConexion;
public static DataOutputStream salidaServidor;
public static BufferedReader entradaServidor;
public static int puerto;

//Clase para hablar
    public class HablarDesdeServidor extends Thread
        {
        //CONSTRUCTOR DE HILO para hablar
        public void run()
        {
            try{
                salidaServidor = new DataOutputStream(socketConexion.getOutputStream());
                System.out.println("salidaServidor = new DataOutputStream(socket.getOutputStream());");
                salidaServidor.writeUTF(InterfazDelChat.fieldMensaje.getText());
            }catch(Exception exc) {
                InterfazDelChat.areaChat.append("\nError al ENVIAR el mensaje.\n");}
            }
        }

    //Clase para escuchar
    public class EscucharDesdeServidor extends Thread
        {
        //CONSTRUCTOR DE HILO para escuchar
        public void run()
            {
            System.out.println("\nLa clase Thread.EscucharDesdeServidor SÍ FUNCIONA.");
            System.out.println("Valor de ServerSocket socketServidor: " + socketServidor);
                try{
                    entradaServidor = new BufferedReader(new InputStreamReader(socketConexion.getInputStream())); //Coge el InputStream, lo pone en un lector y el resultado en un búffer.
                    InterfazDelChat.areaChat.append("\nLa otra persona dice...\n" + entradaServidor.readLine() + "\n");
                }catch(Exception exc){
                    InterfazDelChat.areaChat.append("\nError al RECIBIR el mensaje.\n");}
               
            }
        }

    //Clase para conectar
    public class ConectarDesdeServidor extends Thread
        {
        //CONSTRUCTOR DE HILO para conectar
        public void run()
            {
            System.out.println("La clase Thread.ConectarDesdeServidor SÍ FUNCIONA.");
            try{
                puerto = Integer.parseInt(InterfazDelChat.fieldPuerto.getText());
                socketServidor = new ServerSocket(puerto, 2);
               
                socketConexion = new Socket();
                System.out.println("Parámetro de ServerSocket(puerto): " + puerto);
                System.out.println("Valor de ServerSocket socketServidor: " + socketServidor);
                System.out.println("Valor de Socket socket: " + socketConexion);
               
                socketConexion = socketServidor.accept(); //Aquí espera a que alguien haga la petición. La petición se inicia en el envío del primer mensaje.
               
                InterfazDelChat.fieldDireccionLocal.setText("" + socketConexion.getLocalSocketAddress());
                InterfazDelChat.fieldDireccionRemota.setText("" + socketConexion.getRemoteSocketAddress());
               
                System.out.println("Dirección socket local: " + socketConexion.getLocalSocketAddress());
                System.out.println("Dirección socket remoto: " + socketConexion.getRemoteSocketAddress());
                System.out.println("Valor de (socket = socketServidor.accept()): " + socketConexion);
               
               
               
                System.out.println("Ahora, se supone, estamos enlazados.");
                InterfazDelChat.fieldAyuda.setText("Conectado.");
            }catch(Exception exc) {
                }
            }
        }

    //Clase para desconectar
    public class DesconectarDesdeServidor extends Thread
        {
        //CONSTRUCTOR DE HILO para desconectar
        public void run()
            {
            try{
                socketConexion.close();
                entradaServidor.close();
                salidaServidor.close();
            }catch(Exception exc) {
                }
            }
        }
//CONSTRUCTOR
public ServidorDelChat()
    {
    System.out.println("El método constructor de ServidorDelChat() SÍ funciona.");
        (new ConectarDesdeServidor()).run();
        (new EscucharDesdeServidor()).run();   
    }
   
}



He probado introduciendo bucles en la clase para conectar y en la clase para hablar, pero no hay manera... no se me ocurre nada. Cualquier consejo será de gran ayuda.
¡Gracias, sois muy cracks!

[ChicoTolerante]

Breve explicación para entender mejor el código:
1. Todos los "System.out.println(*);" en realidad sobran, lo que pasa que los utilizo para ir siguiendo el programa, por donde va pasando, e ir quedándome con ciertos valores para ir entendiéndolo mejor.
2. La idea general es crear 4 clases diferentes:
- ConectarDesdeServidor: para conectar con el cliente.
- HablarDesdeServidor: para hablar con el cliente.
- EscucharDesdeServidor: para escuchar al cliente.
- DesconectarDesdeServidor: para desconectar las conexiones, o por lo menos la del cliente.
3. Esto lo hago para poder usar con más libertad los Threads. Por eso cada una de estas clases cumple una función y todas derivan de la clase Thread de Java, para poder usarlas como hilos.
4. No sé bien bien cómo podría hacerlo para que haya una escucha y una posibilidad de hablar al mismo tiempo (eso sí, con "synchronized), pero de una manera CONTINUADA, y no sólo espontánea (ahora consigo que se envíe y se reciba un mensaje, pero nada más...)

[ChicoTolerante]

Reformularé la pregunta, porque creo que es leer código innecesariamente:

¿Cómo puedo hacer para abrir una conexión entre un socket servidor y otro cliente y dejarla abierta para que se puedan enviar mensajes entre sí?

Gracias, y perdón por no haber sido más conciso.

[ChicoTolerante]

Respuesta:
No hay ningún problema. Desde el momento en que acepta, un socket nuevo es creado para seguir escuchando a otros clientes, pero el primero se mantiene abierto en el puerto ServerSocket.getLocalPort(). Así que el problema debe ser otro... y ello debería ir en otro post. En concreto, es un problema de actualizar el JTextArea donde debería aparecer el mensaje nada más entrar la info del DataInputStream. Pero lo comento en otro post.

Gracias y disculpen!!