【Java】使用Socket手搓三次握手 从原理到实践

【Java】使用Socket手搓三次握手 从原理到实践

   本身这次计划将三次握手、四次挥手都做出来。但发现内容越来越多了，以是就只实现了三次握手。但依然为后续操纵做了大量的铺垫。
  系列文章：

• 使用Socket在局域网中举行广播
  
• 【Java】使用Socket实现查找IP并创建毗连？手把手教你
  
• 【Java】使用Socket手搓三次握手 从原理到实践
  

---

前情提要

猛烈发起在阅读这篇博客之前阅读之前的文章
在前面两篇文章中，我们实现了广播和吸收。而且在收到广播后对客户端发起毗连。实现了一个从一对多通讯转一对一通讯的转换。
这篇博客将在此根本上实现更完满的功能
三次握手

在前面的文章中，我们也提到过了：使用UDP实现的数据传输是不包管安全性的。换句话说，假如在一个复杂的网络中，经常会出现一些不可预料的小题目。
好比：
当前的方案

发现题目了吧，客户端的小小一个广播，就让服务器以为乐成通讯，而且连续的为广播所在服务。而客户端收到一条数据后，就以为创建了毗连，从而制止继承广播。
外貌看上去好像没有题目。但假如有一个恶意步调，不停的发送广播、发送数据，就会发生如许的情况。

这不但仅对服务器造成了资源的浪费，还让客户端无法收到准确的消息。假如涉及到了业务，将会粉碎功能，影响步调的正常使用。
三次握手

三次握手就是用来办理这个题目标。先来看一下三次握手的作用。
作用

• ‌确保毗连的可靠性‌：通过三次握手，客户端和服务器都能确认对方已经准备好举行数据传输，从而确保毗连的可靠性。
  
• 防止已失效的毗连哀求‌：通过三次握手，可以防止网络中的失效毗连哀求被误以为是有效的毗连哀求，从而浪费服务器资源。
  
• ‌流量控制和拥塞制止‌：三次握手不但确保了毗连的创建，还能通过协商数据传输的初始窗口巨细，资助控制流量和制止网络拥塞
  

一言以蔽之：三次握手就是为了告诉双方，你的哀求我确实收到了，我们已经可以开始通讯了。
过程

老生常谈啦，直接上图：

步调

• 客户端向服务器：设置seq = n，发送第一次握手。此时客户端设置本身状态为SYN。
  
• 服务器向客户端：设置seq = m，而且设置ack = n + 1，发送第二次握手。此时服务器设置本身状态为SYN ACK。
  
• 客户端向服务器：设置ack = m + 1，发送第三次握手。此时客户端进入停当态。以为此时已经创建毗连了。
  
• 服务器：收到第三次握手后，服务器进入停当态。此时以为已经创建毗连了。
  

缘故原由

为什么客户端收到第二次握手后就以为乐成创建毗连，而服务器须要收到第三次才行呢？
   面经：为什么要三次握手，两次行不可？
  

• 客户端向服务器：第一次握手。这一步没能得到任何信息。
  
• 服务器向客户端：第二次握手。这里紧张分为两部分。客户端与服务器。
  
  
  
  • 客户端：客户端收到了服务器发来的信息，意味着客户端知道了：服务器已经收到我的哀求了、而且我收到了服务器的哀求。前者代表服务器的吸收本领、客户端的发送本领 都正常。后者代表客户端的吸收本领正常。
    
  • 服务器：服务器收到了客户端发来的信息，意味着服务器知道了：我收到了客户端的哀求。代表客户端的发送本领正常、服务器的吸收本领正常。
    
  
  
• 客户端向服务器：第三次握手。这里服务器收到了客户端的信息。服务器知道了：客户端收到了我的哀求。意味着客户端的吸收本领正常、服务器的发送本领正常。
  

至此，客户端和服务器都知道了双方的发送本领、担当本领都是正常的，可以举行数据传输了。
改造

知道了三次握手与三次握手的原理。就可以开始动手举行修改了。别藐视这一步，手搓三次握手，实际上是在实现一个新的协议。就是没人用
界说数据结构

