javaEE 初阶 — Socket 套接字与 UDP 数据报套接字编程

痛定思痛。 2023-10-03 23:51 56阅读 0赞

#### 文章目录 ####

*  1. Socket 套接字
 *   *  1.1 有连接与无连接
     *  1.2 可靠与不可靠传输
     *  1.3 面向字节流与面向数据报
     *  1.4 全双工与半双工
 *  2. UDP数据报套接字编程
 *   *  2.1 DatagramSocket API
     *  2.2 DatagramPacket API
     *  2.3 InetSocketAddress API
 *  3. UDP 版本的客户端服务器程序
 *   *  3.1 服务器实现
     *  3.2 客户端实现
     *  3.3 程序的执行结果
 *  4. 跨主机通信

## 1. Socket 套接字 ##

Socket（**套接字**）是这里的**核心**，这是操作系统提供给应用程序的**网络编程 API**

Socket API 是**和传输层密切相关**的。  
  
传输层里提供了两个最核心的协议：**UDP** 和 **TCP**。  
因此 Socket API 也提供了两种风格（**UDP** 和 **TCP**）

**UDP** 的特点：**无连接、不可靠传输、面向数据报、全双工**  
  
**TCP** 的特点：**有连接、可靠传输、面向字节流、全双工**

### 1.1 有连接与无连接 ###

需要建立连接关系了才能通信，连接建立需要对方来接受。

比如说打电话就是有链接的，而发短信和微信就是无连接的。  
如果是打电话就需要对方接听才可以通信，如果是发微信，就不需要对方 “接受”，直接发就ok。  
  
如果是打电话这种有连接的方式，在通信的过程中，可以及时获取到对方的状态。  
（也就是对方有没有听到我说的话）  
  
如果是发微信这种无连接的方式，在通信的过程中，就不可以及时获取到对方的状态。  
（也就是对方到底看没看到信息是不找到的）

### 1.2 可靠与不可靠传输 ###

网络环境天然是复杂的，不可能保证传输的数据可以 100% 就能到达。

发送方能知道消息是发送过去了还是丢了，**打电话是属于可靠传输**，**发微信是不可靠传输**。

如果是具有已读功能的就相当于是可靠传输了，可靠还是不可靠与有无连接没关系。

### 1.3 面向字节流与面向数据报 ###

面向字节流：**数据传输就和文件读写一样类似于 “流式”** 的，获取使用比较灵活。

面向数据报：**数据传输以一个一个 “数据报” 为基本单位。**  
（一个数据报可能是若干个字节，是带有一定格式的）

### 1.4 全双工与半双工 ###

**全双工** 就是 **一个通信通道可以双向传输**（既可以发送又可以接受）。

**半双工** 就是**不能双向传输。**

![8b2ccd3d4ea34999966420c41f8c6189.png_pic_center][]  
  
比如一个水管，只能是从一头进水一头出水，不能都是进水或者都是出水。（**单向传输**）

水管就是一个 **半双工**。  
  
如果是两头都是进水，那就不可以了。

![3d46e998fe5647db9f76bc09b93a74b5.png_pic_center][]  
  
![605b15e832554dd1b073892a062b0d42.jpeg_pic_center][]  
  
为什么 **UDP** 和 **TCP** 都是全双工？

因为一根网线实际上是有 8 根线组成的。

## 2. UDP数据报套接字编程 ##

### 2.1 DatagramSocket API ###

DatagramSocket 是 **UDP Socket**，用于 **发送** 和 **接收UDP数据报**。

可以使用 **DatagramSocket** 这个类表示一个 **socket对象**。

在操作系统中，把这个 socket 对象也是当成一个文件来处理，相当于是文件描述符表上的一项。

*  普通的文件对应的硬件设备是 **硬盘**。
 *  socket 文件对应的硬件设备是 **网卡**

创建了一个 socket 对象后就可以和另外一台主机进行通信了。  
如果要和多个不同的主机通信，那就需要多创建几个 socket 对象。

