style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Manadar muchos objetos por socket

Buenas noches gente, tengo problemas al mandar objetos al un servidor que me gustaría me ayudaran a resolverlo. Tengo una clase "Datos" que tiene atributos que me interesan manejarlos en el servidor para generar algunas estadisticas, Cada vez que sucede algo que le ineresa al servidor se crea una nuevo objeto de tipo "Dato" y se guarda en un arraylist cuando el servidor necesita los datos le dice a los clientes que le manden la informacion, lo hago de la siguiente forma:

//SERVIDOR

hiloCliente user=null;

for (int i=0; i>clientesActivos.size;i++){

       user = clientesActivos.get(i);

      user.mandarInt(5); // 4 es la opcion de mandar datos en el bloque switch del cliente

}

//ASI RECIBEN LOS OBJETOS

while(escuchar){
           
                int opcion = recibir.readInt();
                switch(opcion){
                   
                    case 3:
                        Datos_Estadisticas datos =null;
               
                   
                    int [] datosCliente = (int[]) recibirObjeto.readObject();

                   datos = new Datos_Estadisticas(getNombreUsu(), datosCliente[2],
                           Servidor.totalJuegos-datosCliente[2], datosCliente[0], datosCliente[1]);    
             
           //Se reciben los datos y se agregan a una lista
                   lstDatos.add(datos);

                        break;
                       
                    case 4:
                        Detalle_Fallas obj=null;
                     obj = (Detalle_Fallas)recibirObjeto.readObject();
                   //recibo el objeto y lo agrego a una lista
                    det.add(obj);

                        break;
                       
                }

//CLIENTE

while(true){
                  opcion=entrada.readInt();
                 
                    switch(opcion){
                       
                        case 5:
                            Detalle_Fallas det =null;
                }

                                //ESTO SI LO HACE BIEN
                            int[] datosCliente = vcli.obtenerDatos();
                            mandarPorSocket(3);//    Le indica al servidor que reciba un objeto
                            mandarObjeto(datosCliente);  
                           

                               //AQUI ES DONDE HAY PROBLEMAS
                           
                            for (int i = 0; i < Principal.lstFallas.size(); i++) {
                                mandarPorSocket(4);//Se le indica al servidor que reciba un objeto
                                det =Principal.lstFallas.get(i);
                              mandarObjeto(det);                            
                            }
                            break;
     
                }
                opcion=0;
             }

Me manda un nullPointerException en este bloque.

                    case 4:
                        Detalle_Fallas obj=null;
                     obj = (Detalle_Fallas)recibirObjeto.readObject();
                   //recibo el objeto y lo agrego a una lista
                    det.add(obj);

                        break;

Espero me puedan entender.Lo mas seguro es que la forma en que lo estoy haciendo nos es la adecuada, ¿Alguno de ustedes me podria ayudar con un poco de lo logica o codigo? Gracias de antemano. =)

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Cid

Y el Stacktrace ?

Seria conveniente ver tu clase completa, así como el Stacktrace para determinar donde esta la falla, sin embargo puede ser que el metodo readObject() es el que te este enviando el NullPointerException si es que no logra leer el objeto. Y tu còdigo tiene una llave que no se que hace ahi ?
 //CLIENTE

     while(true){
                  opcion=entrada.readInt();
                 
                    switch(opcion){
                       
                        case 5:
                            Detalle_Fallas det =null;
                }  // <----- Esta que hace ? no creo que aquí acabe tu switch y otra cosa falla en el case 4 o case 5 ?

                                //ESTO SI LO HACE BIEN
                            int[] datosCliente = vcli.obtenerDatos();
                            mandarPorSocket(3);//    Le indica al servidor que reciba un objeto
                            mandarObjeto(datosCliente);  
                           

                               //AQUI ES DONDE HAY PROBLEMAS
                           
                            for (int i = 0; i < Principal.lstFallas.size(); i++) {
                                mandarPorSocket(4);//Se le indica al servidor que reciba un objeto
                                det =Principal.lstFallas.get(i);
                              mandarObjeto(det);                            
                            }
                            break;
     
                }
                opcion=0;
             }