由于只实现三次握手部分的功能。因此只须要界说一个简单数据结构，方便我们使用就行了。上图

是不是有点太过于简单。但已经完完全全的富足工作了。
   举个例子: 一条带消息的同步数据为 SYN/123;-1;这是消息。
  编写数据结构的类

1. package test2;
3. import java.util.Arrays;
5. public class SocketBean {
6.     private final String type;
7.     private final int seq;
8.     private final int ack;
9.     private final String content;
11.     public static boolean isMsg(String data) {
12.         if (data == null || data.isEmpty()) return false;
13.         String[] dataArr = data.split("/");
14.         return dataArr[0].equals(Constants.MSG_TYPE);
15.     }
17.     public SocketBean(String type, int seq, int ack, String content) {
18.         this.type = type;
19.         this.seq = seq;
20.         this.ack = ack;
21.         this.content = content;
22.     }
24.     public SocketBean(String data) {
25.         String[] dataArr = data.split("/");
26.         this.type = dataArr[0];
27.         String[] dataArr2 = dataArr[1].split(";");
28.         this.seq = Integer.parseInt(dataArr2[0]);
29.         this.ack = Integer.parseInt(dataArr2[1]);
31.         if (dataArr2.length == 3) this.content = dataArr2[2];
32.         else this.content = "";
34.     }
36.     public String getType() {
37.         return type;
38.     }
40.     public int getSeq() {
41.         return seq;
42.     }
44.     public int getAck() {
45.         return ack;
46.     }
48.     public String getContent() {
49.         return content;
50.     }
52.     public String toString() {
53.         return type + "/" + seq + ";" + ack + ";" + content;
54.     }
55. }

复制代码

界说一下常量

在上篇中的常量类中增补一下

1.     // 三次握手消息类型
2.     public static final String MSG_TYPE = "MSG";
3.     public static final String SYNC_TYPE = "SYN";
4.     public static final String ACK_TYPE = "ACK";

复制代码

三次握手的准备工作就完成了
思绪

然后就是三次握手的具体实现了
看看我们当前的工作：

毕竟上，完全可以让客户端发送的广播成为第一次握手。因此只须要完成接下来两次的握手就大功告成。

• 客户端发送第一次握手的广播。
  
• 服务器收到广播，像客户端发送第二次握手。
  
• 客户端收到第二次握手，以为毗连乐成创建。制止发送广播，而且向服务器发送第三次握手。
  
• 服务器收到第三次握手，以为毗连乐成创建。将客户端IP生存，并连续提供服务。
  

如图:

具体实现

这里的代码大多数在前面提到过了，假如有须要请移步汗青文章查察
客户端

