java - 多线程文件服务器java

Question

我正在用 Java 实现一个并发文件服务器。

每个客户端都有自己的与服务器的通信 channel 。服务器运行一个线程来监听所有连接请求，并运行另一个线程来监听和应答每个连接。每个客户端运行一个线程用于与服务器通信，另一个线程用于监听服务器请求(其他客户端请求的文件)。

客户端

public class Cliente {
 private static String nombre;
 private InetAddress ip;
 private static Socket s;
 private static BufferedReader tCliente;
 private static PrintWriter fCliente;
 private static Usuario usr;
 private static String idCliente;

    public Cliente(){

    }

public static void main(String args[]){
        Cliente c=new Cliente();
        Scanner teclado=new Scanner(System.in);
        System.out.println("What´s your name?");
        nombre=teclado.nextLine();
        //construir cliente
        try {
            s= new Socket("ACER", 999);//¿Cómo obtengo la ip del Servidor?  192.168.1.101
            tCliente=new BufferedReader(new InputStreamReader(s.getInputStream()));
            fCliente=new PrintWriter(s.getOutputStream());
            MensajeConexion mConexion=
                    new MensajeConexion(InetAddress.getLocalHost().getHostName(), "ACER",nombre);
            fCliente.println(nombre);*/
            (new OyenteServidor(s,c)).start();

            while (true){
                System.out.println("Que deseas hacer?");
                System.out.println("1) Mostrar lista usuarios");
                System.out.println("2) Pedir fichero");
                System.out.println("3) Cerrar conexión");   
                int op = teclado.nextInt();
                switch (op) {
                case 1:
                break;
                case 2:
                    System.out.println("Que fichero quieres?");
                    String nombreFichero = teclado.nextLine();
                break;
                case 3:
                    s.close();
                break ;
                default:
                    System.err.println("Opción inválida");
                break;
                }
            }
        } 
        catch (IOException e) {

            e.printStackTrace();
        }


    teclado.close();
}
    public void print(String string) {
        System.out.println(string);
   }
}

服务器

public class Servidor {
private static InetAddress ipServer;
private static final int portServer=999;
private static ServerSocket listen;
private static BufferedReader fServer;
private static PrintWriter tServer;
private static Socket s;
private static Hashtable<String, Usuario> tUsuarios;
private static Hashtable<String, ObjectOutputStream> tCanales ;


public Servidor(){

}
public static void main(String args[]){
    Servidor ser=new Servidor();
    try {
        listen=new ServerSocket(portServer);
        ipServer=listen.getInetAddress();
        while(true){
            s=listen.accept();
            (new OyenteCliente(s,ser)).start();
        }
    } 
    catch (IOException e) {
        e.printStackTrace();
    }
}

public InetAddress getInetAdress(){
    return ipServer;
}

public synchronized void guardaFlujo(Usuario usr, ObjectOutputStream fOut) {
    tCanales.put(usr.getName(), fOut);

}
public synchronized void registra(Usuario usr) {
    tUsuarios.put(usr.getName(), usr);
}
}

服务器中监听每个客户端的线程在名为 OyenteCliente(ClientListener) 的类中实现，每个客户端监听服务器 petitios 的线程在 OyenteServidor(ServerListener) 中实现。

客户端监听器

public class OyenteCliente extends Thread {
    private Servidor servidor;
    private Socket s;   private ObjectInputStream fIn;
    private ObjectOutputStream fOut;
    private Usuario infoCliente;
    public OyenteCliente(Socket so,Servidor ser) {
       servidor=ser;
       s=so;
       try {
          fIn=new ObjectInputStream(s.getInputStream());//<---Server thread stops here
          fOut=new ObjectOutputStream(s.getOutputStream());
       } 
       catch (IOException e) {
          e.printStackTrace();
       }
    }


   @Override
   public void run() {
       while (true){
           try {
               Mensaje m= (Mensaje) fIn.readObject();
               TipoMensaje type = m.getTipo();
               switch (type) {
               case Conexion:
                   Usuario usr= new Usuario(((MensajeConexion) m).getUserName());
                servidor.registra(usr);
                servidor.guardaFlujo(usr,fOut);
                MensajeConfirmacion confirmacion = new MensajeConfirmacion(m.getDestino(),m.getOrigen());
                fOut.writeObject(confirmacion);
               break;
               case ListaUsuarios:
                /*
                 * -buscar info en tUsuarios
                 * -mandar msge conf lista usuarios
                 * */
               break;
               case EmitirFichero:
                /*
                 * -obtener info usuario que tiene fichero
                 * -mandar mensaje peticion fichero
                 * 
                 * */
               break;
               case PrepComCS:
                /*
                 * mandar mensaje preparar comunicacion SC
                 * */
               break;
               default:
                   System.err.println(m);
               break;
               }    
           }  
           catch (ClassNotFoundException e) {
               e.printStackTrace();
           }
           catch (IOException e) {  
               e.printStackTrace();
           }
       }
   }
}

服务器监听器

public class OyenteServidor extends Thread{
private Socket myS;
private ObjectInputStream fIn;
private ObjectOutputStream fOut;
private Cliente client;

public OyenteServidor(Socket s,Cliente clie) {
    client=clie;
    try {
        myS=s;
        fIn=new ObjectInputStream(myS.getInputStream());//<---Client thread stops here
        fOut=new ObjectOutputStream(myS.getOutputStream());
    } 
    catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
@Override
public void run(){
    while (true){
        try {
            Mensaje m = (Mensaje) fIn.readObject();
            TipoMensaje type=m.getTipo();
            switch (type) {
            case ConfConexion:
                client.print("Conexión confirmada");
            break;
            case ConfListaUsuarios:
            break;
            case PetFichero:
            break;
            case PrepComCS:
            break;
            default:
            break;
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

我必须通过传递消息(“ConectionRequest”，“FileRequest”..)来实现通信，因此当我创建每个套接字时，我尝试在每个监听器中使用 ObjectInputStream 和 ObjectOutputStream 来执行此操作。

调试(客户端和服务器)我刚刚发现，当两个进程使用 Socket.getInputStream() 初始化 ObjectInputStream 时，它们都会永远暂停。

有人能告诉我我错了吗？

非常感谢!

Answer 1

您需要在 ObjectInputStream 之前构造 ObjectOutputStream。

您还需要在两端构造相同的流。您当前的流混合将不起作用。

如果您希望它适用于多个线程，您还需要从头到尾删除关键字 static。