1、 DatagramSocket 类的构造方法

*  **DatagramSocket()** ：没有指定端口号，但是系统会自动分配一个空闲的端口。
 *  **DatagramSocket(int port)**：需要传入一个端口号。

此时就是让当前的 socket 对象和这个指定的端口（简单的整数），关联起来。

本质上说，不是 **进程** 和 **端口** 建立联系，而是进程中的 socket 对象 和 端口 建立了联系。  
  
  
2、DatagramSocket 类的方法

*  **void receive(DatagramPacket p)**：从此套接字接收数据报。  
    （如果没有接收到数据报，该方法**会阻塞等待**）
 *  **void send(DatagramPacket p)**：从此套接字发送数据报包（**不会阻塞等待**，直接发送）
 *  **void close()**：关闭此数据报套接字，使用完了要关闭，释放资源。

**DatagramPacket p** 此处传入的相当于是一个空的对象，**receive** 方法内部会对参数的这个空对象进行内容填充。  
从而构造出结果了，参数也是一个 **“输出型参数”**

### 2.2 DatagramPacket API ###

**DatagramPacket** 是 **UDP Socket** 发送和接收的数据报。  
  
表示 UDP 中传输的一个报文，构造这个对象可以指定一些具体的数据进去。  
  
1、构造方法

*  **DatagramPacket(byte\[\] buf, int length)**：把 buf 这个缓冲区给设置进去了。
 *  **DatagramPacket(byte\[\] buf, int offset, int length,SocketAddress address)**（构造缓冲区加地址。）

使用这个类表示 IP （地址）+ port（端口号）。  
  
  
2、方法  
  
![b5d499cf80c74743835ee148ef71a744.png_pic_center][]  
  
构造UDP发送的数据报时，需要传入 **SocketAddress** ，该对象可以使用 **InetSocketAddress** 来创建。

### 2.3 InetSocketAddress API ###

InetSocketAddress （ SocketAddress 的子类 ）**构造方法**：  
  
![7b3d0d9e72bb4de1b314fe865b0c6d91.png_pic_center][]

## 3. UDP 版本的客户端服务器程序 ##

### 3.1 服务器实现 ###

下面编写一个最简单的 UDP 版本的客户端服务器程序 ，称之为**回显服务器**。  
  
一个普通的服务器：收到请求后，要根据请求计算响应，然后返回响应。

**回显服务器**：省略了其中 “根据请求计算响应” ，请求是什么就返回什么。  
（回显服务器只是为了展示 socket api 的基本用法，并没有实际的业务）

作为一个真正的服务器，一定要有 “根据请求计算响应” ，因为这个环节是最重要的。

*  网络编程本质上是要操作网卡。
 *  但是网卡不方便直接操作在操作系统内核中，使用一种特殊的叫做 ”socket“ 这样的文件抽象表示网卡。
 *  因此进行网络通信势必先要有一个 **“socket” 对象**。

private DatagramSocket socket = null; //创建 socket 对象

*  对于服务器来说，创建 “socket” 对象的同时要让他绑定上一个具体的端口号。
 *  服务器一定要关联上一个具体的端口号！！！
 *  服务器是网络传输中被动的一方，如果是操作系统随机分配端口，此时客户就不知道这个端口是什么了。

举个例子，比如说张三是卖煎饼的，在集市上租了一个10号摊位。

如果有人要来吃煎饼就需要到集市上的10号摊位购买，集市相当于是搭建的服务器，10号摊位相当于是端口号。

如果有人下次还要购买的的话，就还需要到集市上的10号摊位购买。  
如果下一次来买的时候就不是10号摊位了，就找不到了。  
换成服务器也是同理，如果没有或者是一个随机的端口，每次启动都是一个不同的端口。

有了具体的摊位才能让客户找到，有了具体的端口号才能方便客户端找到。

public UdpEchoServer(int port) throws SocketException {
        
        socket = new DatagramSocket(port);
    }

1、读取客户端发来的请求是什么  
  