1. package test2;
3. import java.io.IOException;
4. import java.net.*;
6. public class ClientSocket {
7.     private final int serverPort = Constants.SERVER_PORT;
8.     private final int clientPort = Constants.CLIENT_PORT;
9.     private final String serverIp = Constants.BROADCAST_IP;
10.     private final int maxWaitTime = Constants.MAX_WAIT_TIME;
12.     private boolean isReceiver = true;
14.     private int seq = -1;
15.     private int ack = -1;
17.     /**
18.      * 广播客户端消息到指定服务器
19.      * 该方法在一个新线程中执行，不断向指定的服务器IP和端口发送广播消息
20.      * 直到isReceiver标志被设置为false
21.      */
22.     public void broadcast() {
23.         // 模拟客户端发送广播的初始化过程
24.         System.out.println("客户端发送广播：充当第一次握手");
25.         System.out.println(serverIp + ":" + serverPort);
27.         new Thread(() -> {
28.             try {
29.                 DatagramSocket sock = new DatagramSocket();
30.                 InetAddress address = InetAddress.getByName(serverIp);
32.                 while (isReceiver) {
33.                     // 三次握手第一次！
34.                     seq = (int) (Math.random() * 1000 + 1);
35.                     String data = new SocketBean(Constants.SYNC_TYPE, seq, ack, "").toString();
37.                     byte[] bytes = data.getBytes();
38.                     DatagramPacket packet = new DatagramPacket(bytes, bytes.length, address, serverPort);
39.                     sock.send(packet);
40.                     System.out.println("三次握手第一次:" + data);
41.                     Thread.sleep(maxWaitTime);
42.                 }
43.                 sock.close();
44.                 System.out.println("客户端发送广播结束");
45.             } catch (IOException | InterruptedException e) {
46.                 throw new RuntimeException(e);
47.             }
48.         }).start();
49.     }
51.     /**
52.      * 接收定向消息的函数
53.      * 通过创建一个新的线程来监听指定端口，以便接收来自任何发送方的定向消息
54.      * 此函数没有参数，也不返回任何值
55.      */
56.     public void receiver() {
57.         System.out.println("客户端接收定向消息");
58.         new Thread(() -> {
59.             DatagramSocket socket = null;
60.             try {
61.                 socket = new DatagramSocket(clientPort);
62.                 byte[] data = new byte[1024];
63.                 DatagramPacket packet = new DatagramPacket(data, 1024);
65.                 while (true) {
66.                     socket.receive(packet);
67.                     if (isReceiver) {
68.                         // 收到第二次握手，此时认为连接可以顺利建立！发送第三次握手
69.                         String synData = new String(packet.getData(), 0, packet.getLength());
71.                         SocketBean socketBean = new SocketBean(synData);
72.                         // 如果ack不正确，则舍弃此数据包
73.                         if (socketBean.getAck() != seq + 1) continue;
74.                         ack =  socketBean.getSeq()+1;
76.                         System.out.println("收到第二次握手，发送第三次握手");
77.                         sendPacket(new SocketBean(Constants.ACK_TYPE, seq, ack, "").toString(), packet.getAddress(), serverPort);
78.                         isReceiver = false;
79.                         continue;
80.                     }
82.                     // 顺利收到消息
83.                     String msg = new String(packet.getData(), 0, packet.getLength());
84.                     System.out.println("客户端收到消息： " + new SocketBean(msg).getContent());
85.                 }
87.             } catch (IOException e) {
88.                 throw new RuntimeException(e);
89.             }
91.         }).start();
92.     }
94.     public static void sendPacket(String data, InetAddress address, int serverPort) {
95.         DatagramSocket socket = null;
96.         try {
97.             socket = new DatagramSocket();
98.             byte[] bytes = data.getBytes();
99.             DatagramPacket packet = new DatagramPacket(bytes, bytes.length, address, serverPort);
100.             socket.send(packet);
101.             socket.close();
102.         } catch (IOException e) {
103.             throw new RuntimeException(e);
104.         }
105.     }
108.     public static void main(String[] args) {
109.         ClientSocket clientSocket = new ClientSocket();
110.         clientSocket.receiver();
111.         clientSocket.broadcast();
112.     }
115. }

复制代码

服务器

