网络编程 p4 TCP编程

TCP编程

• 基本介绍
  
  
  
  • 基于客户端——服务端的网络通信；
    
  • 底层使用的是TCP/IP协议；
    
  • 应用场景举例：客户端发送数据，服务端接收并显示在控制台；
    
  • 基于Socket的TCP编程；
    
  
  
• 示意图
  

• netstat指令
  
  
  
  • netstat -an可以查看当前主机网络情况，包括端口监听情况和网络连接情况；
    
  • netstat -an|more可以分页显示；
    
  • 要求在dos控制台下执行 （win+r）
    说明：
    
    
    
    • Listening 表示某个端口在监听；
      
    • 如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息；
      
    
    
  
  
  
• 注意事项
  
  
  
  • 当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这端口是TCP/IP来分配的，是随机的；
    
    
  
  
• 应用案例
  
  
  
  
  • 客户端
    1. package com.hspedu.socket;
    3. import java.io.*;
    4. import java.net.InetAddress;
    5. import java.net.Socket;
    7. /**
    8. * @author: 86199
    9. * @date: 2023/5/15 15:18
    10. * @description: 字符流
    11. */
    12. public class SocketTCP03Client {
    13.     public static void main(String[] args) throws IOException {
    14.         //思路
    15.         //1. 连接服务端（ip，端口）
    16.         //解读：连接本机的 9999 端口，如果连接成功，返回Socket对象
    17.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
    18.         System.out.println("客户端 socket返回 = " + socket.getClass());
    19.         //2. 连接上后，生成Socket，通过socket.getOutputStream()
    20.         //  得到和socket对象关联的输出流对象
    21.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    22.         //3. 通过输出流，写入数据到 数据通道
    23.         bufferedWriter.write("hello, server");
    24.         bufferedWriter.newLine();//写入一个换行符，表示写入内容结束，要求对方使用readLine的方式来读
    25.         bufferedWriter.flush();//如果使用的字符流，需要手动刷新否则数据不会写入数据通道
    28.         //4. 通过socket.个体InputStream()读取客户端写入到数据通道的数据，显示
    29.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    30.         String s = bufferedReader.readLine();
    31.         System.out.println(s);
    33.         //5. 关闭流对象和socket，必须关闭
    34.         bufferedReader.close();
    35.         bufferedWriter.close();
    36.         socket.close();
    38.     }
    39. }

    复制代码
  • 服务端
    1. package com.hspedu.socket;
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    7. /**
    8. * @author: 86199
    9. * @date: 2023/5/15 15:18
    10. * @description: 字符流
    11. */
    12. public class SocketTCP03Server {
    13.     public static void main(String[] args) throws IOException {
    14.         //思路
    15.         //1. 在本机的9999端口监听，等待连接
    16.         //   细节：要求本机没有其他服务在监听9999
    17.         //   这个 ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
    18.         ServerSocket serverSocket = new ServerSocket(9999);
    19.         System.out.println("服务端，在9999端口监听，等待连接...");
    20.         //2. 当没有客户端连接9999端口时程序会阻塞，等待连接
    21.         //   如果有客户端连接，则会返回Socket对象，程序继续
    22.         Socket accept = serverSocket.accept();
    24.         System.out.println("服务端 socket = " + accept.getClass());
    26.         //3. 通过socket.个体InputStream()读取客户端写入到数据通道的数据，显示
    27.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));//读不到内容会阻塞
    28. //4. IO读取
    29.         String s = bufferedReader.readLine();
    30.         System.out.println(s);
    34.         //5. 通过输出流，写入数据到 数据通道
    35.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
    36.         bufferedWriter.write("hello, client");
    37.         bufferedWriter.newLine();//写入一个换行符，表示写入内容结束，要求对方使用readLine的方式来读
    38.         bufferedWriter.flush();//如果使用的字符流，需要手动刷新否则数据不会写入数据通道
    39.         //设置结束标记
    41.         //6. 关闭流对象和socket，必须关闭
    42.         bufferedWriter.close();
    43.         bufferedReader.close();
    44.         accept.close();
    45.         serverSocket.close();
    46.     }
    47. }

    复制代码
  
  
  
  
  • StreamUtils类
    1. package com.hspedu.upload;
    3. import java.io.BufferedReader;
    4. import java.io.ByteArrayOutputStream;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    8. /**
    9. * @author: 86199
    10. * @date: 2023/5/16 14:57
    11. * @description: 工具类
    12. */
    13. public class StreamUtils {
    14.     public static byte[] streamToByteArray(InputStream is) throws Exception {
    15.         // 创建输出流对象
    16.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
    17.         // 字节数组
    18.         byte[] b = new byte[1024];
    19.         int len;
    20.         while ((len = is.read(b)) != -1) {
    21.             // 循环读取
    22.             // 把读取到的数据，写入 bos
    23.             bos.write(b, 0, len);
    24.         }
    25.         byte[] array = bos.toByteArray();
    26.         bos.close();
    27.         return array;
    28.     }
    30.     public static String streamToString(InputStream is) throws Exception {
    31.         BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    32.         StringBuilder builder = new StringBuilder();
    33.         String line;
    34.         while ((line = reader.readLine()) != null) {
    35.             builder.append(line + "\r\n");
    36.         }
    37.         return builder.toString();
    38.     }
    39. }

    复制代码
  • 服务端
    1. package com.hspedu.upload;
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    7. /**
    8. * @author: 86199
    9. * @date: 2023/5/15 16:24
    10. * @description:
    11. */
    12. public class TCPFileUploadServer {
    13.     public static void main(String[] args) throws Exception {
    14.         ServerSocket serverSocket = new ServerSocket(8888);
    15.         System.out.println("服务端在8888等待连接......");
    16.         Socket accept = serverSocket.accept();
    18.         String filePath = "D:\\program\\javaProject\\Idea_Java_Project\\chapter21\\src\\copy.jpg";
    20.         BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
    21.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
    23.         byte[] bytes = StreamUtils.streamToByteArray(bis);
    25.         bos.write(bytes);
    26.         bos.close();
    28.         //向客户端回复“收到图片”
    29.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
    30.         bufferedWriter.write("收到图片");
    31.         bufferedWriter.flush();
    32.         accept.shutdownOutput();
    34.         //关闭流和socket
    35.         bis.close();
    36.         accept.close();
    37.         serverSocket.close();
    38.     }
    39. }

    复制代码
  • 客户端
    1. package com.hspedu.upload;
    3. import java.io.*;
    4. import java.net.InetAddress;
    5. import java.net.Socket;
    8. /**
    9. * @author: 86199
    10. * @date: 2023/5/15 16:24
    11. * @description:
    12. */
    13. public class TCPFileUploadClient {
    14.     public static void main(String[] args) throws Exception {
    16.         Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
    17.         String filePath = "e:\\qie.jpg";
    19.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
    20.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
    22.         byte[] bytes = StreamUtils.streamToByteArray(bis);
    23.         bos.write(bytes);
    24.         bos.flush();
    25.         //没有手动调用flush方法，也没有调用close方法关闭流，数据复制失败，
    26.         //因为数据还在内部缓冲区，并没有输出 (因为内部缓冲区没有被放满，不调用flush方法，不会输出）
    27.         bis.close();
    28.         socket.shutdownOutput();
    30.         //接收消息
    31.         InputStream inputStream = socket.getInputStream();
    32.         String s = StreamUtils.streamToString(inputStream);
    33.         System.out.println(s);
    35.         //关闭流和socket
    36.         inputStream.close();
    37.         bos.close();
    38.         socket.close();
    39.     }
    40. }

    复制代码
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！