对于 UDP 来说，传输数据的基本单位是 **DatagramPacket**

DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
    socket.receive(requestPacket);

相当于是刚开始给 **DatagramPacket** 一个空白的纸条，客户在这张纸条上写出需求之后再把纸条还回来。

比如说买煎饼的时候需要告诉店家需要什么料儿，加什么酱料等待。  
店家拿到客户制作煎饼的需求后才能开始制作。  
  
**receive** 内部会针对参数对象进行填充，填充的数据来自网卡。  
  
  
此时的这个 **DatagramPacket** 是一个特殊的对象，并不方便直接进行处理，可以将包含的数据拿出来，构造成一个字符串。

String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

此处给 **requestPacket** 的最大长度是 4096，但是实际上这里的空间不一定满了，可能只使用了一小部分。

因此，**getLength** 获取到实际的数据包的长度，只需要把这个实际的有效部分给构造成字符串即可。  
  
  
2、根据请求响应，由于此处是回显服务器，响应和请求相同  
  
写一个方法来根据请求来计算响应。

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

3、把响应写回到客户端。send 的参数也是 DatagramPacket 需要把这个 Packet 构造好  
  
此处构造的响应对象，不能是用空的字节数组构造了而是要使用响应数据来构造

DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
            response.getBytes().length, requestPacket.getSocketAddress());

**DatagramPacket** 不认识字符只认识字节，**response.getBytes** 是传响应对象的字节数组。  
**response.getBytes().length** 指定长度，**requestPacket.getSocketAddress()** 获取到客户端的**IP**和**端口号**  
  
  
4、打印一下当前这次请求响应的中间处理结果

System.out.printf("[%s:%d] req:%s; reap:%ds\n", requestPacket.getAddress().toString(),
            requestPacket.getPort(), request, response);

**requestPacket.getPort()** 是获取到里面的端口，**requestPacket.getAddress().toString()** 是获取到 packet 里面的 IP。

完整代码

package network;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    // UDP 版本的回显服务器
    public class UdpEchoServer {
        
        //先要有一个 “socket” 对象
        private DatagramSocket socket = null;
        
        //关联具体的端口号
        public UdpEchoServer(int port) throws SocketException {
        
            socket = new DatagramSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("启动服务器！！！");
            //服务器不是给一个客户端提供服务器，而是给许多客户端提供服务
            while (true) {
        
                //只要有客户过来就可以提供服务
                //1.读取客户端发来的请求是什么
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(requestPacket);
               
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
                //2.根据请求响应，由于此处是回显服务器，响应和请求相同
                String response = process(request);
                //3.把响应写回到客户端。send 的参数也是 DatagramPacket 需要把这个 Packet 构造好
                //此处构造的响应对象，不能是用空的字节数组构造了而是要使用响应数据来构造
                DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), 
                response.getBytes().length, requestPacket.getSocketAddress());
                socket.send(responsePacket);
                //4.打印一下当前这次请求响应的中间处理结果
                System.out.printf("[%s:%d] req:%s; reap:%s\n", requestPacket.getAddress().toString(),
                        requestPacket.getPort(), request, response);
            }
        }
    
        //这个方法根据请求来计算响应
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException{
        
            //端口的指定在 1024~65535 就可以
            UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
            udpEchoServer.start(); //启动服务器
        }
    }

**socket.receive(requestPacket)** 如果客户端发送请求了，receive 就能顺利地读出来，如果没有发送请求，receive 就阻塞等待。

### 3.2 客户端实现 ###

和服务器的代码一样，客户端这里也是要先有个 **socket 对象**。

private DatagramSocket socket = null;

与服务器不同的是在构造这个 socket 对象的时候，不需要显示的绑定一个端口。  
操作系统会为之自动分配一个没有别的进程在使用的空闲端口。

