Java 如何使用 ObjectInputStream 读取

Question

这是我第一次使用套接字，为了更好地了解正在发生的事情，我决定构建一个可以支持多个用户的客户端服务器聊天应用程序。

一开始我用DataInputStream / DataOutputStream交流，一切正常。但我想切换到ObjectStream，这就是问题所在。一旦我将所有DataInputStream / DataOutputStream 替换为ObjectInputStream / ObjectOutputStream，我将无法再打印检索到的数据。

这是我之前使用的代码，它可以工作（DataStream）：

服务器：

       try {
            DataInputStream in = new DataInputStream(socket.getInputStream());
            DataOutputStream out = new DataOutputStream(socket.getOutputStream());

            out.writeUTF("HI FROM SERVER");
            while (!socket.isClosed()) {
                try {
                    if (in.available() > 0) {
                        String input = in.readUTF();
                        for (ClientThread thatClient : server.getClients()){
                            DataOutputStream outputParticularClient = new DataOutputStream(thatClient.getSocket().getOutputStream());
                            outputParticularClient.writeUTF(input + " GOT FROM SERVER");
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

客户：

try {
    socket = new Socket("localhost", portNumber);


    DataInputStream in = new DataInputStream(socket.getInputStream());
    new Thread(()->{
        while(!socket.isClosed()){
            try {
                if (in.available() > 0){
                    String input = in.readUTF();
                    System.out.println(getUserName() + " > " + input);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
} catch (IOException e) {
    e.printStackTrace();
}

这就是我尝试使用 ObjectStream 执行相同想法的方式：

服务器：

try {
    ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
    ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());

    while (!socket.isClosed()) {
        try {
            if (in.available() > 0) {
                Message input;
                try {
                    input = (Message)in.readObject();
                    if (input.equals(null)){
                        System.err.println("SERVER RETRIEVED NULL OBJECT");
                    }
                    for (ClientThread thatClient : server.getClients()){
                        ObjectOutputStream outputParticularClient = new ObjectOutputStream(thatClient.getSocket().getOutputStream());
                        outputParticularClient.writeObject(input);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
} catch (IOException e) {
    e.printStackTrace();
}

客户：

try {
            socket = new Socket(getHost(), portNumber);

            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            new Thread(()->{
                while(!socket.isClosed()){
                    try {
                        if (in.available() > 0){
                            Message input = null;
                            try {
                                input = (Message)in.readObject();
                                if (input.equals(null)){
                                    System.err.println("CLIENT RETRIEVED NULL OBJECT");
                                }
                                System.out.println("CLIENT " + input.toString());
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        } catch (IOException e) {
            e.printStackTrace();
        }

我觉得这与这个 if 语句 if (in.available() > 0) 有关，但我不能准确地说出发生了什么。

Answer 1

available() 不会像您认为的那样做，而且它在生产代码中几乎从来没有用过（对于ObjectInputStream 尤其如此）。您没有收到任何数据的原因实际上是 in.available() 总是返回 0，正如您已经怀疑的那样。

如 cmets 中所述，StreamCorruptedException 是由使用 ObjectOutputStream 的另一个实例写入已经写入的现有 ObjectInputStream 引起的。参照。答案StreamCorruptedException: invalid type code: AC作进一步解释。

这是一些快速而肮脏的示例代码，其中有一个服务器回显来自两个客户端的消息。它并不干净，但它可能会让您知道如何解决您的问题：

public class SO56493162 {

   private static final class Message implements Serializable {
      private static final long serialVersionUID = 1L;
      private static int cnt = 0;
      private final int id;

      public Message(int id) {
         ++cnt;
         this.id = id;
      }

      public String toString() {
         return "Msg from " + id + " : " + cnt;
      }
   }

   private static final class Client implements Runnable {
      private InetSocketAddress addr = null;
      private int id = -1;

      Client(InetSocketAddress addr, int id) {
         this.addr = addr;
         this.id = id;
      }

      public void run() {
         int timeout = 3000;
         Socket s = null;
         try {
            s = new Socket();
            s.connect(addr, timeout);
            ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
            ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
            System.out.println("Client " + id + " connected");
            while (true) {
               Thread.sleep(new Random().nextInt(2000));
               Message hello = new Message(id);
               oos.writeObject(hello);
               oos.flush();
               Message reply = (Message) ois.readObject();
               System.out.println("Reply: " + reply.toString());
            }
         } catch (Exception e) {
            e.printStackTrace();
         } finally {
            try {
               s.close();
            } catch (Exception ignore) {
            }
         }
      }
   }

   private static final class Server implements Runnable {
      private ServerSocket sock = null;

      Server(ServerSocket sock) throws IOException {
         this.sock = sock;
      }

      public void run() {
         System.out.println("starting server");
         try {
            while (true) {
               final Socket client = sock.accept();
               System.out.println("connection accepted");
               Thread t = new Thread(new Runnable() {
                  @Override
                  public void run() {
                     try {
                        ObjectInputStream ois = new ObjectInputStream(client.getInputStream());
                        ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
                        while (!client.isClosed()) {
                           try {
                              Message input = (Message) ois.readObject();
                              oos.writeObject(input);
                              oos.flush();
                           } catch (EOFException eof) {
                              System.err.println("EOF!");
                              client.close();
                           }
                        }
                     } catch (Exception e) {
                        e.printStackTrace();
                     }
                  }
               });
               t.setDaemon(true);
               t.start();
            }
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
   }

   public static void main(String args[]) throws IOException, InterruptedException {
      final int port = 9876;

      Thread ts = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               new Server(new ServerSocket(port)).run();
            } catch (Exception e) {
               e.printStackTrace();
            }
         }
      });
      ts.setDaemon(true);
      ts.start();

      InetSocketAddress addr = new InetSocketAddress("localhost", port);

      for (int i = 0; i < 2; ++i) {
         Client cl = new Client(addr, i);
         Thread tc = new Thread(cl);
         tc.setDaemon(true);
         tc.start();
      }

      Thread.sleep(10000);
      System.err.println("done");
   }
}