Imagen de paranoid_android

Podrías

Intenta buscar algún caracter extraño, podrias buscar tramas que esta enviando y que no esta recibiendo para ver cual genera un error.

Imagen de n00b

solo copie las partes del

solo copie las partes del código donde creo esta el error y se me fue por ahí una llave, solo mostré los case que me están fallando por eso me salte al 5 disculpen si eso causo confución(debí preverlo una disculpa). Pondre las clases completas espero esto ayude un poco mas unque se que han dicho que no es muy recomendable hacerlo.

Este es el hilo que maneja a los clientes en el servidor, se crea uno cada vez que un cliente se conecta.

package Servidor;

import clases.Detalle_Fallas;
import java.io.*;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.Semaphore;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author David
 */

class threadServidor extends Thread {
    int opcion;
    Socket comunicacion, comunicacion2;
    Servidor vent;
    DataInputStream recibir, recibir2;
    DataOutputStream mandar, mandar2;
    ObjectInputStream recibirObjeto;
    String nombreUsu;
    int [] posAleatorias;
    int posActual=0;
    public static Vector<threadServidor> clientesActivos=new Vector();
    public static ArrayList<Datos_Estadisticas> lstDatos = new ArrayList<Datos_Estadisticas>();
    public static ArrayList<Detalle_Fallas> det;
    protected Semaphore semaforo;
   
    public threadServidor(Socket comunicacion,Socket comunicacion2, Servidor vent){
      this.comunicacion=comunicacion;
      this.comunicacion2= comunicacion2;
      this.vent=vent;
      clientesActivos.add(this);
      semaforo = new Semaphore(1);
    }

    public void setOpcion(int opcion) {
        this.opcion = opcion;
    }  
   
    public String getNombreUsu() {
        return nombreUsu;
    }

