客户-服务器套接字编程

Question

I have written client-server message sending program using sockets in Java, which is working fine, but if the string length of the previous message is greater than the present in.read(b5) , string message is printed with previous message characters added to it. This problem is due to previous stored characters in byte array.

How to clear the byte array for every loop? How can I resolve this?

CLIENT code:

try
  {
    String add=args[0];
    int port=Integer.parseInt(args[1]);
    Socket s=new Socket(add,port);
    OutputStream out=s.getOutputStream();
    InputStream in=s.getInputStream();
    BufferedReader bufIn = new BufferedReader( new InputStreamReader( in ) );
    BufferedWriter bufOut = new BufferedWriter( new OutputStreamWriter( out ) );
    byte b1[]=new byte[100];
    byte b2[]=new byte[100];
    while(true)//infinite loop
    {
      System.out.println("To Server:");
      System.in.read(b1);  //reading from keyboard
      out.write(b1);       //writing to server
      in.read(b2);         //reading from server            
      String s1=new String(b2);
      String s2=s1.trim();
      System.out.println("From Server:"+s2);
    }   
  }
  catch (Exception e)
  {
    System.err.println(e);
  }

SERVER code:

try
{       
  int port=Integer.parseInt(args[0]);
  ServerSocket ss=new ServerSocket(port);
  while(true)   //this loop for diff. no. of clients
  {
    Socket s=ss.accept();               
    InputStream in=s.getInputStream();
    OutputStream out=s.getOutputStream();
    byte b1[]=new byte[100];
    byte b2[]=new byte[100];
    while(true)   //this loop for one client diff. no. of times.
    {                   
      in.read(b1);
      String s1=new String(b1);
      String s2=s1.trim();
      System.out.println("From Client:"+s2);
      System.out.print("To Client:");
      System.in.read(b2);
      out.write(b2);
    }
  } 
}
catch (Exception e)
{
  System.err.println(e);
}

Answer 1

add out.flush(); to the bottom of your loop. Read the javadoc for more info. See relevant part below:

"Flushes this output stream and forces any buffered output bytes to be written out. The general contract of flush is that calling it is an indication that, if any bytes previously written have been buffered by the implementation of the output stream, such bytes should immediately be written to their intended destination. "

Answer 2

you need to read till the stream is completely read. The same is applicable for write also

For writing/sending

System.out.println("To Server:");
            while (System.in.read(b1) != -1)
            {
                out.write(b1);// writing to server
            }

For reading

                   String s2 = "";

                do
                {
                    in.read(b1);
                    String s1 = new String(b1);
                    s2 += s1;
                } while (in.available() > 0);

Answer 3

It's related to the way you use b1 and b2 arrays. You are reusing the same array for every read, so the bytes that are not overridden by present read remain unchanged.

See Javadoc for InputStream.read:

The first byte read is stored into element b[0], the next one into b 1 , and so on. The number of bytes read is, at most, equal to the length of b. Let k be the number of bytes actually read; these bytes will be stored in elements b[0] through b[k-1], leaving elements b[k] through b[b.length-1] unaffected.

You can't use Arrays.fill(b1,0) because b1 is an array of bytes and 0 is a int. That is you are pretending to use Arrays.fill(byte[] b, int val) that does not exist.

Just cast 0 to byte and you are done:

Arrays.fill(b1, (byte)0);

In this case you are using method Arrays.fill(byte[] b, byte val) that does exist.