Duda sobre sockets en java

[emma93]

Buenos días.

Tengo una duda que me está carcomiendo la cabeza: Intento hacer una aplicación cliente servidor, desde el servidor espero conexiones (es un servidor que acepta varios clientes).

La cuestion es que yo quiero realizar algo como lo siguiente:

Código Sockets:

-> Esperar conexión en el servidor
   -> Cliente conectado
-> Obtener socket del cliente con server.accept();
-> Abrir flujos DataInputStream y DataOutputStream del socket
-> Enviar un paquete al cliente, para ello uso DataOutputStream
   -> Recibir paquete del servidor, para ello uso DataInputStream
   -> Enviar respuesta al servidor
-> Recibir respuesta del cliente
-> Enviar paquete al cliente
   -> Recibir paquete del servidor, para ello vuelvo a usar DataInputStream
   -> Enviar paquete al servidor
-> Recibir paquete del cliente
-> Cerrar conexion
 

Bien, como pueden ver no es algo muy complicado ya que de ésa manera tengo entendido que funcionan los sockets (según lo que leí). La comunicación la hago en binario (osea, transmito y recibo paquetes pero no en formato texto, no se si me explico).

Mi problema es el siguiente: Cuando envío el primer paquete al cliente, me lo transmite correctamente. Luego, desde el cliente le respondo al servidor, quien recibe correctamente el paquete. Pero luego quiero enviar un nuevo paquete desde el servidor al cliente, y me dice que el Socket ya ha sido cerrado. Para enviar datos al cliente por el socket uso el método write(byte[] data) de DataOutputStream. Luego hago un dOutputStream.close(); (haciendo ésto es cuando me llegan los datos correctos al cliente). Pero se vé que cuando cierro el flujo de salida, no puedo enviar más nada.

Ésto es lo que tengo en el método run del ServerSocketThread

Código Javascript:

public void run(){
        
        int maxLen = 1024;
        byte[] buffer; //Buffer de datos
        
        while(true){
            try {
                dInputStream  = new DataInputStream(socket.getInputStream());
                dOutputStream = new DataOutputStream(socket.getOutputStream());
                //Leemos el paquete, y de aqui lo mandamos a analizar.
                buffer = new byte[maxLen]; //Definimos el buffer con el tamaño maximo de 1024 bytes
                int k = -1;
                int readLen = 0;
                
                while((k = dInputStream.read()) != -1 && readLen < maxLen){ //Leemos byte a byte hasta que no queden mas bytes                  
                    buffer[readLen] = (byte)k;
                    readLen++;
                    if(k == ConstantsProtocol.END)
                        break;
                }
                
                //Si recibimos menos del maximo, entonces lo guardaremos en un arreglo nuevo para que no queden espacios vacios (0x00)
                if(readLen <= maxLen){
                    byte[] buffAux = new byte[readLen];
                    ByteUtils.arrayCopy(buffer, 0, buffAux, 0, readLen);
                    buffer = buffAux;
                }
                
                Print.logInfo("Recv[" + readLen + "][Hex]: " + StringTools.toHexString(buffer));
                byte respuesta[] = new byte[3];
                respuesta[0] = 0x00;
                respuesta[1] = 0x00;
                respuesta[2] = 0x00;
                dOutputStream.write(respuesta);
                dOutputStream.close();
            } catch(SocketTimeoutException timeout){
                Print.logError("Read timeout[30s]: Cerrando conexion");
                try {
                    socket.close();
                    Print.logError("Conexion cerrada.");
                    break;
                } catch (IOException e) {
                    Print.logError("Error al cerrar conexion por timeout: " + e.getMessage());
                } catch (Throwable e) {
                    Print.logError("Error al cerrar Thread por timeout: " + e.getMessage());
                }
            } catch (IOException e) {
                Print.logError("Error al leer: " + e.getMessage());
                break;
            }
        }
    }
 

Gracias, espero puedan ayudarme.

saludos..

[chuidiang]

Pues es bastante claro, dOutputStream.close() cierra el Stream y el Stream es el socket. No lo cierres.

Se bueno.

[emma93]

Si ,ya solucioné el problema. El problema es que desde el lado del cliente no estaba poniendo un control para terminar de leer.

Por ejemplo, hacía algo así:

int k = 0;
public static final int END = 0x01;

Código Javascript:

while((k = dInputStream.read()) != -1 && k != END){
     buffer[offset] = k;
     offset++;
}
 

mientras que lo correcto era hacer:

Código Javascript:

while((k = dInputStream.read()) != -1){
     buffer[offset] = k;
     offset++;
     if(k == END)
         break;
}
 

Saludos y gracias.