1. package test2;
3. import java.io.IOException;
4. import java.net.DatagramPacket;
5. import java.net.DatagramSocket;
6. import java.net.InetAddress;
7. import java.net.SocketException;
8. import java.util.ArrayList;
9. import java.util.List;
11. public class ServerSocket {
12.     private final String serverIp = Constants.BROADCAST_IP;
13.     private final int serverPort = Constants.SERVER_PORT;
14.     private final int maxWaitTime = Constants.MAX_WAIT_TIME;
16.     private final List<InetAddress> addresses = new ArrayList<>();
18.     private int seq;
19.     private int ack;
21.     /**
22.      * 启动服务器套接字
23.      * 该方法初始化服务器套接字，并监听指定的IP地址和端口
24.      * 同时，它启动一个新的线程来处理传入的广播消息
25.      */
26.     public void open() {
27.         System.out.println("ServerSocket open");
28.         System.out.println("serverIp:" + serverIp + " serverPort:" + serverPort);
30.         // 创建并启动一个新的线程来处理网络通信
31.         new Thread(() -> {
32.             try {
33.                 DatagramSocket socket = new DatagramSocket(serverPort);
35.                 // 无限循环等待并处理广播消息
36.                 while (true) {
37.                     DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
38.                     socket.receive(packet);
39.                     String msg = new String(packet.getData(), 0, packet.getLength());
40.                     System.out.println("服务器收到握手:" + msg + " 来自 " + packet.getAddress());
41.                     SocketBean socketBean = new SocketBean(msg);
43.                     // 在这里判断处于握手的状态！
44.                     switch (socketBean.getType()) {
45.                         case Constants.SYNC_TYPE:
46.                             // 三次握手第二次！
47.                             ack = socketBean.getSeq()+1;
48.                             seq = (int) (Math.random() * 1000 + 1);
49.                             String packetData = new SocketBean(Constants.ACK_TYPE, seq, ack, "").toString();
50.                             System.out.println("收到第一次握手！发送第二次握手");
51.                             sendPacket(packetData, packet.getAddress(), Constants.CLIENT_PORT);
52.                             break;
53.                         case Constants.ACK_TYPE:
54.                             // 如果ack不正确，则忽略该消息
55.                             if (socketBean.getAck() != seq + 1) continue;
56.                             // 三次握手第三次！此时认为顺利建立了连接！
57.                             addresses.add(packet.getAddress());
58.                             System.out.println("收到第三次握手！建立连接： " + packet.getAddress());
59.                             break;
60.                         default:
61.                             System.out.println("服务器收到其他类型消息:" + msg);
62.                     }
65.                 }
66.             } catch (IOException e) {
67.                 throw new RuntimeException(e);
68.             }
70.         }).start();
71.     }
73.     /**
74.      * 发送数据报的方法
75.      * 该方法在一个新的线程中执行，不断尝试向地址列表中的客户端发送数据
76.      */
77.     public void send() {
78.         new Thread(() -> {
79.             DatagramSocket socket = null;
80.             try {
81.                 socket = new DatagramSocket();
82.             } catch (SocketException e) {
83.                 throw new RuntimeException(e);
84.             }
86.             while (true) {
87.                 try {
88.                     Thread.sleep(maxWaitTime);
90.                     if (!addresses.isEmpty()) {
91.                         for (InetAddress address : addresses) {
92.                             String data = new SocketBean(Constants.MSG_TYPE, seq, ack, "服务器的定向消息").toString();
93.                             byte[] bytes = data.getBytes();
94.                             DatagramPacket packet = new DatagramPacket(bytes, bytes.length, address, Constants.CLIENT_PORT);
95.                             socket.send(packet);
96.                             System.out.println("服务器发送定向数据:" + data);
97.                         }
98.                     }
99.                 } catch (InterruptedException | IOException e) {
100.                     throw new RuntimeException(e);
101.                 }
102.             }
103.         }).start();
104.     }
106.     public static void sendPacket(String data, InetAddress address, int serverPort) {
107.         DatagramSocket socket = null;
108.         try {
109.             socket = new DatagramSocket();
110.             byte[] bytes = data.getBytes();
111.             DatagramPacket packet = new DatagramPacket(bytes, bytes.length, address, serverPort);
112.             socket.send(packet);
113.             socket.close();
114.         } catch (IOException e) {
115.             throw new RuntimeException(e);
116.         }
117.     }
119.     public static void main(String[] args) {
120.         ServerSocket serverSocket = new ServerSocket();
121.         serverSocket.send();
122.         serverSocket.open();
123.     }
124. }

复制代码

注意

• 实际上在三次握手之后seq、ack就已经没有任何作用了。但我在这里依然做了生存。后续可以引入更多逻辑到场验证。
  
• 在收消息的时间，通过判定范例来确定这条消息数据什么状态。
  
• 假如判定是正在握手中的状态，则进一步判定ack是否准确。假如不准确，则忽略该消息。继承等候其他的消息。
  
• 引入了最大等候时间。将来将通过最大等候时间举行消息重传等控制。
  

总结

• 着实在搞明确握手的原理以及作用的时间，统统就已经明白了。
  
• 界说了各种范例，方便后续拓展更多功能（四次挥手）。
  
• 须要在担当消息的时间判定消息的范例。对各种范例分别举行处理惩罚。但依然要警惕骚扰信息的存在。
  

三次握手实现完成，看看效果：

此中客户端：

此中服务端：

效果很好！晚安！

---

上一篇：【Java】使用Socket实现查找IP并创建毗连？手把手教你

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。