网络编程套接字（UDP与TCP网络编程）

不应该热爱

已于 2022-11-19 14:39:06 修改

阅读量1.3k

点赞数 1

文章标签：网络服务器 linux

于 2022-11-13 19:40:15 首次发布

本文链接：https://blog.csdn.net/qq_63218110/article/details/127793814

版权

前言：该篇文章直接从Socket套接字讲起，如果想要了解一些关于其的基础知识，请阅读博主的另一篇博客网络套接字预备知识

一、UDP网络编程

1.1 基础概念

1.2 DatagramSocket API

1.3 DatagramPacket API

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

其实Socket本质上也是文件（操作系统把其抽象出来的），其对应网卡这一设备。

一、UDP网络编程

1.1 基础概念

数据报套接字：使用传输层UDP协议: UDP，即User Datagram Protocol（用户数据报协议），传输层协议。

以下为UDP的特点：

无连接
不可靠传输
面向数据报（发送和接受数据，都需要使用数据报，下方回显服务器会展示）
有接收缓冲区，无发送缓冲区
大小受限：一次最多传输64k.

解析：对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

1.2 DatagramSocket API

我们知道我们的数据是从应用层开始封装，一直到物理层封装完成并发送，那数据传输的第一步就是将应用层的数据交给传输层，为了完成这个过程，操作系统提供了一组API即socket，用来实现将应用层的数据转交给传输层（内核）进一步传输。

常见传输层协议有两种，分别是UDP与TCP，其中UDP类型的socket，有两个相关网络传输的核心类，一个是DatagramSocket，其实例的对象表示UDP版本的socket，这个socket可以理解为操作网卡的遥控器。

DatagramSocket 构造方法：

方法签名	方法说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

DatagramSocket 方法：

void receive(DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)	从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()	关闭此数据报套接字

1.3 DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报。
DatagramPacket 构造方法：

方法签名	方法说明
DatagramPacket(byte[] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数 length）
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数 length）。address指定目的主机的IP和端口号

DatagramPacket 方法

方法签名	方法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创
建。

1.4 UDP回显服务器

为了加强大家对UDP网络编程的理解，这便利用了回显服务器，顾名思义，其作用主要是返回你所输入的请求。

1.4.1 服务器：

步骤：

创建Socket实例对象(DatagramSocket对象)，并指定服务器的端口号。
启动服务器。
获取客户端请求(DatagramPacket为载体)。
处理客户端请求，并获取计算后的响应。
发送处理响应(DatagramPacket为载体)。

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;


public class UdpEchoServer {
    private DatagramSocket socket = null;
//参数的端口表示服务器要绑定的端口
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    //通过这个方法启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动");
        //这里使用while循环的原因是因为，服务器不知道客户端什么时候发送请求，所以需要严阵以待。
//直到客户端发送请求过来后，才解除阻塞
        while(true) {
            //循环里面处理一次请求
            // 1. 读取请求并且分析
            //这里的字节数组大小可任意。
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //需要注意的是这里receive方法的参数，是个输出型参数，调用receive的时候，需要手动的传入一个空的
            //DatagramPacket 对象，然后把对象交给receive，在receive里面负责把从网卡读到的数据，给填充到这个对象中。
            socket.receive(requestPacket);
            //把这个DatagramPacket 对象转成字符串，方便去打印
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            // 2. 根据请求计算响应
            String response = process(request);
            // 3. 把响应写到客户端
            //还需在文件上写上客户端的数据才行，于是加上了requestPacket.getSocketAddress()
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);

            // 4. 打印一个日志，记录当前的情况
            //requestPacket.getAddress().toString()客户端的端口号，客户端的IP地址：requestPacket.getPort()
            System.out.printf("[%s:%d] req: %s; resp: %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);

        }
    }
    //当前写的是一个回显服务器响应数据和请求是一样的
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

1.4.2 服务器客户端

步骤：

创建Socket实例对象(DatagramSocket对象)。
用户输入请求。
读取用户请求。
打包请求并发送给服务器(DatagramPacket对象打包数据)。
等待响应。
接收响应，并反馈。

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;

    //两个参数一会会在发送数据的时候用到，这里先存起来
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        //这里并不是说没有端口，而是让系统自动指定一个空闲的端口，因为如果是指定端口的话，可能会存在端口
        //已经被占用的情况
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while(true) {
            // 1. 从控制台读取用户输入的内容
            System.out.print("->");
            String request = scanner.next();
            // 2. 构造一个UDP请求，发送给服务器
//注意这里request.getBytes().length;不能随意更改(比如修改为request.length)，因为如果这个请求
//是中文的话，这两个值就不相同(如果都是ASCII的话就相同)。
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(this.serverIP),this.serverPort);
            socket.send(requestPacket);
            // 3. 从服务器读取UDP响应数据，并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
//如果服务器未把响应结果返回来，那么这时客户端也会进入阻塞状态，直到结果返回来。
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            // 4. 把响应请求打印在控制台上
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
        client.start();
    }

}

Tip1：

对于服务器来说，“读取请求并分析”，“根据请求计算响应”，“把响应写回客户端”.的三个请求执行速度极快，如果同一时间内，多个客户端发来请求，服务器也是可以响应的，但是在服务器本质上却是串行执行的。

当然了，具体速度还是要取决于实际的业务场景，如果确实快，就天然可以处理比较多的并发。

