使用Java发送对象时如何停止从BufferedReader读取？

Question

I´m writing a java program that sends an object converted to a byte array through a socket. The client has to read all the bytes and translate it back to a Java Object. However I´m having my program stuck on a read() inside the loop where I read all bytes until I find a -1.

I've read the docs and it says that the read() method return a -1 when reaching the end of the stream, but this is not working.

Heres my code: Method for sending an object:

Socket socket;
BufferedReader input;
DataOutputStream output;
boolean connectionOpen;  //Just for you to know the types of the attributes of my class
 public void sendResponse(Object obj) throws IOException{

    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutput out = null;
    try {
      out = new ObjectOutputStream(bos);   
      out.writeObject(obj);
      byte[] yourBytes = bos.toByteArray();


      output.write(yourBytes);

    } finally {
      try {
        if (out != null) {
          out.close();
        }
      } catch (IOException ex) {
        // ignore close exception
      }
      try {
        bos.close();
      } catch (IOException ex) {
        // ignore close exception
      }
    }  


}     

Method For reading the bytes. (This is where my code gets stuck)

public Email getMail(int id) throws Exception{
    byte[] bytes = new byte[50000];
    Email result;
    try{
        this.outToServer.writeBytes("MAIL "+id+"\n");
        String response = inFromServer.readLine();
        String[] data = response.split(" ");
        int code = Integer.parseInt(data[0]); 
        if(code==500){
            throw new Exception("Error en servidor Pop4. Servidor respondio: "+response);
        }
        int current =  inFromServer.read();
                int i = 0;

        while(current!=-1){

            bytes[i]=(byte) current;
            i++;
            current= inFromServer.read();
        }
        //Convertimos el arreglo de bytes a un objeto Email
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInput in = null;
        try {
          in = new ObjectInputStream(bis);
          result = (Email) in.readObject(); 

        } finally {
          try {
            bis.close();
          } catch (IOException ex) {
            // ignore close exception
          }
          try {
            if (in != null) {
              in.close();
            }
          } catch (IOException ex) {
            // ignore close exception
              ex.printStackTrace();
          }
        }            
    }

    catch(Exception e){
            throw e;
    }
    return result;


}

Answer 1

I suggest you read one object at a time directly from the socket.

final ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());

public void sendMessage(Object obj) {
    out.writeObject(obj);
    out.reset();
    out.flush();
}

final ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

public Object readMessage() {
    return in.readObject();
}

In short, you need to know when you should stop reading or use a stream which does.

Answer 2

The docs are quite right that InputStream.read() returns -1 when it cannot transfer any bytes because it has reached the end of the stream. However, nothing in what you presented gives me any reason to think that condition will be satisfied.

End of stream corresponds to a condition in which it is certain that no more bytes ever will be received from the stream. That is not at all the same thing as there being no more bytes available at any given time. If the sender indeed has nothing further to say for the remaining life of the connection, then it should close the OutputStream for its end of the connection. After it does so, the reader should detect end-of-stream. You presented no evidence that you do that.

If the sender is not ready to close the stream, then you need to devise a different way for the receiver to know when to stop reading. That implies some kind of application-layer protocol on top of the stream. One of the simplest of such protocols involves sending messages consisting of a fixed-width byte-count followed by the specified number of bytes.