public UdpEchoClient () throws SocketException {
        
        socket = new DatagramSocket();

在一次通信中涉及到的 ip 和 端口 有两组：**源ip** 和 **源端口**、**目的ip** 和 **目的端口**。

如果让 客户端 给 服务器 发送一个数据，此时的 **源ip** 就是 **客户端的 ip 地址**，**目的 ip** 就是 **服务器的 ip 地址**。  
源端口 就是 **客户端的端口**，目的端口就是 **服务器的端口**。

端口号用来表示/区分一个进程，因此不允许一个端口同时被多个进程使用（前提是同一个主机上）

一个端口在通常情况下不能被多个进程使用。（我租个店面开个小吃店，只能我用，别人不行）  
**但是一个进程可以绑定多个端口**。（我不但可以租一个店面，我也可以开几个分店）

进程只要多创建几个 socket 对象，就可以分别关联不同的端口。（socket 和端口是一对一的，进程 和 socket 是一对一多的）

**对于服务器来说，端口必须是确定好的；而对于客户端来说，端口可以是系统分配的。**

如果有客户来到我的小吃店吃东西，点完餐以后我给他了一个手牌，这个手牌上面取餐码就相当于是客户的端口。  
（这个取餐码是多少，是随机的）

如果客户点餐的时候想要指定一个取餐码（比如说客户就喜欢 6 ），也不是不可以，但是不推荐。  
因为这个 6 号有可能已经被别的顾客使用了。

客户端如果显示的指定一个 6666 这个端口，很有可能就和客户端电脑上其他程序正在使用 6666 这个端口，  
此时这就可能导致程序无法正确通信，运行就会抛出异常，提示端口绑定失败。

为什么服务器指定端口不怕重复？  
  
因为服务器是程序猿手里的机器，上面运行什么都是程序猿可以控制的，程序猿可以安排程序使用哪两个端口。  
而客户端的机器是处于用户这里的，不受小猿的控制。  
毕竟 有一千个读者就有一千个哈姆雷特，每个客户运行的程序都不相同。

如果是服务器发给客户端的操作，**服务器的端口就是源端口**，**客户端的端口就是目的端口**。

如果是客户端发给服务器的操作，**服务器的端口就是目的端口**，**客户端的端口就是源端口**。

**任何的通信，都得是 源端口 和 目的端口 两个端口**

1、== 从控制台读取要发送的数据==

Scanner scanner = new Scanner(System.in);
     System.out.println("<");
     String request = scanner.next();
     if (request.equals("exit")) {
        
         System.out.println("goodbye");
         return;
     }

2、构造成 UDP 请求并发送

DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                          InetAddress.getByName(serverIp), serverPort);
    socket.send(requestPacket);

3、读取服务器的 UDP 响应并解析

DatagramPacket reponsePacket = new DatagramPacket(new byte[4096], 4096);
    socket.receive(reponsePacket);
    String response = new String(reponsePacket.getData(), 0, reponsePacket.getLength());

4、把解析好的结果显示出来

System.out.println(response);

5、完整代码

package network;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    import java.util.Scanner;
    
    // UDP 版本的回显客户端
    public class UdpEchoClient {
        
    
        //要先有一个 socket 对象
        private DatagramSocket socket = null;
        private String serverIp = null;
        private int serverPort = 0;
    
        // 一次通信需要有两个IP，两个端口
        // 客户端的 ip 是 127.0.0.1 已知
        // 客户端的 port 是系统自动分配的
        // 服务器的 ip 和 port 也需要告诉客户端，才能顺利的把消息发给服务器
        public UdpEchoClient (String serverIp, int serverPort) throws SocketException {
        
            socket = new DatagramSocket();
            this.serverIp = serverIp;
            this.serverPort = serverPort;
        }
    
        //启动客户端的方法
        public void start() throws IOException {
        
            System.out.println("客户端启动！！！");
            Scanner scanner = new Scanner(System.in);
            while (true) {
        
                // 1.从控制台读取要发送的数据
                System.out.println("<");
                String request = scanner.next();
                if (request.equals("exit")) {
        
                    System.out.println("goodbye");
                    return;
                }
                // 2.构造成 UDP 请求并发送
                DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                        InetAddress.getByName(serverIp), serverPort);
                socket.send(requestPacket);
                // 3.读取服务器的 UDP 响应并解析
                DatagramPacket reponsePacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(reponsePacket);
                String response = new String(reponsePacket.getData(), 0, reponsePacket.getLength());
                // 4.把解析好的结果显示出来
                System.out.println(response);
            }
        }
    
        public static void main(String[] args) throws IOException{
        
            UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1", 9090);
            udpEchoClient.start();
        }
    }