反之则需要使用多线程（多个CPU），和分布式了（多台主机来处理）。

Tips2:

上面我们也说到：服务器有时候是需要处理多个客户端的，那么如何在idea中处理多个客户端呢？

以上面的回显服务器为例，以下两个不同的端口号（这里的端口号是系统随机分配的）就代表两个不同的客户端。

1.5 UDP翻译服务器

翻译服务器大致内容与回显相同，只是process方法（根据请求计算响应）不一样。

这也说明一个服务器最核心的地方是process。

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

public class UdpTranslateServer extends UdpEchoServer{

    //翻译的本质其实就是 key -> value
    private Map<String,String> dict = new HashMap<>();
    public UdpTranslateServer (int port) throws SocketException {
        super(port);
        dict.put("cat","猫咪");
        dict.put("dog","修勾");
        //这里可以填入很多内容，像市面上见到的许多翻译软件，
        // 都是这样实现的（有一个很大的hash表，包含了几乎所有单词）
    }

    @Override
    public String process(String request) {
        return dict.getOrDefault(request,"词在单词表中未找到");
    }
//这里的start方法可以跟父类相同，不需重写。

    public static void main(String[] args) throws IOException {
        UdpTranslateServer server = new UdpTranslateServer(9090);
        server.start();
    }
}

二、TCP网络编程

TCP相较于UDP有很大的不同，TCP是需要建立连接的，而且是通过文件的读与写操作来进行以字节为单位的数据传输。

这里简单介绍两个常用的类：

ServerSocket API（给服务端使用的类）。
ServerSocket 构造方法：

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

ServerSocket 方法：

方法签名	方法说明
Socket accept()	开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket 对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

Socket API（既可以用于客户端也可以用于服务器）
Socket 构造方法：

方法签名	方法说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

socket方法：

方法签名	方法说明
InetAddress getInetAddress()	返回套接字所连接的地址
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

第一个方法可以获取对方的IP地址和端口号，其中的后面两个方法，是通过socket来获取流对象，对其进行读和写。

2.1 TCP回显服务器

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;


public class TcpEchoServer {
    //
    private ServerSocket listenSocket = null;

    public TcpEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true) {
            //1.先调用 accept 来接受客户端的连接
            Socket clientSocket = listenSocket.accept();
            //2.再调用这个连接
            procession(clientSocket);
        }
    }

    private void procession(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d]客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //处理客户信息
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                //1.读取请求并分析
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()) {
                    //读完了，连接断开
                    System.out.printf("[%s:%d] 客户端下线",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                String request = scanner.next();
                //2.根据请求计算响应
                String response = process(request);
                // 3. 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                //刷新缓冲区确保数据是通过网卡发送出去了
                printWriter.flush();
                System.out.printf("[%s:%d] req: %s; resp: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

2.2 TCP回显客户端

import sun.security.krb5.SCDynamicStoreConfig;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIP,int serverPort) throws IOException {
        // 和服务器建立连接，就需要知道服务器在哪，这里的IP是服务器的IP，而
        //端口则是服务器随机分配的端口
        socket = new Socket(serverIP,serverPort);
    }
    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            while(true) {
                // 1. 从控制台读取数据，构造成一个请求
                System.out.print("->");
                String request = scanner.next();
                // 2. 发送请求给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                // 3. 从服务器读取响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                // 4. 把响应显示到界面上
                System.out.println(response);

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

2.3 解决无法同时启动多个客户端的问题

但是上述代码其实是有些问题的，当客户端的数量从单个变为多个的时候，这时服务器就无法响应多个客户端的请求了。

原因如下：

因为在服务器代码中procession方法里面还有一层循环，这层循环需要与当前的客户端传输完成后才退出，此时如果有其他的客户端发送请求，就无法跳出循环来与其建立连接，这就像打电话遇到占线的情况一样。简单来说，就是一个线程只能连接一个客户端，所以最简单的方法就是使用多线程，这样就可以做到每连接一个客户端，就创建一个线程与其对接。

注：这里并不是说客户端的消息并未发送出去，客户端的数据是实实在在的发送出去了，但是服务器由于处于阻塞状态，没有时间进行处理）：

于是对上述代码进行改进：
这里我们运用多线程的方法，让服务器即能快速重复的调用accept，又能循环的处理客户端的请求。

将上述的 start（）方法优化如下：

    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true) {
            //1.先调用 accept 来接受客户端的连接
            Socket clientSocket = listenSocket.accept();
            //2.这里的连接，应该实现多线程，也就是每个客户端连接上来的时候，都有一个线程负责处理
            Thread t = new Thread(()->{
                try{
                    procession(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }

但是仍然有些小瑕疵，因为这样需要频繁的创建以及销毁进程，于是我们再次进行优化，引入线程池：

    public void start() throws IOException {
        System.out.println("服务器启动");
        ExecutorService service = Executors.newCachedThreadPool();
        while(true) {
            //1.先调用 accept 来接受客户端的连接
            Socket clientSocket = listenSocket.accept();
            //2.这里的连接，应该实现多线程，也就是每个客户端连接上来的时候，都有一个线程负责处理
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        procession(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

2.4 TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接；

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

对比以上长短连接，两者区别如下：

建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

扩展：
基于BIO（同步阻塞IO）的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说，这样的消耗是不能承受的。