客户端：

1. import java.io.BufferedReader;
   
2. import java.io.BufferedWriter;
   
3. import java.io.IOException;
   
4. import java.io.InputStream;
   
5. import java.io.InputStreamReader;
   
6. import java.io.OutputStreamWriter;
   
7. import java.io.PrintWriter;
   
8. import java.net.Socket;
   
9. import java.net.UnknownHostException;
   
10. 
    
11. public class CopyOfTransClient {
    
12. 
    
13.         public static void main(String args[]) throws UnknownHostException,
    
14.                         IOException {
    
15.                 run();
    
16.                         }
    
17. 
    
18.        
    
19.         public static void run() throws UnknownHostException, IOException {
    
20.                 // 连接服务端、获取客户端输出流。
    
21.                 Socket socket = new Socket("192.168.0.3", 10009);
    
22. 
    
23.                 BufferedWriter bwso = new BufferedWriter(new OutputStreamWriter(
    
24.                                 socket.getOutputStream()));
    
25. 
    
26.                 // 获取键盘录入。socket输出流输出。
    
27.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
28.                
    
29.                 // socket输入流。
    
30.                 BufferedReader brso = new BufferedReader(new InputStreamReader(
    
31.                                 socket.getInputStream()));
    
32. 
    
33.                 String str = null;
    
34.                 while ((str = br.readLine()) != null) {
    
35.                         if (str.equals("over"))
    
36.                                 break;
    
37.                         bwso.write(str);
    
38.                         bwso.flush();
    
39. 
    
40.                         // socket输入流。接受服务端的反馈。
    
41.                         String strso = brso.readLine();
    
42.                         System.out.println(strso);
    
43.                         bwso.close();
    
44.                         br.close();
    
45.                 }
    
46. 
    
47.         }
    
48. }

复制代码

服务端：

1. import java.io.BufferedReader;
   
2. import java.io.BufferedWriter;
   
3. import java.io.IOException;
   
4. import java.io.InputStream;
   
5. import java.io.InputStreamReader;
   
6. import java.io.OutputStream;
   
7. import java.io.OutputStreamWriter;
   
8. import java.net.ServerSocket;
   
9. import java.net.Socket;
   
10. 
    
11. public class CopyOfTransServer {
    
12.         public static void main(String args[]) throws IOException {
    
13.                 run();
    
14.         }               
    
15.        
    
16.         public static void run() throws IOException {
    
17.                 // 获取连接过来的客户端。
    
18.                 ServerSocket serverSocket = new ServerSocket(10009);
    
19.                 Socket socket = serverSocket.accept();
    
20.                
    
21.                 //获取ip
    
22.                 String ip = socket.getInetAddress().getHostAddress();
    
23.                 System.out.println(ip);
    
24. 
    
25.                 // 获取客户端流对象。
    
26.                 BufferedReader br = new BufferedReader(new InputStreamReader(
    
27.                                 socket.getInputStream()));
    
28. 
    
29.                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
    
30.                                 socket.getOutputStream()));
    
31.                
    
32.                 String str = null;
    
33.                 while ((str = br.readLine()) != null) {
    
34.                         bw.write(str.toUpperCase());
    
35.                 }
    
36.                 serverSocket.close();
    
37.                 socket.close();
    
38. 
    
39.         }
    
40. 
    
41. 
    
42. }
    

复制代码

哎，谁知毕老师接下来讲的就是这个问题！3个错误！
1.客户端write()方法后要进行刷新flush()，因为要写入的数据只是到了write()方法的缓冲区，没有写入预期目标。
2.因为客户端在34行没有读到结束标记“\r\n”(这点可以从毕老师讲的readLine()方法原理可以知道)，刷新后，服务端就在33行读，它读到了数据，但就是等不到结束标记，因为她是readLine()方法，他就一直等。造成了阻塞。所以，客户端在write()要加“\r\n”，服务端也要在write()加“\r\n”(因为客户端读取用的也是readLine()方法).
3.客户端43、44行的输出输入流不应该关。要关也应该在while循环外关。客户端也应该在while循环外关！

一、客户端
       1、的输出流brso，应加newLine方法，因为flush和newLine方法一般都是一起使用；

  2、关流动作应在循环外

这样写:
     import java.io.*;
import java.net.*;

class Client
{
        public static void main(String [] args)throws IOException
        {
                Socket s = new Socket("192.168.2.109",10002);
               
                BufferedReader bufr =
                        new BufferedReader(new InputStreamReader(System.in));
               
                BufferedWriter bufOut =
                        new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
               
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));
               
                String line = null;
                while((line = bufr.readLine()) != null)
                {
                        if("over".equals(line))
                                break;
                        bufOut.write(line);
                        bufOut.newLine();
                        bufOut.flush();
                        String str = bufIn.readLine();
                        System.out.println(str);
                }
                bufr.close();
                s.close();
        }
}
class Server
{
        public static void main(String [] args)throws IOException
        {
                ServerSocket ss = new ServerSocket(10002);
               
                Socket s = ss.accept();
               
                String ip = s.getInetAddress().getHostAddress();
               
                System.out.println(ip + "connected...");
               
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));
               
                BufferedWriter bufOut =
                        new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
               
                String line = null;
                while((line = bufIn.readLine()) != null)
                {
                        bufOut.write(line.toUpperCase());
                        bufOut.newLine();
                        bufOut.flush();
                }
                ss.close();
        }
}