通信的过程

![a374ec1852ec455bb586563b5593903f.png_pic_center][]  
  
![0a8d7ef80fbd4a77be1fc19e5c617e77.png_pic_center][]  
  
对于客户端服务器程序来说，一个服务器要给很多的客户端提供服务，我们也就需要构造很多的客户端来进行测试。  
IDEA 默认只能启动一个客户端，需要调整一下让idea 能启动多个客户端。  
  
  
1、**找到 idea 右上角如图位置**  
  
![05749e9824a54f7ebcd1c860e54ec75b.png_pic_center][]

2、**点击圈中的的位置**  
  
![7ac13778378c4947bcbf7040e4786729.png_pic_center][]

3、**在出现窗口中选中如同圈出的位置**  
  
![271d4a54ae124e18abd19f066853d808.png_pic_center][]

4、**选中以后别忘了点击 OK**  
  
![6bfde3dfa32143aaaa7ddba84fe14c59.png_pic_center][]

### 3.3 程序的执行结果 ###

先来看两个客户端的  
  
![a58fc9ac27814a44a8c56a14f15d2c06.png_pic_center][]  
  
![1b9fe79442e443818e6ef9822848b25a.png_pic_center][]  
  
接着是服务器  
  
![108f72a97c6947579e540a88126e2789.png_pic_center][]  
  
这里的 **127.0.0.1:49675** 指的是 **IP** 和 **端口号**，此处的 IP 是环回 IP ，这里的端口是系统随机分配。  
  
**端口冲突**  
  
下面来看看 端口冲突 是什么样的效果。

一个端口只能被一个进程使用，如果有多个进程使用就不行。  
  
下面先启动 回显服务器，在启动查词典的服务器，注意看效果。  
  
![0ff6a0e78aac4a58aaa75bbb71d3c7eb.png_pic_center][]

## 4. 跨主机通信 ##

回显服务器缺少业务逻辑，现在就在上面的代码的基础上稍微调整，实现一个查词典的服务器（英文单词翻译成中文）  
  
对于 DisServer 来说，和 EchoServer 相比，大部分的东西是一样的，主要是 “根据请求计算响应” 的步骤不太一样。

public class extends UdpEchoServer {
        
    
        public UdpDisServer(int port) throws SocketException {
        
            super(port);
    }

直接继承之前所写的回显服务器，然后构造 **UdpDisServer**。  
  
设置一个 Map 并在 dict 里面添内容。

private Map<String, String> dict = new HashMap<String, String>();

// 给这个 dict 设置内容 
     dict.put("sing","唱");
     dict.put("jump","跳");
     dict.put("rap","说唱");
     dict.put("basketball","篮球");
     // 这里可以无线多

重写 **UdpEchoServer** 服务器的 **process** 方法实现根据响应计算请求的。

@Override
     public String process(String request) {
        
         //查词典的过程
         return dict.getOrDefault(request, "当前单词不存在！！！");
     }

完整代码

package network;
    
    import java.io.IOException;
    import java.net.SocketException;
    import java.util.HashMap;
    import java.util.Map;
    
    // 对于 DisServer 来说，和 EchoServer 相比，大部分的东西是一样的
    // 主要是 “根据请求计算响应” 的步骤不太一样
    public class UdpDisServer extends UdpEchoServer{
        
    
        private Map<String, String> dict = new HashMap<String, String>();
    
