[RESUELTO]Crear una cola de conexiones de Socket en un ServerSocket.

[NikNitro!]

Buenas, no estaba seguro de que preguntas de programación fueran en Redes, por lo que lo puse aquí.

Tengo un servidor que recibe conexiones de socket. Solo puede procesar una a la vez, pero quiero que si un segundo cliente intenta conectarse espere hasta que pueda. Había pensado hacerlo con una cola, pero no se "qué meter" dentro de la cola.

Aquí el code de mi Servidor:

Código (java) [Seleccionar] Expandir


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class Servidor extends Thread{

private int port;
private ServerSocket server;
private Socket sck;

public Servidor() {
port = 5000;

}
public Servidor(int i) {
port = i;

}

public boolean Connect() {
try {

server = new ServerSocket(port);
System.out.println("Servidor esperando conexión.");
sck = server.accept();

return true;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("Error con la conexión");
return false;
}

}

public boolean Disconnect() {
try {

sck.close();
server.close();

return true;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("Error al desconectar");
return false;
}

}

public boolean receiveMensaje() {
try {
PrintWriter printer = new PrintWriter(sck.getOutputStream(), true);
BufferedReader reader = new BufferedReader(new InputStreamReader(sck.getInputStream()));

System.out.println("Esperando Mensaje...");

sck.setSoTimeout(40*1000);
String mensaje = reader.readLine();
while(sck.isConnected() && !mensaje.equals("FIN")) {

System.out.println("Recibido: "+mensaje);
if(!mensaje.equals("FIN")) {

printer.println(mensaje.toUpperCase());
mensaje = reader.readLine();

}
}


// System.out.println("Server apagandose");
this.Disconnect();

return true;
} catch (IOException e) {
System.out.println("Error: Compruebe su conexion o que no ha estado más de 40 segundos inactivo.");
Disconnect();
return false;
}
}

public void run() {
while(true) {
Connect();
receiveMensaje();
}
}


public static void main(String[] args) {
// TODO Auto-generated method stub
Servidor sv = new Servidor();
// Servidor sv = new Servidor(Integer.parseInt(args[0]));
sv.run(); // Porque no necesita ser concurrente.
}

Como veis, la conexion no es más que un 'Socket sck = ServerSocket.accept()"

Entonces cómo podría hacerlo?

Salud

[Migugami]

Se me ocurre que puedes hacer que cada conexión sea un thread y esperar por el término del thread actual. Creo que esto lo puedes hacer llamando al método join() en el thread que quieres se mantenga ejecutándose sin iniciar el otro thread que quiere ejecutarse, poniendo el thread B en cola de espera.

Código (=java) [Seleccionar] Expandir


Conexion conexion = new Conexion().run();
conexion.join();
// aquí va el hilo que esperara que termine el hilo 'conexion'.

[NikNitro!]

Mmm, perdón por la tardanza en la respuesta, pero quería responder con 'sustancia'.

Lo de los hilos no es lo que busco. Te explico:

El constructor de serverSocket que estoy usando es al que se le pasa un int que es el puerto, pero existe otro constructor tal que así:

Código [Seleccionar] Expandir

new ServerSocket(int port, int backlog);

backlog indica el número de conexiones en espera que puede tener a la vez. Con el que yo estoy usando se usa como predeterminado el número 20 (o 50, ahora mismo no lo recuerdo bien).

Esto significa que la cola de conexiones está creada y, sin embargo, cuando cierro una conexion se me cierran todas las de la cola (todas van al mismo puerto y al cerrar el socket se cierran todas).

Total, si comento el close del serverSocket, cuando cierro la conexion desde el cliente me empiezan a dar una exageración de Throws en el receiveMessage().

Qué pensais que estoy haciendo mal? :s

Salud

[Migugami]

¿Cuando se cierran todas las conexiones, lanza alguna excepción (debería hacerlo) ? Si es así, coloca el StackTrace.

Te dejo un ejemplo extraído del libro Cómo programar en Java, que crea un servidor con una cola de conexiones:

Código (=java) [Seleccionar] Expandir


// 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

Código (=java) [Seleccionar] Expandir


// 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( "127.0.0.1" );
      else
         aplicacion = new Cliente( args[ 0 ] );

      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      aplicacion.ejecutarCliente();
   }

} // fin de la clase Cliente

[NikNitro!]

Ok. El fallo estaba únicamente en que cuando acababa una conexion cerraba el serverSocket y luego creaba uno nuevo. He puesto el constructor del serverSocket en el constructor de Servidor y le he quitado el .close().

Si alguien necesita el código completo que me lo pida. De todos modos a partir del día 8 (que es cuando entrego la práctica) lo subiré a mi blog