为什么在客户端读取服务器端返回的数据时，要将代码放到while循环中

客户端

1. /*
   
2. * 客户端往服务器发送数据，数据来源于键盘录入  
   
3. * 服务器给客户端一个反馈，返回该数据的大写表示。
   
4. *
   
5. */
   
6. public class ClientDemo3 {
   
7.         public static void main(String[] args) throws IOException {
   
8.                 // 创建客户端对象
   
9.                 Socket s = new Socket(InetAddress.getLocalHost(), 12306);
   
10. 
    
11.                 // 包装键盘录入
    
12.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
13.                 // 把客户端直接获取到的输出流对象用BufferedWriter包装
    
14.                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
    
15.                                 s.getOutputStream()));
    
16. 
    
17.                 // 包装一个读取数据的流对象
    
18.                                         BufferedReader brServer = new BufferedReader(new InputStreamReader(
    
19.                                                         s.getInputStream()));
    
20. 
    
21.                 // 基本读写
    
22.                 String line = null;
    
23.                 while ((line = br.readLine()) != null) {
    
24.                         // 判断是否over
    
25.                         if ("over".equals(line)) {
    
26.                                 break;
    
27.                         }
    
28. 
    
29.                         // 发给服务器
    
30.                         bw.write(line); //haha
    
31.                         bw.newLine();//加上\r\n
    
32.                         bw.flush();//刷新
    
33. 
    
34.                         // 获取服务器数据
    
35.                         String server = brServer.readLine(); <font color="#ff0000">//为什么这段代码要放到while循环里面</font>
    
36.                         System.out.println("server:"+server);
    
37.                 }
    
38. 
    
39.                 // 释放资源
    
40.                 br.close();
    
41.                 s.close();
    
42.         }
    
43. }

复制代码

服务器

1. /*
   
2. * 服务器接收客户端的数据，转成大写，返给客户端
   
3. */
   
4. public class ServerDemo3 {
   
5.         public static void main(String[] args) throws IOException {
   
6.                 // 创建服务器的Socket服务对象
   
7.                 ServerSocket ss = new ServerSocket(12306);
   
8. 
   
9.                 // 获取当前的连接的客户端
   
10.                 Socket s = ss.accept();
    
11. 
    
12.                 // 包装读取数据
    
13.                 BufferedReader br = new BufferedReader(new InputStreamReader(
    
14.                                 s.getInputStream()));
    
15. 
    
16.                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
    
17.                                 s.getOutputStream()));
    
18. 
    
19.                 // 获取客户端数据，转成大写，返回
    
20.                 String line = null;
    
21.                 while ((line = br.readLine()) != null) {
    
22.                         // 用于检测服务器是否接受到数据了
    
23.                         System.out.println("数据:" + line);
    
24.                         bw.write(line.toUpperCase());
    
25.                         bw.newLine();
    
26.                         bw.flush();
    
27.                 }
    
28. 
    
29.                 // 释放资源
    
30.                 s.close();
    
31.                 ss.close();
    
32.         }
    
33. }

复制代码

这个是为了当服务器有数据发到客户端时，客户端能及时收到

一、TCP的基本概念 TCP是专门设计用于在不可靠的英特网上提供可靠的、端到端的字节流通信的协议，是一个面向连接的协议，TCP连接是字节流而非报文流。UDP和TCP各有65536个端口号互不影响。 二、单线程服务端 以下代码只能实现服务端和客户端的同步对话。服务

一、TCP的基本概念　　TCP是专门设计用于在不可靠的英特网上提供可靠的、端到端的字节流通信的协议，是一个面向连接的协议，TCP连接是字节流而非报文流。UDP和TCP各有65536个端口号互不影响。
　　二、单线程服务端
　　以下代码只能实现服务端和客户端的同步对话。服务端处理完一个客户端请求，才会处理另一个客户端请求。服务器端的输出效果是Client1阻塞20秒，Client2不会执行。必须等Client1阻塞结束之后，Client2才会执行。该例子可用来学习TCP的基本语法。
　　/**
　　* TCP客户端1
　　*
　　*
　　*/
　　public class Client1
　　{
　　public static void main（String[] args） throws Exception
　　{
　　Socket socket = new Socket（"127.0.0.1", 8821）；
　　OutputStream os = socket.getOutputStream（）；
　　String msg = "黑马1";
　　Thread.sleep（20000）；
　　os.write（msg.getBytes（））；
　　os.flush（）；
　　os.close（）；socket.close（）；
　　}
　　}
　　/**
　　* TCP客户端2
　　*
　　*/
　　public class Client2
　　{
　　public static void main（String[] args） throws Exception
　　{
　　Socket socket = new Socket（"127.0.0.1", 8821）；
　　OutputStream os = socket.getOutputStream（）；
　　String msg = "黑马2";
　　os.write（msg.getBytes（））；
　　os.flush（）；
　　os.close（）；socket.close（）；
　　}
　　}
　　/**
　　* 单线程TCP服务端
　　*
　　*
　　*/
　　public class Server
　　{
　　public static void main（String[] args） throws Exception
　　{
　　// 创建端口为8821的TCP服务器端对象
　　// 8821是服务器端的端口号而客户端从某端口A连到8821,端口A是随机的
　　ServerSocket serverSocket = new ServerSocket（8821）；
　　while （true）
　　{
　　// 若无客户端发送请求则线程在此阻塞，方法不继续执行
　　Socket socket = serverSocket.accept（）；
　　System.out.println（"connected"）；
　　InputStream instream = socket.getInputStream（）；
　　ByteArrayOutputStream bos = new ByteArrayOutputStream（）；
　　int len = 0;
　　byte[] buffer = new byte[1024];
　　while （（len = instream.read（buffer）） != -1）
　　{
　　bos.write（buffer, 0, len）；
　　}
　　instream.close（）；
　　bos.flush（）；
　　bos.close（）；
　　String msg = bos.toString（）；
　　System.out.println（"客户端的IP:" + socket.getInetAddress（）。getHostAddress（））；
　　System.out.println（"客户端的端口：" + socket.getPort（））；
　　System.out.println（"客户端的信息：" + msg）；
　　}
　　}
　　}

因为服务器端可能发送很多行消息，但是用了readline()方法一次只能读取一行所以要用while()循环。