    public void setNombreUsu(String nombreUsu) {
        this.nombreUsu = nombreUsu;
    }

   
    public void mandarPorSocket(int opcion) throws InterruptedException{
        try {
            this.mandar.writeInt(opcion);
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
   public void mandarPorSocket2(int opcion) throws InterruptedException{
        try {
           
            this.mandar2.writeInt(opcion);
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

   
    @Override
    public void run(){
        try {
           
           
            recibir = new DataInputStream(comunicacion.getInputStream());
            mandar = new DataOutputStream(comunicacion.getOutputStream());
            recibir2 = new DataInputStream(comunicacion2.getInputStream());
            mandar2 = new DataOutputStream(comunicacion2.getOutputStream());
            recibirObjeto = new ObjectInputStream(comunicacion.getInputStream());
           
            setNombreUsu(String.valueOf(recibir.readUTF()));          
            vent.mostrar("Jugador agregado>> "+getNombreUsu());
            vent.añadirUsuario(getNombreUsu());
           
            for (int i = 0; i < clientesActivos.size(); i++) {
                threadServidor user= null;
                user = clientesActivos.get(i);
                for (int j = 0; j < clientesActivos.size(); j++) {
                user.mandar.writeInt(3);
                user.mandar2.writeUTF(clientesActivos.get(j).getNombreUsu());
                }              
            }
           
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }      
//       posAleatorias = vent.getPosAleatorias();
//        System.out.println("thread serv hay "+posAleatorias.length);
     String mensaje="";
     
     boolean escuchar=true;
        while(escuchar){
            try {
                int opcion = recibir.readInt();
                switch(opcion){
                    case 1:  
                        escuchar=false;
                        break;
                    case 2:
                        mensaje = recibir.readUTF();
                        if(mensaje.equals("gane")){
                            vent.mostrar(this.getNombreUsu()+" ha ganado");
                           
                            for (int i = 0; i < clientesActivos.size(); i++) {
                               threadServidor user= null;
                               if(!clientesActivos.get(i).getNombreUsu().equals(this.getNombreUsu())){
                                  user = clientesActivos.get(i);
                                  user.mandar.writeInt(2);
                                  user.mandar2.writeUTF(this.getNombreUsu());
                               }
                            }
                            OpcionesServ op = new OpcionesServ(vent,true,this.getNombreUsu(),vent);
                            op.setVisible(true);                            
                        }
                        break;
                   
                    case 3:
                        Datos_Estadisticas datos =null;
                try {
                   
                    int [] datosCliente = (int[]) recibirObjeto.readObject();
                   datos = new Datos_Estadisticas(getNombreUsu(), datosCliente[2],
                           Servidor.totalJuegos-datosCliente[2], datosCliente[0], datosCliente[1]);                
                   lstDatos.add(datos);
                   
                 //  det = (ArrayList<Detalle_Fallas>) recibirObjeto.readObject();
                   
                   
                   
                } catch (IOException | ClassNotFoundException ex) {
                    Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
                }
                        break;
                       
                    case 4:
                        Detalle_Fallas obj=null;
                try {
                    obj = (Detalle_Fallas)recibirObjeto.readObject();
                    det.add(obj);

                    System.out.println("Recibi un paquete de: "+this.getNombreUsu());
                } catch (Exception ex) {
                    Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
                }
                        break;
                       
                }
               
            } catch (IOException ex ) {
                break;
            }
        }      
       vent.mostrar(this.nombreUsu+" Se desconecto");
       clientesActivos.removeElement(this);
       vent.removerUsuario(nombreUsu);
       
       try
        {
         
          comunicacion.close();
          comunicacion2.close();
        }      
        catch(Exception ex)
        {vent.mostrar("no se puede cerrar el socket");}
    }          
}

Este es el hilo que maneja al cliente.

package Cliente;

import clases.Detalle_Fallas;
import java.io.*;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

/**
 *
 * @author David
 */

public class threadCliente extends Thread{
   
    int opcion=0;
    static DataInputStream entrada,entrada2;
    static DataOutputStream salida;
    static ObjectOutputStream salidaObjeto;
    Principal vcli;
    Socket comunication;
    String ip;
   
    public threadCliente(DataInputStream entrada,DataInputStream entrada2, DataOutputStream salida,ObjectOutputStream salidaObjeto, Principal vcli,Socket comunication, String ip){
       this.entrada = entrada;
       this.entrada2 = entrada2;
       this.salida = salida;
       this.vcli = vcli;
       this.ip = ip;
       this.salidaObjeto = salidaObjeto;      
    }
   
    public static void mandarPorSocket(int opcion){
        try {
            salida.writeInt(opcion);
        } catch (IOException ex) {
            Logger.getLogger(threadCliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
    public static void mandarPorSocket2(String mensaje){
        try {
            salida.writeUTF(mensaje);
        } catch (IOException ex) {
            Logger.getLogger(threadCliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
    public static void mandarObjeto(Object objeto) throws IOException{
        salidaObjeto.writeObject(objeto);
    }
   
    String mensaje="";
   
    @Override
    public void run(){
        try {
            while(true){
                  opcion=entrada.readInt();
                   System.out.println(ConexionCliente.nomCliente+">> Mensaje recibido del servidor: "+opcion +"<<opcion");
                    switch(opcion){
                        case 1:
                            int posicion = entrada2.readInt();
                            System.out.println(ConexionCliente.nomCliente+">>Mensaje recibido del servidor: "+posicion+"<<Posicion");
                            vcli.siguienteBaraja(posicion);
                            break;
                        case 2:
                            String ganador = entrada2.readUTF();
                            Opciones2 op = new Opciones2(vcli,true, ganador, vcli);
                            op.setVisible(true);
                            break;
                           
                        case 3:

                          mensaje = entrada2.readUTF();                          
                          vcli.agregarUsuario(mensaje);
                            break;
                           
                        case 4:
                            mensaje = entrada2.readUTF();
                            vcli.eliminarUsuario(mensaje);
                            break;
                           
                        case 5:
                            Detalle_Fallas det =null;

                            int[] datosCliente = vcli.obtenerDatos();
                            mandarPorSocket(3);
                            mandarObjeto(datosCliente);  
                           
                           
                            for (int i = 0; i < Principal.lstFallas.size(); i++) {
                                mandarPorSocket(4);
                                det =Principal.lstFallas.get(i);
                              mandarObjeto(det);
                                System.out.println("mande el paquete: "+i);
                             
                            }
                            break;    
                }
                opcion=0;
             }
       
        } catch (IOException ex) {
            int confirmado = JOptionPane.showConfirmDialog(vcli, "Se perdio la conexion con el servidor\n¿Desea reconectarse?");
           
            if(JOptionPane.OK_OPTION==confirmado){
               ConexionCliente con = new ConexionCliente(vcli, ip);
               con.Conectar();
               
              vcli.lstJugadores.removeAll();
            }else{
                System.exit(0);
            }
           
           
        }  
  }  
   
}

Asi les digo a los clientes que me manden la información

threadServidor user=null;      
        for (int i = 0; i < threadServidor.clientesActivos.size(); i++) {
            try {
                user=threadServidor.clientesActivos.get(i);
                user.mandarPorSocket(5);
            } catch (InterruptedException ex) {
                Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
            }
       }

Espero no se ofendan por la cantidad de lineas(aunque se que tampoco son muchas). La clase Detalle_fallas implementa la interfaz serializable solo para aclarar.

Imagen de Cid

Posibles errores

Hola bueno sigue un poco escueto porque no se que pase con tus clases Principal.DetalleFallas pero segun estas serializando y mandando esos datos ahi por lo que cuentas si cumple con implementar Serializable, entonces no hay problema, la falla entonces se puede deber a:

Si es el case 4:

el metodo readUTF() no este leyendo nada.

Si es el caso 5:

Aqui puede ser que el metodo obtenerDatos() no este devolviendo el arreglo.

Imagen de n00b

Aclaremos

Detalle_fallas es una clase que tiene atributos de tipo String y enteros, cada vez que el usuario falla al elegir una opcion se guardan detalles de esa falla como el nombre de la falla y cual es la opcion correcta, esto se guarda en un ArrayList de tipo Detalle_fallas(ArrayList), es decir se equivoca el usuario, se crea un objeto de la clase Detalle_fallas y se guarda en una lista de tipo Detalle_fallas. Quiero mandar esa lista al servidor para mostrar algunas estadisticas y graficarlas.Con el case 4 no hay problemas y el metodo obtenerDatos() si funciona, es decir si se manda ese arreglo de datos al servidor, lo que no se manda es la lista de objetos Principal.lstFallas, en concreto el siguiente bloque del case 5:

for (int i = 0; i < Principal.lstFallas.size(); i++) {
                                mandarPorSocket(4);
                                det =Principal.lstFallas.get(i);
                              mandarObjeto(det);
                                System.out.println("mande el paquete: "+i);
                             
                            }

El servidor deberia de recibirlos de la siguiente forma en el case 4:

case 4:
                        Detalle_Fallas obj=null;
                try {
                    obj = (Detalle_Fallas)recibirObjeto.readObject();
                    det.add(obj);
                    System.out.println("Recibi un paquete de: "+this.getNombreUsu());
                } catch (Exception ex) {
                    Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
                }
                        break;

Pero no lo hace -_- me manda un nullPointerException al intentar añadir el objeto a la lista(det.add(obj). No se si tenga algo que ver la concurrencia a la hora en que los clientes mandan datos al servidor, aunque segun tengo entendido que los metodos readObject, readInt, readUTF, etc. Bloquean el hilo hasta que entre otro dato, espero no haberles liado un poco mas -_-.

Imagen de paranoid_android

Ya pudiste reproducir el error

¿Ya conseguiste enviar datos que generan el mismo error?

Imagen de n00b

Al parecer tendre que

Al parecer tendre que intentarlo de una forma diferente.Mandare todos los datos en un arreglo(de la forma que si me funciona), estuve pensando que de alguna forma tengo que avisarle al servidor que ya mande todos los datos que me pidio, entonces el servidor mandara la peticion a otro cliente y asi sucesivamente con todos los clientes(que es lo que debi haber hecho desde el principio). Gracias a todos por sus respuestas :)

No pusiste el stacktrace,

No pusiste el stacktrace, pero si el error está en la sección que dices solo puede ser que el arreglo :"det" ( supongo que por detalle ) no está inicializado.

Mira:

              case 4:
                        Detalle_Fallas obj=null;
                     obj = (Detalle_Fallas)recibirObjeto.readObject();
                   //recibo el objeto y lo agrego a una lista
                    det.add(obj);
                        break;

Si det ( mejor nombralo "detalleFallas", los discos de hoy en día tienen varios gigas de espacio ) es nulo , estás invocando null.add(obj); y eso resulta en NullPointerException.

Inicializalo e intenta de nuevo.

Muy bien por poner el código ( vaya.. así es más fácil que simplemente adivinar ) ahora el siguiente paso es que hagas un esfuerzo extra por hacerlo legible. A tu compilador no le importa nada, pero para los que lo leemos de este lado nos cuesta.

Espero que eso te ayude. Le voy a dar una formateada el código para que veas a que me refiero.

Saludos.

No estaba tan mal :)package

No estaba tan mal :)

package Servidor;
import clases.Detalle_Fallas;
import java.io.*;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.Semaphore;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @author David
 */

class ThreadServidor extends Thread {
    private int opcion;
    private Socket comunicacion;
    private Socket comunicacion2;
    private Servidor vent; // vent?
    private DataInputStream recibir;
    private DataInputStream recibir2;
    private DataOutputStream mandar;
    private DataOutputStream mandar2;
    private ObjectInputStream recibirObjeto;
    private String nombreUsu;
    private int [] posAleatorias;
    private int posActual=0;

    protected Semaphore semaforo;

    public static List<ThreadServidor> clientesActivos=new ArrayList<ThreadServidor>();
    public static List<Datos_Estadisticas> lstDatos = new ArrayList<Datos_Estadisticas>();
    public static List<Detalle_Fallas> det; // <--- Donde se inicaliza??
   
    public ThreadServidor(Socket comunicacion,Socket comunicacion2, Servidor vent) {
      this.comunicacion=comunicacion;
      this.comunicacion2= comunicacion2;
      this.vent=vent;
      ThreadServidor.clientesActivos.add(this);
      this.semaforo = new Semaphore(1);
    }
    public void setOpcion(int opcion) {
        this.opcion = opcion;
    }  
   
    public String getNombreUsuario() { // Usu -> Usuario
        return nombreUsu;
    }
    public void setNombreUsuario(String nombreUsu) {
        this.nombreUsu = nombreUsu;
    }
   
    public void mandarPorSocket(int opcion) throws InterruptedException{
        try {
            this.mandar.writeInt(opcion);
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
   public void mandarPorSocket2(int opcion) throws InterruptedException{
        try {
           
            this.mandar2.writeInt(opcion);
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
    @Override
    public void run(){
        try {
           
           
            recibir         = new DataInputStream(comunicacion.getInputStream());
            mandar          = new DataOutputStream(comunicacion.getOutputStream());
            recibir2        = new DataInputStream(comunicacion2.getInputStream());
            mandar2         = new DataOutputStream(comunicacion2.getOutputStream());
            recibirObjeto   = new ObjectInputStream(comunicacion.getInputStream());
           
            setNombreUsuario(String.valueOf(recibir.readUTF()));          
            vent.mostrar("Jugador agregado>> "+getNombreUsuario());
            vent.añadirUsuario(getNombreUsuario());
           
            for (int i = 0; i < clientesActivos.size(); i++) {
                threadServidor user= null;
                user = clientesActivos.get(i);
                for (int j = 0; j < clientesActivos.size(); j++) {
                    user.mandar.writeInt(3);
                    user.mandar2.writeUTF(clientesActivos.get(j).getNombreUsuario());
                }              
            }
           
        } catch (IOException ex) {
            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
        }      
        //       posAleatorias = vent.getPosAleatorias();
        //        System.out.println("thread serv hay "+posAleatorias.length);
         String mensaje="";
     
        boolean escuchar=true;
        while(escuchar){
            try {
                int opcion = recibir.readInt();
                switch(opcion){
                    case 1:  
                        escuchar=false;
                        break;
                    case 2:
                        mensaje = recibir.readUTF();
                        if (mensaje.equals("gane")) {
                            vent.mostrar(this.getNombreUsuario()+" ha ganado");
                           
                            for (int i = 0; i < clientesActivos.size(); i++) {
                               threadServidor user= null;
                               if (!clientesActivos.get(i).getNombreUsuario().equals(this.getNombreUsuario())) {
                                  user = clientesActivos.get(i);
                                  user.mandar.writeInt(2);
                                  user.mandar2.writeUTF(this.getNombreUsuario());
                               }
                            }
                            OpcionesServ op = new OpcionesServ(vent,true,this.getNombreUsuario(),vent);
                            op.setVisible(true);                            
                        }
                        break;
                   
                    case 3:
                        Datos_Estadisticas datos =null;
                        try { // try dentro del try? ¬¬
                           
                            int [] datosCliente = (int[]) recibirObjeto.readObject();
                            datos = new Datos_Estadisticas(getNombreUsuario(),
                                                            datosCliente[2],
                                                            Servidor.totalJuegos-datosCliente[2],
                                                            datosCliente[0], datosCliente[1]);                
                            lstDatos.add(datos);
                                                           
                            //  det = (ArrayList<Detalle_Fallas>) recibirObjeto.readObject(); // ¬¬
                        } catch (IOException | ClassNotFoundException ex) {
                            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        break;
                       
                    case 4:
                        Detalle_Fallas obj=null;
                        try {
                            obj = (Detalle_Fallas)recibirObjeto.readObject();
                            det.add(obj);
                            System.out.println("Recibi un paquete de: "+this.getNombreUsuario());
                        } catch (Exception ex) {
                            Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
                        }
                                break;
                       
                }
               
            } catch (IOException ex ) {
                break;
            }
        }      
       vent.mostrar(this.nombreUsu+" Se desconecto");
       clientesActivos.removeElement(this);
       vent.removerUsuario(nombreUsu);
       
        try {
          comunicacion.close();
          comunicacion2.close();
        } catch(Exception ex) {
           vent.mostrar("no se puede cerrar el socket");
        }
    }          
}

Cada vez que anidas un if, dentro de otro if, dentro de otro... se hace un poquíto más dificil seguir el hilo. Agerga métodos auxiliares para que se vaya limpiando el codigo, tu run debería de verse así:

private final static int DETENERSE = 0;
...

// ejemlpos
private void envia() {
    try {
        inicializa(); // donde inciializas tus objetos.
        escribeUsuariosConectados(); // el for ... y eso
    } catch (IOException ex) {
        Logger.getLogger(threadServidor.class.getName()).log(Level.SEVERE, null, ex);
    }      
}
public void run() {
    envia();
    lee(); //  el while
    terminar(); // el usuario se desconecto y etc.
}
private void lee() {

    boolean escuchar=true;
    while(escuchar){
        try {
            int opcion = recibir.readInt();
            switch(opcion){
                case DETENERSE:  
                    escuchar=false;
                break;
                case GANO:
                    usuarioHaGanado(); // donde dice "El usuario blah gano etc.    
                break;                    
                case ESTADISTICAS:
                    mostrarEstadisticas();
                break;

                case FALLAS: fallas(); // donde muestras las fallas y eso                      
            }                
        } catch (IOException ex ) {
                break;
        }
    }
}

Cada método chiquito que se pone ahí te sirve incluso de documentación.

Ese es un ejemplo de como ditribuir el código para que sea más legible.

Espero que te sea de ayuda.

Saludos

Imagen de n00b

Gracias por tus comentarios.

Gracias por tus comentarios. Se que me alejo mucho de las buenas practicas de programacion, te pondria de pretexto infinidad de cosas pero la verdad es por no leer un poco mas, ¿tendras algo de teoria para leer? nunca es tarde para comenzar jeje :P

Si, y no es regaño ni nada,

Si, y no es regaño ni nada, es ayuda.

Para leer empieza pro esto:

http://www.javamexico.org/foros/java_standard_edition/manadar_muchos_obj...

:)

Imagen de n00b

Comprendo, corregiré lo que

Comprendo, corregiré lo que me indicaste y te cuento que pasa. Tal vez abuso de tu confianza pero me podrias ayudar con el requerimiento que comente hace un rato.

"estuve pensando que de alguna forma desde el cliente tengo que avisarle al servidor que ya mande todos los datos que me pidio, entonces el servidor mandara la peticion a otro cliente y asi sucesivamente con todos los clientes activos(que es lo que debi haber hecho desde el principio)".

Tal vez no sea posible con codigo, pero algo de logica me basta. Gracias de antemano. :)

Como diría un amigo, me fui

Como diría un amigo, me fui por la fácil y solo revisé tu código ya no ví ni que hace o cual es el diseño detrás así que no podría opinar, pero te puedo dar una idea.

Como funciona por ejemplo el modelo HTTP es que el cliente le pide datos al servidor y este le devuelve los datosy se cierra la conexión. Al pedirselo también puede mandas datos.

Podías hacer algo similar, hacer que el cliente se conecte al servidor y le mande su estatus. El servidor lo atiende y le responde el estatus de los demas jugadores ( que tiene almacenado en algún lado )

Algo así: ( pseudo-código: nombrevariable TipoDato )

Client {

    // Corre!!
    // Toma la direccion del servidor
    // y en un loop infinito
    // le envia el estatus al servidor        
    run() {

        serverAddress = ServerAddress("192.168.0.1:8888")
        whileTrue(() {
            takeTurn()
            sendStatus( to: serverAddress )
        })

    }
   
    // Se conecta el servidor
    // crea la petición con el estatus del cliente
    // se la manda al server y espera respuesta  
    // después hace algo con esa respuesta
    // y se desconecta
    sendStatus( to ServerAddress ) {
        server = connecToServer( to )
        request = createRequest(with: clientStatus() )
        response = server.send(request)
        updateClient(with: response )
        server.disconnect()
    }
    ...
}

Server {
    // un mapa donde se tiene el estado de los jugadores
    players Map<Int,Status>

    // Obtiene el cliente de la peticion
    // almacena su estatus    
    // y pone en la respeusta el estatus de los demás
    // envía la respuesta de regreso    
    handle( request Request, response Response ) {
       
        client = request.client()
        players.put(key: client.id(), value: client.status())
        players.each((entry) {
            response.addStatus( playerid: entry.key(), status: entry.value() )
        })
        send( response )
    }
    ...
}

Bueno algo así es la idea.

Este es solo un modelo en el que cada cliente le envía el servidor cada cierto tiempo su estatus, el servidor lo que hace es que lo almacena y se lo pasa al siguiente que se conecte. También puede aplicar reglas del juego.

Otra forma es teniendo una conexión permanente y estar empujando la información o jalandola. Otro ( que me parece es el que hiciste ) es teniendo dos canales abiertos, uno para leer y otro para escribir, ahí la comunicación es asíncrona, puedes estar escribiendo y de repente el server te escribe, un tanto más compleja.

En fin, espero que le entiendas al pseudo código

Saludos.

Imagen de n00b

Gracias por tus respuestas,

Gracias por tus respuestas, me guiare de tu pseudo código.

saludos.

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">