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

编程入门行业动态更新时间:2024-10-11 23:20:24

【<a href=https://www.elefans.com/category/jswz/34/1769818.html style= 计算机网络】网络编程 Socket"/>

【计算机网络】网络编程 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的区别

TCP是有连接的，UDP是无连接的。
TCP是可靠传输的，UDP是不可靠传输的。
TCP是面向字节流的，UDP是面向数据报的。
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的客户端/服务器通信的程序。(回显服务器)

服务器程序

import java.io.IOException;
import java.DatagramPacket;
import java.DatagramSocket;
import java.SocketException;//服务器程序
public class  MyServer {private DatagramSocket socket = null;//port 端口号 服务器需要手动指定端口号public MyServer(int port) throws SocketException {//折磨写就是手动指定端口socket = new DatagramSocket(port);//这么写就是让系统自动分配端口//socket = new DatagramSocket();}//服务器启动方法startpublic void start() throws IOException {System.out.println("服务器启动!");while(true) {// 1.读取请求并解析//创建一个空的数据报，用来存储服务器接收客户端传来的请求DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);//讲数据报传入socket中socket.receive(requestPacket);//将数据报中存储的客户端的请求数据从字节流转成字符串String request = new String(requestPacket.getData(),0,requestPacket.getLength());// 2.根据请求计算响应String response = process(request);//将计算后的响应数据一个传入新创建的数据报 参数有 字节数组 字节数组长度 数据报的发送地址DatagramPacket responsePacket = new DatagramPacket(request.getBytes(),request.getBytes().length,requestPacket.getSocketAddress());// 3.把响应写回给客户端 以数据包形式socket.send(responsePacket);// 4.打印日志System.out.printf("[%s:%d] request=%s response=%s\n",requestPacket.getAddress().toString(),responsePacket.getPort(),request,response);}}private String process(String request) {return request;}public static void main(String[] args) throws IOException {//设置服务器的端口号为9090MyServer server = new MyServer(9090);server.start();}}

客户端程序

import java.io.IOException;
import java.DatagramPacket;
import java.DatagramSocket;
import java.InetAddress;
import java.SocketException;
import java.util.Scanner;//客户端程序
public class MyClient {private DatagramSocket socket = null;//服务器IPprivate String serverIp =null;//服务器端口private int serverPort = 0;//构造方法 参数为服务器IP和服务器端口号public MyClient(String IP,int port) throws SocketException {//客户端端口号不需要手动指定 由系统自动分配socket = new DatagramSocket();this.serverIp = IP;this.serverPort = port;}//客户端启动程序public void start() throws IOException {System.out.println("客户端启动!");Scanner sc = new Scanner(System.in);while(true) {// 1.将客户端的请求数据发给服务器System.out.print("->");String request = sc.next();//创建数据报 将请求数据以字节流形式装入包中//因为是充当发送的数据报 所以数据包中要有 数据+发送目的地DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,InetAddress.getByName(serverIp),serverPort);//将数据报发送给服务器socket.send(requestPacket);// 2.接收服务器响应回的数据//再创建一个空的数据包接收服务器返回的数据DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);//接收服务器返回的响应socket.receive(responsePacket);String response = new String(responsePacket.getData(),0,responsePacket.getLength());System.out.println(response);}}public static void main(String[] args) throws IOException {//参数为服务器IP地址和端口号MyClient client = new MyClient("127.0.0.1",9090);client.start();}
}

总结

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

上述代码中的几个细节：

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

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

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

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

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

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

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

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

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

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


import java.io.IOException;
import java.SocketException;
import java.util.HashMap;
import java.util.Map;public class udpTranServer extends udpServer{private Map<String,String> map = new HashMap<>();public udpTranServer(int port) throws SocketException {super(port);map.put("cat","猫");map.put("dog","狗");map.put("tiger","老虎");//......}//重写process方法 服务器处理请求@Overridepublic String process(String request) {//英译汉String response = map.getOrDefault(request,"没有这个单词!");return response;}public static void main(String[] args) throws IOException {udpTranServer server = new udpTranServer(9090);server.start();}
}

3.基于TCP的Socket API

有两个关键的类：

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

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

常用的四个方法：

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

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

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

服务器

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.ServerSocket;
import java.Socket;
import java.util.Scanner;//服务器
public class tcpServer {private ServerSocket serverSocket = null;public tcpServer(int port) throws IOException {//服务器手动指定端口号serverSocket = new ServerSocket(port);}//这个方法用来启动服务器public void start() throws IOException {System.out.println("服务器启动！");while(true) {//服务器接收请求Socket requestSocket = serverSocket.accept();//先需要建立连接 细节流程是由内核完成的 只需要调用即可processConnection(requestSocket);}}private void processConnection(Socket requestSocket) throws IOException {//打印日志System.out.printf("[%s:%d] 上线啦! %s\n",requestSocket.getInetAddress(),requestSocket.getPort());//处理请求try(InputStream is = requestSocket.getInputStream();OutputStream os = requestSocket.getOutputStream()) {Scanner sc = new Scanner(is);PrintWriter writer = new PrintWriter(os);while(true) {// 字节流转字符流// 先读 Scannerif (!sc.hasNext()) {System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());break;}String request = sc.next();// 处理请求String response = process(request);//打印日志System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);// 将请求处理结果返回给客户端// 再写 PrintWriter 或者将 字符串转成字节数组writer.println(response);// 字符串转成字节数组// os.write(response.getBytes());// 刷新缓冲writer.flush();// os.flush();}} catch (IOException e) {e.printStackTrace();}finally {requestSocket.close();}}private String process(String request) {//这里负责处理请求并返回响应return request;}public static void main(String[] args) throws IOException {tcpServer server = new tcpServer(9090);server.start();}
}

客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.Socket;
import java.util.Scanner;//客户端
public class tcpClient {Socket socket = null;//需要明确访问服务器的IP地址和端口号public tcpClient(String serverIp,int serverPort) throws IOException {//具体链接的细节，不需要我们手动干预，内核自动负责//当我们new这个对象的时候，操作系统就进行三次握手 具体细节，完成建立的细节socket = new Socket(serverIp,serverPort);}public void start() {System.out.println("客户端启动!");Scanner sc = new Scanner(System.in);try(InputStream is = socket.getInputStream();OutputStream os = socket.getOutputStream()) {Scanner res = new Scanner(is);PrintWriter writer = new PrintWriter(os);while(true) {System.out.print("->");String request = sc.next();//将请求以字节流形式发送给服务器//os.write(request.getBytes());writer.println(request);//刷新缓冲区writer.flush();//os.flush();//接收服务器传回来的响应//传回来的是字节流 进一步要转成字符流String response = res.next();System.out.println(response);}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) throws IOException {tcpClient client = new tcpClient("127.0.0.1",9090);client.start();}
}

服务器程序的问题

问题一：为啥光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多路复用。

代码如下：

只需要改服务器程序。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.ServerSocket;
import java.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;//服务器
public class tcpServer {private ServerSocket serverSocket = null;//使用线程池 保证多个客户端正常运行ExecutorService service = Executors.newCachedThreadPool();public tcpServer(int port) throws IOException {//服务器手动指定端口号serverSocket = new ServerSocket(port);}//这个方法用来启动服务器public void start() throws IOException {System.out.println("服务器启动！");while(true) {//服务器接收请求Socket requestSocket = serverSocket.accept();//先需要建立连接 细节流程是由内核完成的 只需要调用即可//第一种 最简单的多线程处理/*Thread thread = new Thread(() -> {try {processConnection(requestSocket);} catch (IOException e) {e.printStackTrace();}});thread.start();*///第二种 线程池service.submit(new Runnable() {@Overridepublic void run() {try {processConnection(requestSocket);} catch (IOException e) {e.printStackTrace();}}});//协程和IO多路复用以后实现}}private void processConnection(Socket requestSocket) throws IOException {//打印日志System.out.printf("[%s:%d] 上线啦! \n",requestSocket.getInetAddress(),requestSocket.getPort());//处理请求try(InputStream is = requestSocket.getInputStream();OutputStream os = requestSocket.getOutputStream()) {Scanner sc = new Scanner(is);PrintWriter writer = new PrintWriter(os);while(true) {// 字节流转字符流// 先读 Scannerif (!sc.hasNext()) {System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());break;}String request = sc.nextLine();// 处理请求String response = process(request);//打印日志System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);// 将请求处理结果返回给客户端// 再写 PrintWriter 或者将 字符串转成字节数组writer.println(response);// 字符串转成字节数组// os.write(response.getBytes());// 刷新缓冲writer.flush();// os.flush();}} catch (IOException e) {e.printStackTrace();}finally {requestSocket.close();}}private String process(String request) {//这里负责处理请求并返回响应return request;}public static void main(String[] args) throws IOException {tcpServer server = new tcpServer(9191);server.start();}
}

更多推荐

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

本文发布于:2023-12-06 10:34:37，感谢您对本站的认可！

本文链接:https://www.elefans.com/category/jswz/34/1667307.html