• 【计算机网络】网络编程 Socket

    目录

    1.TCP和UDP的区别

    2.基于UDP的 Socket API

    总结

    3.基于TCP的Socket API

    服务器程序的问题

    网络编程的目的：通过网络，让不同主机之间能够进行通信。

    在进行网络编程的时候，需要操作系统提供一组API，也就是Socket API，才能完成编程。Socket API可以认为是应用层和传输层之间交互的路径。

    Socket：也被称为套接字，就是网络中不同主机上的应用程序之间进行双向通信的端点的抽象。其本质上是一种特殊的文件。与普通文件不同的是，普通文件都是在同一台计算机上，两个进程之间传输数据。而Socket可以实现在不同计算机之间传输数据，也就是网络传输数据。比如说打开QQ,打开一个网页，这些都是socket来实现通信的，而网络通信又必须遵守的两个协议，tcp/ip协议和udp协议，Socket里面已经封装好了这两个协议，我们直接拿来用即可。Socket就属于是把"网卡"这个设备给抽象成文件了。往Socket文件中写数据，就相当于通过网卡发送数据；从Socket文件读数据，就相当于通过网卡接收数据。

    传输层提供的网络协议主要有两个：TCP和UDP。

    1.TCP和UDP的区别

    1. TCP是有连接的，UDP是无连接的。
    2. TCP是可靠传输的，UDP是不可靠传输的。
    3. TCP是面向字节流的，UDP是面向数据报的。
    4. TCP和UDP都是全双工的。

    详细来说这四个区别。

    1. TCP是有连接的，UDP是无连接的。

    • 这里的连接只是抽象的说法，就是连接双方各自保存了对方的信息。两台计算机连接就是双方彼此保存了对方的关键信息。TCP想要通信，就要先建立连接，如果一方请求建立连接，而另一方拒绝连接，则无法连接，也就无法通信。而UDP想要通信，直接发送数据即可，不需要关心对方是否同意，UDP自身也不会保存对方的信息。

    2. TCP是可靠传输的，UDP是不可靠传输的。

    举个例子：A给B发送消息，发送成功还是失败，若A这边都能及时知道，那这就是可靠传输，否则就是不可靠传输。但是要想可靠传输，也得付出一些代价：

    • 可靠传输的机制更复杂。
    • 可靠传输的传输效率会降低。

    3. TCP是面向字节流的，UDP是面向数据报的。

    • 即TCP是以字节为基本单位来进行传输的。
    • UDP是以数据报为基本单位进行传输的。
    • 网络通信数据的基本单位有多种说法：数据报(Datagram)，数据包(Packet)，数据帧(Frame)，数据段(Segment)。

    4. TCP和UDP都是全双工的。

    一个信道，允许双向通信，就是全双工。

    一个信道，只能单向通信，就是半双工。

    双向通信的原因：与网线有关，一根网线里通常有8根网线，4个为一组，每一组又是单向传输的，这样这一组负责数据传过来，另一组负责数据传过去。就构成了双向通信。

    2.基于UDP的 Socket API

    在Java中也提供了一组API，用来操作Socket，具体使用DatagramSocket这个类操作。其常用方法有接收数据receive()方法，发送数据send()方法，关闭文件close()方法。DatagramPacket这个类用来创建数据包，每次发送数据或者是接收数据都要以数据包的形式传递。且发送数据时数据包还要加上发送目的地(IP，端口等)。接收数据时还要提前创建好空的数据报。

    为啥要以数据包的形式接收和发送？

    因为UDP是面向数据包的。是以数据报为基本单位。

    接下来我们实现一个简单的基于UDP的客户端/服务器通信的程序。(回显服务器)

    服务器程序

    1. import java.io.IOException;
    2. import java.net.DatagramPacket;
    3. import java.net.DatagramSocket;
    4. import java.net.SocketException;
    5.  
    6. //服务器程序
    7. public class  MyServer {
    8.     private DatagramSocket socket = null;
    9.     //port 端口号 服务器需要手动指定端口号
    10.     public MyServer(int port) throws SocketException {
    11.         //折磨写就是手动指定端口
    12.         socket = new DatagramSocket(port);
    13.         //这么写就是让系统自动分配端口
    14.         //socket = new DatagramSocket();
    15.     }
    16.     //服务器启动方法start
    17.     public void start() throws IOException {
    18.         System.out.println("服务器启动!");
    19.         while(true) {
    20.             // 1.读取请求并解析
    21.             //创建一个空的数据报，用来存储服务器接收客户端传来的请求
    22.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
    23.             //讲数据报传入socket中
    24.             socket.receive(requestPacket);
    25.             //将数据报中存储的客户端的请求数据从字节流转成字符串
    26.             String request = new String(requestPacket.getData(),0,requestPacket.getLength());
    27.             // 2.根据请求计算响应
    28.             String response = process(request);
    29.             //将计算后的响应数据一个传入新创建的数据报 参数有 字节数组 字节数组长度 数据报的发送地址
    30.             DatagramPacket responsePacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
    31.                     requestPacket.getSocketAddress());
    32.             // 3.把响应写回给客户端 以数据包形式
    33.             socket.send(responsePacket);
    34.             // 4.打印日志
    35.             System.out.printf("[%s:%d] request=%s response=%s\n",requestPacket.getAddress().toString(),
    36.                     responsePacket.getPort(),request,response);
    37.         }
    38.     }
    39.  
    40.     private String process(String request) {
    41.         return request;
    42.     }
    43.  
    44.     public static void main(String[] args) throws IOException {
    45.         //设置服务器的端口号为9090
    46.         MyServer server = new MyServer(9090);
    47.         server.start();
    48.     }
    49.  
    50. }

    客户端程序 

    1. import java.io.IOException;
    2. import java.net.DatagramPacket;
    3. import java.net.DatagramSocket;
    4. import java.net.InetAddress;
    5. import java.net.SocketException;
    6. import java.util.Scanner;
    7.  
    8. //客户端程序
    9. public class MyClient {
    10.     private DatagramSocket socket = null;
    11.     //服务器IP
    12.     private String serverIp =null;
    13.     //服务器端口
    14.     private int serverPort = 0;
    15.  
    16.     //构造方法 参数为服务器IP和服务器端口号
    17.     public MyClient(String IP,int port) throws SocketException {
    18.         //客户端端口号不需要手动指定 由系统自动分配
    19.         socket = new DatagramSocket();
    20.         this.serverIp = IP;
    21.         this.serverPort = port;
    22.     }
    23.     //客户端启动程序
    24.     public void start() throws IOException {
    25.         System.out.println("客户端启动!");
    26.         Scanner sc = new Scanner(System.in);
    27.         while(true) {
    28.             // 1.将客户端的请求数据发给服务器
    29.             System.out.print("->");
    30.             String request = sc.next();
    31.             //创建数据报 将请求数据以字节流形式装入包中
    32.             //因为是充当发送的数据报 所以数据包中要有 数据+发送目的地
    33.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,InetAddress.getByName(serverIp),serverPort);
    34.             //将数据报发送给服务器
    35.             socket.send(requestPacket);
    36.             // 2.接收服务器响应回的数据
    37.             //再创建一个空的数据包接收服务器返回的数据
    38.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
    39.             //接收服务器返回的响应
    40.             socket.receive(responsePacket);
    41.             String response = new String(responsePacket.getData(),0,responsePacket.getLength());
    42.             System.out.println(response);
    43.         }
    44.     }
    45.     public static void main(String[] args) throws IOException {
    46.         //参数为服务器IP地址和端口号
    47.         MyClient client = new MyClient("127.0.0.1",9090);
    48.         client.start();
    49.     }
    50. }
    总结

           基于UCP协议的话：服务器和客户端之间的来回receive和send都是以数据包形式传递数据 所以要经常创建数据包。数据包中可包含数据 发送的目的地。充当发送的数据包中是要有发送的地址的，充当接收的数据包要预先创建一个空的数据包。这就是两种方式下数据包的不同的用法。

    上述代码中的几个细节：

    1.既然说Socket是文件，为啥使用完后不进行close操作呢？不怕文件资源泄露吗？

    • 原因是Socket在整个程序的运行过程中都是需要使用的，并且也没有去频繁地打开文件。我们都知道打开文件，就会占用一个文件描述符表，造成文件资源泄露的原因也是因为文件描述符表满了。而文件描述符表又是在PCB上的，当整个程序运行结束，进程结束了，PCB就会还给操作系统，被销毁，那么文件描述符也就会被回收。

    文件资源泄露的原因：在一个程序中，频繁地打开文件而不去关闭。会使文件描述符表满。

    2.服务器和客户端的端口号都需要手动添加吗？

    • 服务器端口号需要手动指定添加，而客户端端口号不需要指定。
    • 因为服务器是在程序员手里的，是可控的，而不同的用户，其电脑上下载的程序，占用的端口号都不同，如果给客户端去指定端口号可能会引发冲突。而最好的做法是让系统去自动分配一个端口号，这样就可以保证分配的这个端口号一定是不冲突的。

    3.这段代码服务器和客户端各自的工作流程？

    1. 服务器先启动，启动之后，就会进入while循环，执行到receive这里，若是未收到客户端的请求，就会一直阻塞，直到客户端有请求发送过来，才会继续往下执行。
    2. 客户端后启动，也先进入while循环，执行.next()，等待用户输入请求，这里也会阻塞等待。当用户输入请求后，以字节形式封装进数据报，将请求数据包发送(send)给服务器。然后继续往下执行到receive(接收)处，等待服务器响应。
    3. 服务器接收(receive)到请求后，将接收到的数据报里的数据又从字节流转成(解析成)字符串，再执行process操作来处理请求，处理完成后，先将响应数据转成字节数组，再封装入数据报，再返回给客户端。
    4. 客户端收到响应后，从receive处向下执行，再次将数据包中的数据解析成字符串并进行打印。
    5. 服务器执行完一次循环后，又执行到receive这里，等待客户端的请求。客户端执行完一次循环后，又执行到next()这里，等待用户输入请求。也就是双双进入阻塞。

    4.为啥接收数据的时候需要提前手动创建一个有大小的数据报？

    • 因为DatagramPacket不能自己分配内存。因此需要提前手动创建好一个字节数组和长度。

    基于上述代码再写一个简单的翻译器程序(继承)

    1.  
    2. import java.io.IOException;
    3. import java.net.SocketException;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6.  
    7. public class udpTranServer extends udpServer{
    8.     private Map map = new HashMap<>();
    9.     public udpTranServer(int port) throws SocketException {
    10.         super(port);
    11.         map.put("cat","猫");
    12.         map.put("dog","狗");
    13.         map.put("tiger","老虎");
    14.         //......
    15.     }
    16.  
    17.     //重写process方法 服务器处理请求
    18.     @Override
    19.     public String process(String request) {
    20.         //英译汉
    21.         String response = map.getOrDefault(request,"没有这个单词!");
    22.         return response;
    23.     }
    24.  
    25.     public static void main(String[] args) throws IOException {
    26.         udpTranServer server = new udpTranServer(9090);
    27.         server.start();
    28.     }
    29. }

    3.基于TCP的Socket API

    有两个关键的类：

    ServerSocket：只给服务器使用，用来绑定端口号。

    Socket：既给服务器用，也给客户端用，用来接收(receive)和发送(send)数据(字节流)。

    常用的四个方法：

    • 得到对端的网络地址和端口号

    • 得到本地的网络地址和端口号 

     

     

    由于TCP是面向字节流的，以字节为基本单位。所以传输过程中就会用到InputStream和OutputStream流进行接收和发送。通过InputStream进行read操作，就是接收，通过OutputStream进行write操作，就是发送。

    服务器

    1. import java.io.IOException;
    2. import java.io.InputStream;
    3. import java.io.OutputStream;
    4. import java.io.PrintWriter;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7. import java.util.Scanner;
    8.  
    9. //服务器
    10. public class tcpServer {
    11.  
    12.     private ServerSocket serverSocket = null;
    13.     public tcpServer(int port) throws IOException {
    14.         //服务器手动指定端口号
    15.         serverSocket = new ServerSocket(port);
    16.     }
    17.  
    18.     //这个方法用来启动服务器
    19.     public void start() throws IOException {
    20.         System.out.println("服务器启动！");
    21.         while(true) {
    22.             //服务器接收请求
    23.             Socket requestSocket = serverSocket.accept();
    24.             //先需要建立连接 细节流程是由内核完成的 只需要调用即可
    25.             processConnection(requestSocket);
    26.         }
    27.     }
    28.  
    29.     private void processConnection(Socket requestSocket) throws IOException {
    30.         //打印日志
    31.         System.out.printf("[%s:%d] 上线啦! %s\n",requestSocket.getInetAddress(),requestSocket.getPort());
    32.         //处理请求
    33.         try(InputStream is = requestSocket.getInputStream();
    34.             OutputStream os = requestSocket.getOutputStream()) {
    35.             Scanner sc = new Scanner(is);
    36.             PrintWriter writer = new PrintWriter(os);
    37.             while(true) {
    38.                 // 字节流转字符流
    39.                 // 先读 Scanner
    40.                 if (!sc.hasNext()) {
    41.                     System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());
    42.  
    43.                     break;
    44.                 }
    45.                 String request = sc.next();
    46.                 // 处理请求
    47.                 String response = process(request);
    48.                 //打印日志
    49.                 System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);
    50.  
    51.                 // 将请求处理结果返回给客户端
    52.                 // 再写 PrintWriter 或者将 字符串转成字节数组
    53.                 writer.println(response);
    54.                 // 字符串转成字节数组
    55.                 // os.write(response.getBytes());
    56.                 // 刷新缓冲
    57.                 writer.flush();
    58.                 // os.flush();
    59.             }
    60.  
    61.         } catch (IOException e) {
    62.             e.printStackTrace();
    63.         }finally {
    64.             requestSocket.close();
    65.         }
    66.  
    67.     }
    68.  
    69.     private String process(String request) {
    70.         //这里负责处理请求并返回响应
    71.         return request;
    72.     }
    73.  
    74.     public static void main(String[] args) throws IOException {
    75.         tcpServer server = new tcpServer(9090);
    76.         server.start();
    77.     }
    78. }

    客户端

    1. import java.io.IOException;
    2. import java.io.InputStream;
    3. import java.io.OutputStream;
    4. import java.io.PrintWriter;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. //客户端
    9. public class tcpClient {
    10.     Socket socket = null;
    11.     //需要明确访问服务器的IP地址和端口号
    12.     public tcpClient(String serverIp,int serverPort) throws IOException {
    13.         //具体链接的细节，不需要我们手动干预，内核自动负责
    14.         //当我们new这个对象的时候，操作系统就进行三次握手 具体细节，完成建立的细节
    15.         socket = new Socket(serverIp,serverPort);
    16.     }
    17.     public void start() {
    18.         System.out.println("客户端启动!");
    19.         Scanner sc = new Scanner(System.in);
    20.         try(InputStream is = socket.getInputStream();
    21.             OutputStream os = socket.getOutputStream()) {
    22.             Scanner res = new Scanner(is);
    23.             PrintWriter writer = new PrintWriter(os);
    24.             while(true) {
    25.                 System.out.print("->");
    26.                 String request = sc.next();
    27.                 //将请求以字节流形式发送给服务器
    28.                 //os.write(request.getBytes());
    29.                 writer.println(request);
    30.                 //刷新缓冲区
    31.                 writer.flush();
    32.                 //os.flush();
    33.                 //接收服务器传回来的响应
    34.                 //传回来的是字节流 进一步要转成字符流
    35.                 String response = res.next();
    36.                 System.out.println(response);
    37.  
    38.             }
    39.  
    40.         } catch (IOException e) {
    41.             e.printStackTrace();
    42.         }
    43.  
    44.     }
    45.  
    46.     public static void main(String[] args) throws IOException {
    47.         tcpClient client = new tcpClient("127.0.0.1",9090);
    48.         client.start();
    49.     }
    50. }
    服务器程序的问题

    问题一：为啥光Socket对象要进行close操作而ServerSocket不用close，为啥这个会资源泄露？

    原因是这个对象在while循坏中，每次有一个客户端来请求都会创建一个，这个Socket对象也就会占据文件描述符的位置，久而久之，不及时关闭就会造成文件资源泄露，而同一个代码中ServerSocket不用close，是因为它的对象只有一个，且生命周期贯穿整个程序。

    但是我们不是加了try()语句吗，这种语句形式不是会自动关闭的吗？

    原因是这只是关闭了Socket对象自带的流对象，本身本体Socket对象并没有被关闭。

    问题二：上面这种代码如果启动多个客户端会有什么问题，如何解决？

    虽然客户端是多个，但其实进线程只有一个。 最先启动的客户端是可以正常交互的。而后面启动的这些客户端没有响应。并且当第一个客户端结束后，第二个又可以正常运行，并且会将之前积压的请求由服务器全部正常处理。以此类推，即同一时间只能正常运行一个，仿佛是其他客户端都在等待自己的前一个客户端结束后才活过来。这是与我们服务器的代码逻辑有关，在代码中，我们有两层嵌套while(true)循环，这样第一个客户端上线后，进程就会阻塞在里面的while循环的判断语句hasNext这块，还是上面所说的虽然客户端是多个，但其实线程只有一个。所以只有这个用户下线后，里面的while循环才能跳出来，继续执行。

    解决办法：使用多线程并发执行。 

    1. 把连接操作放在Thread里

    • 这样会有效，但是这样每个客户进来，都会创建一个线程，如果客户端多了，并且频繁地建立连接/断开连接，就会频繁地创建和销毁线程，开销就会很大。还可以采用线程池(2)。

    2. 采用线程池

    线程池的方式虽然可以降低线程的频繁创建与销毁的开销。但如果同一时刻大量用户进行访问，线程池也要同时创建多个线程，也会招架不住。还可以采用协程(3)或IO多路复用(4)。

    3.协程

    4.IO多路复用/IO多路转接

    IO多路复用/IO多路转接：用一个线程可以同时处理多个客户端的Socket。在Java中是NIO，其底层就是IO多路复用。

    代码如下：

    只需要改服务器程序。

    1. import java.io.IOException;
    2. import java.io.InputStream;
    3. import java.io.OutputStream;
    4. import java.io.PrintWriter;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7. import java.util.Scanner;
    8. import java.util.concurrent.ExecutorService;
    9. import java.util.concurrent.Executors;
    10.  
    11. //服务器
    12. public class tcpServer {
    13.  
    14.     private ServerSocket serverSocket = null;
    15.     //使用线程池 保证多个客户端正常运行
    16.     ExecutorService service = Executors.newCachedThreadPool();
    17.     public tcpServer(int port) throws IOException {
    18.         //服务器手动指定端口号
    19.         serverSocket = new ServerSocket(port);
    20.     }
    21.  
    22.     //这个方法用来启动服务器
    23.     public void start() throws IOException {
    24.         System.out.println("服务器启动！");
    25.         while(true) {
    26.             //服务器接收请求
    27.             Socket requestSocket = serverSocket.accept();
    28.             //先需要建立连接 细节流程是由内核完成的 只需要调用即可
    29.  
    30.             //第一种 最简单的多线程处理
    31.             /*
    32.             Thread thread = new Thread(() -> {
    33.                 try {
    34.                     processConnection(requestSocket);
    35.                 } catch (IOException e) {
    36.                     e.printStackTrace();
    37.                 }
    38.             });
    39.             thread.start();
    41.              */
    42.             //第二种 线程池
    43.             service.submit(new Runnable() {
    44.                 @Override
    45.                 public void run() {
    46.                     try {
    47.                         processConnection(requestSocket);
    48.                     } catch (IOException e) {
    49.                         e.printStackTrace();
    50.                     }
    51.                 }
    52.             });
    53.             //协程和IO多路复用以后实现
    54.         }
    55.     }
    56.  
    57.     private void processConnection(Socket requestSocket) throws IOException {
    58.         //打印日志
    59.         System.out.printf("[%s:%d] 上线啦! \n",requestSocket.getInetAddress(),requestSocket.getPort());
    60.         //处理请求
    61.         try(InputStream is = requestSocket.getInputStream();
    62.             OutputStream os = requestSocket.getOutputStream()) {
    63.             Scanner sc = new Scanner(is);
    64.             PrintWriter writer = new PrintWriter(os);
    65.             while(true) {
    66.                 // 字节流转字符流
    67.                 // 先读 Scanner
    68.                 if (!sc.hasNext()) {
    69.                     System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());
    70.  
    71.                     break;
    72.                 }
    73.                 String request = sc.nextLine();
    74.                 // 处理请求
    75.                 String response = process(request);
    76.                 //打印日志
    77.                 System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);
    78.  
    79.                 // 将请求处理结果返回给客户端
    80.                 // 再写 PrintWriter 或者将 字符串转成字节数组
    81.                 writer.println(response);
    82.                 // 字符串转成字节数组
    83.                 // os.write(response.getBytes());
    84.                 // 刷新缓冲
    85.                 writer.flush();
    86.                 // os.flush();
    87.             }
    88.  
    89.         } catch (IOException e) {
    90.             e.printStackTrace();
    91.         }finally {
    92.             requestSocket.close();
    93.         }
    94.  
    95.     }
    96.  
    97.     private String process(String request) {
    98.         //这里负责处理请求并返回响应
    99.         return request;
    100.     }
    101.  
    102.     public static void main(String[] args) throws IOException {
    103.         tcpServer server = new tcpServer(9191);
    104.         server.start();
    105.     }
    106. }

  • 相关阅读:
    前端框架Vue学习 ——（六）Vue组件库Element
    Citus 11(分布式 PostgreSQL) 文档贡献与本地运行
    【无标题】
    Python批量导入及导出项目中所安装的类库包到.txt文件
    面试题: 线程池的核心参数
    小匠物联获评2023年度浙江省省工业设计企业
    Android 自定义加载动画LoadingView
    【Redis】Docker部署Redis数据库
    Python学习-----Day09
    python5day
  • 原文地址：https://blog.csdn.net/m0_73381672/article/details/133875540