        public UdpDisServer(int port) throws SocketException {
        
            super(port);
    
            // 给这个 dict 设置内容
            dict.put("sing","唱");
            dict.put("jump","跳");
            dict.put("rap","说唱");
            dict.put("basketball","篮球");
            // 这里可以无线多
        }
    
        @Override
        public String process(String request) {
        
            //查词典的过程
            return dict.getOrDefault(request, "当前单词不存在！！！");
        }
    
        public static void main(String[] args) throws IOException {
        
            UdpDisServer server = new UdpDisServer(9090);
            server.start(); //启动
        }
    }

执行结果  
  
![d4e61304d71a47d7974522d129f2d4e2.png_pic_center][]

![cfbdaffa712a4e0180a96f024755d0cc.png_pic_center][]

[8b2ccd3d4ea34999966420c41f8c6189.png_pic_center]: https://img-blog.csdnimg.cn/8b2ccd3d4ea34999966420c41f8c6189.png#pic_center
[3d46e998fe5647db9f76bc09b93a74b5.png_pic_center]: https://img-blog.csdnimg.cn/3d46e998fe5647db9f76bc09b93a74b5.png#pic_center
[605b15e832554dd1b073892a062b0d42.jpeg_pic_center]: https://img-blog.csdnimg.cn/605b15e832554dd1b073892a062b0d42.jpeg#pic_center
[b5d499cf80c74743835ee148ef71a744.png_pic_center]: https://img-blog.csdnimg.cn/b5d499cf80c74743835ee148ef71a744.png#pic_center
[7b3d0d9e72bb4de1b314fe865b0c6d91.png_pic_center]: https://img-blog.csdnimg.cn/7b3d0d9e72bb4de1b314fe865b0c6d91.png#pic_center
[a374ec1852ec455bb586563b5593903f.png_pic_center]: https://img-blog.csdnimg.cn/a374ec1852ec455bb586563b5593903f.png#pic_center
[0a8d7ef80fbd4a77be1fc19e5c617e77.png_pic_center]: https://img-blog.csdnimg.cn/0a8d7ef80fbd4a77be1fc19e5c617e77.png#pic_center
[05749e9824a54f7ebcd1c860e54ec75b.png_pic_center]: https://img-blog.csdnimg.cn/05749e9824a54f7ebcd1c860e54ec75b.png#pic_center
[7ac13778378c4947bcbf7040e4786729.png_pic_center]: https://img-blog.csdnimg.cn/7ac13778378c4947bcbf7040e4786729.png#pic_center
[271d4a54ae124e18abd19f066853d808.png_pic_center]: https://img-blog.csdnimg.cn/271d4a54ae124e18abd19f066853d808.png#pic_center
[6bfde3dfa32143aaaa7ddba84fe14c59.png_pic_center]: https://img-blog.csdnimg.cn/6bfde3dfa32143aaaa7ddba84fe14c59.png#pic_center
[a58fc9ac27814a44a8c56a14f15d2c06.png_pic_center]: https://img-blog.csdnimg.cn/a58fc9ac27814a44a8c56a14f15d2c06.png#pic_center
[1b9fe79442e443818e6ef9822848b25a.png_pic_center]: https://img-blog.csdnimg.cn/1b9fe79442e443818e6ef9822848b25a.png#pic_center
[108f72a97c6947579e540a88126e2789.png_pic_center]: https://img-blog.csdnimg.cn/108f72a97c6947579e540a88126e2789.png#pic_center
[0ff6a0e78aac4a58aaa75bbb71d3c7eb.png_pic_center]: https://img-blog.csdnimg.cn/0ff6a0e78aac4a58aaa75bbb71d3c7eb.png#pic_center
[d4e61304d71a47d7974522d129f2d4e2.png_pic_center]: https://img-blog.csdnimg.cn/d4e61304d71a47d7974522d129f2d4e2.png#pic_center
[cfbdaffa712a4e0180a96f024755d0cc.png_pic_center]: https://img-blog.csdnimg.cn/cfbdaffa712a4e0180a96f024755d0cc.png#pic_center