Chat en java

[MjRoxas]

Buenas, estoy intentando implementar un servidor de un chat
Necesito llevar una lista de los conectados: he pensado en la clase DefaultListModel, pero no entiendo muy bien como esta clase mantiene informados al resto de los conectados mediando los metodos de fire..
Tambien necesito conocer los flujos necesarios, y habia pensado en la clase SocketChannel, pero tampoco acabo de entender como funciona..

Pueden aconsejarme, darme idea u orientarme?
Muchas gracias!!

[endgel]

aca esta un ejemplo para que te guies, este es un chat entre 2 pc via lan, configuras las ip de cada una entre cliente y servidor y listo ... quizas te ayude en algo.. saludos

Código Javascript:

// Cliente que lee y muestra la informaci�n que le env�a un Servidor.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Cliente extends JFrame {
   private JTextField campoIntroducir;
   private JTextArea areaPantalla;
   private ObjectOutputStream salida;
   private ObjectInputStream entrada;
   private String mensaje = "";
   private String servidorChat;
   private Socket cliente;
 
   // inicializar servidorChat y configurar GUI
   public Cliente( String host )
   {
      super( "Cliente" );
 
      servidorChat = host; // establecer el servidor al que se va a conectar este cliente
 
      Container contenedor = getContentPane();
 
      // crear campoIntroducir y registrar componente de escucha
      campoIntroducir = new JTextField();
      campoIntroducir.setEditable( false );
      campoIntroducir.addActionListener(
         new ActionListener() {
 
            // enviar mensaje al servidor
            public void actionPerformed( ActionEvent evento )
            {
               enviarDatos( evento.getActionCommand() );
               campoIntroducir.setText( "" );
            }
         }  
      ); 
 
      contenedor.add( campoIntroducir, BorderLayout.NORTH );
 
      // crear areaPantalla
      areaPantalla = new JTextArea();
      contenedor.add( new JScrollPane( areaPantalla ),
         BorderLayout.CENTER );
 
      setSize( 300, 150 );
      setVisible( true );
 
   } // fin del constructor de Cliente
 
   // conectarse al servidor y procesar mensajes del servidor
   private void ejecutarCliente() 
   {
      // conectarse al servidor, obtener flujos, procesar la conexi�n
      try {
         conectarAServidor(); // Paso 1: crear un socket para realizar la conexi�n
         obtenerFlujos();      // Paso 2: obtener los flujos de entrada y salida
         procesarConexion(); // Paso 3: procesar la conexi�n
      }
 
      // el servidor cerr� la conexi�n
      catch ( EOFException excepcionEOF ) {
         System.err.println( "El cliente termino la conexi�n" );
      }
 
      // procesar los problemas que pueden ocurrir al comunicarse con el servidor
      catch ( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
 
      finally {
         cerrarConexion(); // Paso 4: cerrar la conexi�n
      }
 
   } // fin del m�todo ejecutarCliente
 
   // conectarse al servidor
   private void conectarAServidor() throws IOException
   {      
      mostrarMensaje( "Intentando realizar conexi�n\n" );
 
      // crear Socket para realizar la conexi�n con el servidor
      cliente = new Socket( InetAddress.getByName( servidorChat ), 12345 );
 
      // mostrar la informaci�n de la conexi�n
      mostrarMensaje( "Conectado a: " + 
         cliente.getInetAddress().getHostName() );
   }
 
   // obtener flujos para enviar y recibir datos
   private void obtenerFlujos() throws IOException
   {
      // establecer flujo de salida para los objetos
      salida = new ObjectOutputStream( cliente.getOutputStream() );      
      salida.flush(); // vac�ar b�fer de salida para enviar informaci�n de encabezado
 
      // establecer flujo de entrada para los objetos
      entrada = new ObjectInputStream( cliente.getInputStream() );
 
      mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
   }
 
   // procesar la conexi�n con el servidor
   private void procesarConexion() throws IOException
   {
      // habilitar campoIntroducir para que el usuario del cliente pueda enviar mensajes
      establecerCampoTextoEditable( true );
 
      do { // procesar mensajes enviados del servidor
 
         // leer mensaje y mostrarlo en pantalla
         try {
            mensaje = ( String ) entrada.readObject();
            mostrarMensaje( "\n" + mensaje );
         }
 
         // atrapar los problemas que pueden ocurrir al leer del servidor
         catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
            mostrarMensaje( "\nSe recibi� un objeto de tipo desconocido" );
         }
 
      } while ( !mensaje.equals( "SERVIDOR>>> TERMINAR" ) );
 
   } // fin del m�todo procesarConexion
 
   // cerrar flujos y socket
   private void cerrarConexion() 
   {
      mostrarMensaje( "\nCerrando conexi�n" );
      establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir
 
      try {
         salida.close();
         entrada.close();
         cliente.close();
      }
      catch( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
   }
 
   // enviar mensaje al servidor
   private void enviarDatos( String mensaje )
   {
      // enviar objeto al servidor
      try {
         salida.writeObject( "CLIENTE>>> " + mensaje );
         salida.flush();
         mostrarMensaje( "\nCLIENTE>>> " + mensaje );
      }
 
      // procesar los problemas que pueden ocurrir al enviar el objeto
      catch ( IOException excepcionES ) {
         areaPantalla.append( "\nError al escribir el objeto" );
      }
   }
 
   // m�todo utilitario que es llamado desde otros subprocesos para manipular a 
   // areaPantalla en el subproceso despachador de eventos
   private void mostrarMensaje( final String mensajeAMostrar )
   {
      // mostrar mensaje del subproceso de ejecuci�n de la GUI
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run() // actualiza areaPantalla
            {
               areaPantalla.append( mensajeAMostrar );
               areaPantalla.setCaretPosition( 
                  areaPantalla.getText().length() );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   // m�todo utilitario que es llamado desde otros subprocesos para manipular a 
   // campoIntroducir en el subproceso despachador de eventos
   private void establecerCampoTextoEditable( final boolean editable )
   {
      // mostrar mensaje del subproceso de ejecuci�n de la GUI
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run()  // establece la capacidad de modificar campoIntroducir
            {
               campoIntroducir.setEditable( editable );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   public static void main( String args[] )
   {
      Cliente aplicacion;
 
      if ( args.length == 0 )
         aplicacion = new Cliente( "192.200.101.131" );
      else
         aplicacion = new Cliente( args[ 0 ] );
 
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      aplicacion.ejecutarCliente();
   }
 
} // fin de la clase Cliente
 

[endgel]

Código Javascript:

package chat;
 
// Configurar un servidor que reciba una conexión de un cliente, envíe
// una cadena al cliente y cierre la conexión.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Servidor extends JFrame {
   private JTextField campoIntroducir;
   private JTextArea areaPantalla;
   private ObjectOutputStream salida;
   private ObjectInputStream entrada;
   private ServerSocket servidor;
   private Socket conexion;
   private int contador = 1;
 
   // configurar GUI
   public Servidor()
   {
      super( "Servidor" );
 
      Container contenedor = getContentPane();
 
      // crear campoIntroducir y registrar componente de escucha
      campoIntroducir = new JTextField();
      campoIntroducir.setEditable( false );
      campoIntroducir.addActionListener(
         new ActionListener() {
 
            // enviar mensaje al cliente
            public void actionPerformed( ActionEvent evento )
            {
               enviarDatos( evento.getActionCommand() );
               campoIntroducir.setText( "" );
            }
         }  
      ); 
 
      contenedor.add( campoIntroducir, BorderLayout.NORTH );
 
      // crear areaPantalla
      areaPantalla = new JTextArea();
      contenedor.add( new JScrollPane( areaPantalla ), 
         BorderLayout.CENTER );
 
      setSize( 300, 150 );
      setVisible( true );
 
   } // fin del constructor de Servidor
 
   // configurar y ejecutar el servidor 
   public void ejecutarServidor()
   {
      // configurar servidor para que reciba conexiones; procesar las conexiones
      try {
 
         // Paso 1: crear un objeto ServerSocket.
         servidor = new ServerSocket( 12345, 100 );
 
         while ( true ) {
 
            try {
               esperarConexion(); // Paso 2: esperar una conexión.
               obtenerFlujos();        // Paso 3: obtener flujos de entrada y salida.
               procesarConexion(); // Paso 4: procesar la conexión.
            }
 
            // procesar excepción EOFException cuando el cliente cierre la conexión 
            catch ( EOFException excepcionEOF ) {
               System.err.println( "El servidor terminó la conexión" );
            }
 
            finally {
               cerrarConexion();   // Paso 5: cerrar la conexión.
               ++contador;
            }
 
         } // fin de instrucción while
 
      } // fin del bloque try
 
      // procesar problemas con E/S
      catch ( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
 
   } // fin del método ejecutarServidor
 
   // esperar que la conexión llegue, después mostrar información de la conexión
   private void esperarConexion() throws IOException
   {
      mostrarMensaje( "Esperando una conexión\n" );
      conexion = servidor.accept(); // permitir al servidor aceptar la conexión            
      mostrarMensaje( "Conexión " + contador + " recibida de: " +
         conexion.getInetAddress().getHostName() );
   }
 
   // obtener flujos para enviar y recibir datos
   private void obtenerFlujos() throws IOException
   {
      // establecer flujo de salida para los objetos
      salida = new ObjectOutputStream( conexion.getOutputStream() );
      salida.flush(); // vaciar búfer de salida para enviar información de encabezado
 
      // establecer flujo de entrada para los objetos
      entrada = new ObjectInputStream( conexion.getInputStream() );
 
      mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
   }
 
   // procesar la conexión con el cliente
   private void procesarConexion() throws IOException
   {
      // enviar mensaje de conexión exitosa al cliente
      String mensaje = "Conexión exitosa";
      enviarDatos( mensaje );
 
      // habilitar campoIntroducir para que el usuario del servidor pueda enviar mensajes
      establecerCampoTextoEditable( true );
 
      do { // procesar los mensajes enviados por el cliente
 
         // leer el mensaje y mostrarlo en pantalla
         try {
            mensaje = ( String ) entrada.readObject();
            mostrarMensaje( "\n" + mensaje );
         }
 
         // atrapar problemas que pueden ocurrir al tratar de leer del cliente
         catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
            mostrarMensaje( "\nSe recibió un tipo de objeto desconocido" );
         }
 
      } while ( !mensaje.equals( "CLIENTE>>> TERMINAR" ) );
 
   } // fin del método procesarConexion
 
   // cerrar flujos y socket
   private void cerrarConexion() 
   {
      mostrarMensaje( "\nFinalizando la conexión\n" );
      establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir
 
      try {
         salida.close();
         entrada.close();
         conexion.close();
      }
      catch( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
   }
 
   // enviar mensaje al cliente
   private void enviarDatos( String mensaje )
   {
      // enviar objeto al cliente
      try {
         salida.writeObject( "SERVIDOR>>> " + mensaje );
         salida.flush();
         mostrarMensaje( "\nSERVIDOR>>> " + mensaje );
      }
 
      // procesar problemas que pueden ocurrir al enviar el objeto
      catch ( IOException excepcionES ) {
         areaPantalla.append( "\nError al escribir objeto" );
      }
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a
   // areaPantalla en el subproceso despachador de eventos
   private void mostrarMensaje( final String mensajeAMostrar )
   {
      // mostrar mensaje del subproceso de ejecución despachador de eventos
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run() // actualiza areaPantalla
            {
               areaPantalla.append( mensajeAMostrar );
               areaPantalla.setCaretPosition( 
                  areaPantalla.getText().length() );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a 
   // campoIntroducir en el subproceso despachador de eventos
   private void establecerCampoTextoEditable( final boolean editable )
   {
      // mostrar mensaje del subproceso de ejecución despachador de eventos
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run()  // establece la capacidad de modificar a campoIntroducir
            {
               campoIntroducir.setEditable( editable );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   public static void main( String args[] )
   {
      Servidor aplicacion = new Servidor();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      aplicacion.ejecutarServidor();
   }
 
}  // fin de la clase Servidor
 

[MjRoxas]

Ya lo tenia implementado, pero muchas gracias endgel.
Te comento como lo hice:
- El servidor toma cada cliente como un hilo
- ArrayList de todos los clientes conectados (hilos creados)
- Para la comunicacion seguia pensando en usar el Channel, pero por ahora estoy utilizando los flujos normales de los sockets

Estoy en proceso de depuracion, y ahora mismo los problemas que tengo son con los avisos y mensajes del servidor a el/los clientes.

Muchas gracias de todos modos!

[HackmanC]

Iniciado por MjRoxas

... Necesito llevar una lista de los conectados: he pensado en la clase DefaultListModel, pero no entiendo muy bien como esta clase mantiene informados al resto de los conectados mediando los metodos de fire..

¿Por qué no usas tu propia implementación? Esta implementación es bastante antigua, así que use un HashSet, pero actualmente podrías usar una implementación como LinkedList. Cada usuario es un JUser y es un Thread, e implementa una función para enviarle mensajes.

Código Java:

public class JUser extends JObject implements JPingerListener, JConnectionHandler {
...
    public void notice(String message) {
        socket.print(JMessage.message(JMessage.JM_NOTICE, nickname, message));
    }
    
    public void noticeWithMode(String message, char mode) {
        if(modes.indexOf(mode) != -1)
            notice(message);
    }
...    
}
 

La lista de usuarios, que es un HashSet de JUser se mantiene sincronizada y pasa por cada uno enviandole los mensajes correspondientes a uno y cada uno de los participantes, (cuando escribí esta aplicación no existía los Generics, pero puedes adaptar el método con Generics para no tener la necesidad de hacer el cast a JUser).

Código Java:

public class JUsers extends JObject {
...
    private HashSet users;
...
    public synchronized void handleConnection(Socket socket) throws IOException {
        JUser user = new JUser(this, socket);
        user.start();
        users.add(user);
    }
    
    public synchronized void remove(JUser user, String message) {
        users.remove(user);
    }
...
    public synchronized void fireNoticeAll(String message) {
        for(Iterator e = users.iterator(); e.hasNext(); )
            ((JUser)e.next()).notice(message);
    }
    
    public synchronized void fireNoticeAllWithMode(String message, char mode) {
        for(Iterator e = users.iterator(); e.hasNext(); )
            ((JUser)e.next()).noticeWithMode(message, mode);
    }
...    
}
 

El servidor cuando necesita avisarle a todos solamente hace uso del método de la clase donde le avisa a todos los usuarios conectados,

Código Java:

public class JServer extends JThread {
...
    public JServer(int port) {
        this.users = new JUsers(this);
    }
...
    private synchronized void handleConnection(Socket socket) throws IOException {
...
                    if(!bannedConnection(socket, hostname, hostaddr))
...
        }
    }
...
    private boolean bannedConnection(Socket socket, String hostname, String hostaddr) {
...
        if(banned) {
            JSocket.print(socket, JMessage.message(JMessage.JM_KLINED, kl.reason));
            users.fireNoticeAllWithMode(JMessage.message(JMessage.JM_KLINEDALL, hostname), 'K');
...
        }
        
        return banned;
    }
}
 

De esa forma cuando el servidor quiere enviar un mensaje a todos los usuarios, o un usuario quiere enviar un mensaje a todos los demás usuarios, pasa por cada uno de los conectados y les envía el mensaje.

Iniciado por MjRoxas

... Estoy en proceso de depuracion, y ahora mismo los problemas que tengo son con los avisos y mensajes del servidor a el/los clientes. ...

La programación en Java está orientada a objetos, aunque la aplicación que mostró endgel ha de ser funcional parece programación estructurada, como Pascal o C.

Para hacer este servidor y lograr que todos los componentes se comuniquen correctamente necesitas por lo menos 10 clases distintas, por ejemplo .. JServer, JSocket, JUser, JUsers, JConnection, JConnectionHandler, JChannel, JChannels, etc. Cada uno tiene una ocupación diferente y de esta forma logras dividir la funcionalidad de cada componente para que sea mas fácil de sincronizar al mismo tiempo de mantener la lógica simple.

Saludos,

ps:

El codigo fue escrito en el año 2002, así que evidentemente es muy antiguo, y eliminé muchas partes de control de errores, etc., pero es rápido y eficiente, en lo que cabe con cien usuarios conectados.