JavaEE - 网络初始之TCP/IP五层模型

旧时言

已于 2022-07-03 22:23:19 修改

阅读量711

点赞数

分类专栏：操作系统/网络/多线程/Linux/JVM 文章标签： java

于 2022-04-08 21:21:20 首次发布

本文链接：https://blog.csdn.net/qq_43398758/article/details/124051026

版权

操作系统/网络/多线程/Linux/JVM 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

网络发展史

独立模式

独立模式：计算机之间相互独立；
在这里插入图片描述

网络互连

随着时代的发展，越来越需要计算机之间互相通信，共享软件和数据，即以多个计算机协同工作来完成业务，就有了网络互连。
网络互连：将多台计算机连接在一起，完成数据共享。
数据共享本质是网络数据传输，即计算机之间通过网络来传输数据，也称为网络通信。
根据网络互连的规模不同，可以划分为局域网和广域网。

局域网LAN

局域网，即 Local Area Network，简称LAN。
Local即标识了局域网是本地，局部组建的一种私有网络。
局域网内的主机之间能方便的进行网络通信，又称为内网；局域网和局域网之间在没有连接的情况下，是无法通信的。
局域网组建网络的方式有很多种：

（1）基于网线直连
在这里插入图片描述
（2）基于集线器组建

（3）基于交换机组建

（4）基于交换机和路由器组建

在这里插入图片描述

广域网WAN

广域网，即 Wide Area Network，简称WAN。
通过路由器，将多个局域网连接起来，在物理上组成很大范围的网络，就形成了广域网。广域网内部的局域网都属于其子网。

在这里插入图片描述

网络通信基础

网络互连的目的是进行网络通信，也即是网络数据传输，更具体一点，是网络主机中的不同进程间，基于网络传输数据。
那么，在组建的网络中，如何判断到底是从哪台主机，将数据传输到那台主机呢？这就需要使用IP地址来标识。

IP地址

概念
IP地址主要用于标识网络主机、其他网络设备（如路由器）的网络地址。简单说，IP地址用于定位主机的网络地址。
就像我们发送快递一样，需要知道对方的收货地址，快递员才能将包裹送到目的地。
格式
IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节），如：
01100100.00000100.00000101.00000110。
通常用“点分十进制”的方式来表示，即 a.b.c.d的形式（a,b,c,d都是0~255之间的十进制整数）。如：100.4.5.6。
特殊IP

127.*的IP地址用于本机环回(loop back)测试，通常是127.0.0.1
本机环回主要用于本机到本机的网络通信（系统内部为了性能，不会走网络的方式传输），对于开发网络通信的程序（即网络编程）而言，常见的开发方式都是本机到本机的网络通信。

IP地址解决了网络通信时，定位网络主机的问题，但是还存在一个问题，传输到目的主机后，由哪个进程来接收这个数据呢？这就需要端口号来标识。

端口号

概念
在网络通信中，IP地址用于标识主机网络地址，端口号可以标识主机中发送数据、接收数据的进程。简单说：端口号用于定位主机中的进程。
类似发送快递时，不光需要指定收货地址（IP地址），还需要指定收货人（端口号）。

格式
端口号是0~65535范围的数字，在网络通信中，进程可以通过绑定一个端口号，来发送及接收网络数据。
注意事项：
两个不同的进程，不能绑定同一个端口号，但一个进程可以绑定多个端口号。

问题：
有了IP地址和端口号，可以定位到网络中唯一的一个进程，但还存在一个问题，网络通信是基于二进制
0/1数据来传输，如何告诉对方发送的数据是什么样的呢？
网络通信传输的数据类型可能有多种：图片，视频，文本等。同一个类型的数据，格式可能也不同，如发送一个文本字符串“你好！”：如何标识发送的数据是文本类型，及文本的编码格式呢？
基于网络数据传输，需要使用协议来规定双方的数据格式。

认识协议

概念

协议，网络协议的简称，网络协议是网络通信（即网络数据传输）经过的所有网络设备都必须共同遵从的一组约定、规则。如怎么样建立连接、怎么样互相识别等。只有遵守这个约定，计算机之间才能相互通信交流。通常由三要素组成：

1.语法：即数据与控制信息的结构或格式；

类似打电话时，双方要使用同样的语言：普通话

2.语义：即需要发出何种控制信息，完成何种动作以及做出何种响应；

语义主要用来说明通信双方应当怎么做。用于协调与差错处理的控制信息。
类似打电话时，说话的内容。一方道：你瞅啥？另一方就得有对应的响应：瞅你咋的！

3.时序，即事件实现顺序的详细说明。

时序定义了何时进行通信，先讲什么，后讲什么，讲话的速度等。比如是采用同步传输还是异步传输。
女生和男生的通话，总是由男生主动发起通话，而总是在男生恋恋不舍的时候，由女生要求结束通话。

协议（protocol）最终体现为在网络上传输的数据包的格式。

作用

为什么需要协议？
就好比见网友，彼此协商胸口插支玫瑰花见面，这就是一种提前的约定，也可以称之为协议。
在这里插入图片描述
计算机之间的传输媒介是光信号和电信号。通过 "频率"和 "强弱"来表示 0和 1这样的信息。要想传递各种不同的信息，就需要约定好双方的数据格式。

计算机生产厂商有很多；
计算机操作系统，也有很多；
计算机网络硬件设备，还是有很多；
如何让这些不同厂商之间生产的计算机能够相互顺畅的通信?就需要有人站出来，约定一个
共同的标准，大家都来遵守，这就是网络协议；

知名协议的默认端口

系统端口号范围为 0 ~ 65535，其中：0 ~ 1023为知名端口号，这些端口预留给服务端程序绑定广泛使用的应用层协议，如：

22端口：预留给SSH服务器绑定SSH协议
21端口：预留给FTP服务器绑定FTP协议
23端口：预留给Telnet服务器绑定Telnet协议
80端口：预留给HTTP服务器绑定HTTP协议
443端口：预留给HTTPS服务器绑定HTTPS协议

需要补充的是：
以上只是说明 0 ~ 1023范围的知名端口号用于绑定知名协议，但某个服务器也可以使用其他 1024 ~65535范围内的端口来绑定知名协议。

餐厅的VIP包房是给会员使用，但会员也可以不坐包房，坐其他普通座位。

五元组

在TCP/IP协议中，用五元组来标识一个网络通信：

1.源IP：标识源主机
2.源端口号：标识源主机中该次通信发送数据的进程
3.目的IP：标识目的主机
4.目的端口号：标识目的主机中该次通信接收数据的进程
5.协议号：标识发送进程和接收进程双方约定的数据格式

在这里插入图片描述
五元组在网络通信中的作用，类似于发送快递：

可以在cmd中，输入 netstat -ano查看网络数据传输中的五元组信息：

如果需要过滤（一般是通过端口号或进程PID过滤），可以使用 netstat -ano | findstr 过滤字符串

协议分层

对于网络协议来说，往往分成几个层次进行定义。

什么是协议分层

协议分层类似于打电话时，定义不同的层次的协议：

在这里插入图片描述
在这个例子中，我们的协议只有两层；但是实际的网络通信会更加复杂，需要分更多的层次。

分层的作用

为什么需要网络协议的分层？
在这里插入图片描述

分层最大的好处，类似于面向接口编程：定义好两层间的接口规范，让双方遵循这个规范来对接。
在代码中，类似于定义好一个接口，一方为接口的实现类（提供方，提供服务），一方为接口的使用类
（使用方，使用服务）：

对于使用方来说，并不关心提供方是如何实现的，只需要使用接口即可
对于提供方来说，利用封装的特性，隐藏了实现的细节，只需要开放接口即可

这样能更好的扩展和维护，如下图：
在这里插入图片描述

TCP/IP五层（或四层）模型

TCP/IP通讯协议采用了5层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。

应用层：负责应用程序间沟通，如简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。我们的网络编程主要就是针对应用层。
传输层：负责两台主机之间的数据传输。如传输控制协议 (TCP)，能够确保数据可靠的从源主机发送到目标主机。
网络层：负责地址管理和路由选择。例如在IP协议中，通过IP地址来标识一台主机，并通过路由表的方式规划出两台主机之间的数据传输的线路（路由）。路由器（Router）工作在网路层。
数据链路层：负责设备之间的数据帧的传送和识别。例如网卡设备的驱动、帧同步(就是说从网线上检测到什么信号算作新帧的开始)、冲突检测(如果检测到冲突就自动重发)、数据差错校验等工作。有以太网、令牌环网，无线LAN等标准。交换机（Switch）工作在数据链路层。
物理层：负责光/电信号的传递方式。比如现在以太网通用的网线(双绞线)、早期以太网采用的的同轴电缆(现在主要用于有线电视)、光纤，现在的wifi无线网使用电磁波等都属于物理层的概念。物理层的能力决定了最大传输速率、传输距离、抗干扰性等。集线器（Hub）工作在物理层。

在这里插入图片描述
物理层我们考虑的比较少。因此很多时候也可以称为 TCP/IP四层模型。

在这里插入图片描述

参考资料

TCP/IP四层模型和OSI七层模型的概念

网络设备所在分层

对于一台主机，它的操作系统内核实现了从传输层到物理层的内容，也即是TCP/IP五层模型的下四层；
对于一台路由器，它实现了从网络层到物理层，也即是TCP/IP五层模型的下三层；
对于一台交换机，它实现了从数据链路层到物理层，也即是TCP/IP五层模型的下两层；
对于集线器，它只实现了物理层；

注意我们这里说的是传统意义上的交换机和路由器，也称为二层交换机（工作在TCP/IP五层模型的下两层）、三层路由器（工作在TCP/IP五层模型的下三层）。

随着现在网络设备技术的不断发展，也出现了很多3层或4层交换机，4层路由器。我们以下说的网络设备都是传统意义上的交换机和路由器。

网络分层对应
网络数据传输时，经过不同的网络节点（主机、路由器）时，网络分层需要对应。
以下为同一个网段内的两台主机进行文件传输：
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
以下为跨网段的主机的文件传输：数据从一台计算机到另一台计算机传输过程中要经过一个或多个路由器

封装和分用

不同的协议层对数据包有不同的称谓，在传输层叫做段(segment)，在网络层叫做数据报(datagram)，在链路层叫做帧(frame)。
应用层数据通过协议栈发到网络上时，每层协议都要加上一个数据首部(header)，称为封装(Encapsulation)。
首部信息中包含了一些类似于首部有多长，载荷(payload)有多长，上层协议是什么等信息。
数据封装成帧后发到传输介质上，到达目的主机后每层协议再剥掉相应的首部，根据首部中的 "上层协议字段"将数据交给对应的上层协议处理。

下图为数据封装的过程

在这里插入图片描述
下图为数据分用的过程

在这里插入图片描述

网络编程基础

在这里插入图片描述

什么是网络编程

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
在这里插入图片描述

当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
进程A：编程来获取网络资源
进程B：编程来提供网络资源

好比在银行办事：

银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）

常见的客户端服务端模型

最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
1.客户端先发送请求到服务端
2.服务端根据请求数据，执行相应的业务处理
3.服务端返回响应：发送业务处理结果
4.客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）

Socket套接字

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

分类
Socket套接字主要针对传输层协议划分为如下三类：

TCP协议

流套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议。
以下为TCP的特点（细节后续再学习）：

有连接
可靠传输
面向字节流
有接收缓冲区，也有发送缓冲区
大小不限

对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。

UDP协议

数据报套接字：使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
以下为UDP的特点（细节后续再学习）

无连接
不可靠传输
面向数据报
有接收缓冲区，无发送缓冲区
大小受限：一次最多传输64k

在这里插入图片描述

原始套接字

原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。

Java数据报套接字通信模型

对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。
java中使用UDP协议通信，主要基于 DatagramSocket类来创建数据报套接字，并使用DatagramPacket作为发送或接收的UDP数据报。对于一次发送及接收UDP数据报的流程如下：

在这里插入图片描述
以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：

Java流套接字通信模型

在这里插入图片描述

Socket编程注意事项

在这里插入图片描述

1.客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场景，一般都是不同主机。
2.注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程
3. Socket编程我们是使用流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应用层协议，也需要考虑，这块我们在后续来说明如何设计应用层协议。
4.关于端口被占用的问题

如果一个进程A已经绑定了一个端口，再启动一个进程B绑定该端口，就会报错，这种情况也叫端口被占用。对于java进程来说，端口被占用的常见报错信息如下：

在这里插入图片描述
此时需要检查进程B绑定的是哪个端口，再查看该端口被哪个进程占用。以下为通过端口号查进程的方式：

在cmd输入 netstat -ano | findstr 端口号，则可以显示对应进程的pid。如以下命令显示了8888进程的pid

在这里插入图片描述

在任务管理器中，通过pid查找进程

在这里插入图片描述
解决端口被占用的问题：

如果占用端口的进程A不需要运行，就可以关闭A后，再启动需要绑定该端口的进程B
如果需要运行A进程，则可以修改进程B的绑定端口，换为其他没有使用的端口。

UDP数据报套接字编程

DatagramSocket API

DatagramSocket是UDP Socket，用于发送和接收UDP数据报。
DatagramSocket构造方法：
在这里插入图片描述 DatagramSocket方法：

DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报。
DatagramPacket构造方法：
在这里插入图片描述
DatagramPacket方法：

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

InetSocketAddress API
InetSocketAddress（ SocketAddress的子类）构造方法
在这里插入图片描述

示例一：一发一收（无响应）

以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：
UDP服务端

package org.example.udp.demo1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Arrays;
public class UdpServer {
   //服务器socket要绑定固定的端口
   private static final int PORT = 8888;
   public static void main(String[] args) throws IOException {
       // 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
       DatagramSocket socket = new DatagramSocket(PORT);
       //不停的接收客户端udp数据报
       while (true){
           // 2.创建数据报，用于接收客户端发送的数据
           byte[] bytes = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最多
64k（包含UDP首部8byte）
           DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
           System.out.println("------------------------------------------------
---");
           System.out.println("等待接收UDP数据报...");
           // 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
           socket.receive(packet);
           System.out.printf("客户端IP：%s%n",
packet.getAddress().getHostAddress());
           System.out.printf("客户端端口号：%s%n", packet.getPort());
           System.out.printf("客户端发送的原生数据为：%s%n",
Arrays.toString(packet.getData()));
           System.out.printf("客户端发送的文本数据为：%s%n", new
String(packet.getData()));
      }
  }
}

运行后，服务端就启动了，控制台输出如下：

---------------------------------------------------
等待接收UDP数据报...

可以看出，此时代码是阻塞等待在 socket.receive(packet)代码行，直到接收到一个UDP数据报。

UDP客户端

package org.example.udp.demo1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
public class UdpClient {
   // 服务端socket地址，包含域名或IP，及端口号
   private static final SocketAddress ADDRESS = new
InetSocketAddress("localhost", 8888);
   public static void main(String[] args) throws IOException {
       // 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
       DatagramSocket socket = new DatagramSocket();
       // 5-1.准备要发送的数据
       byte[] bytes = "hello world!".getBytes();
       // 5-2.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
       DatagramPacket packet = new DatagramPacket(bytes, bytes.length,
ADDRESS);
       // 6.发送UDP数据报
       socket.send(packet);
  }
}

客户端启动后会发送一个"hello world!"的字符串到服务端，在服务端接收后，控制台输出内容如下：

---------------------------------------------------
等待接收UDP数据报...
客户端IP：127.0.0.1
客户端端口号：57910
客户端发送的原生数据为：[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33,
0, 0, 0, ...此处省略很多0]
客户端发送的文本数据为：hello world!                                                
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
   
---------------------------------------------------
等待接收UDP数据报...

从以上可以看出，发送的UDP数据报（假设发送的数据字节数组长度为M），在接收到以后（假设接收
的数据字节数组长度为N）：

如果N>M，则接收的byte[]字节数组中会有很多初始化byte[]的初始值0，转换为字符串就是空白
字符；
如果N<M，则会发生数据部分丢失（可以自己尝试，把接收的字节数组长度指定为比发送的字节
数组长度更短）。

要解决以上问题，就需要发送端和接收端双方约定好一致的协议，如规定好结束的标识或整个数据的长度。

示例二：请求响应

示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：
构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务
（1）客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
（2）发送请求：将该相对路径作为数据报发送到服务端
（3）服务端接收并处理请求：根据该请求数据，作为本地目录的路径，列出下一级子文件及子文件夹
（4）服务端返回响应：遍历子文件和子文件夹，每个文件名一行，作为响应的数据报，返回给客户端
（5）客户端接收响应：简单的打印输出所有的响应内容，即文件列表。
为了解决空字符或长度不足数据丢失的问题，客户端服务端约定好统一的协议：这里简单的设计为ASCII结束字符 \3表示报文结束。
以下为整个客户端服务端的交互执行流程：

在这里插入图片描述
以下为服务端和客户端代码：

UDP服务端

package org.example.udp.demo2;
import java.io.File;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
public class UdpServer {
   //服务器socket要绑定固定的端口
   private static final int PORT = 8888;
   //本地文件目录要展示的根路径
   private static final String BASE_PATH = "E:/TMP";
   public static void main(String[] args) throws IOException {
       // 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
       DatagramSocket socket = new DatagramSocket(PORT);
       //不停的接收客户端udp数据报
       while (true){
           // 2.创建数据报，用于接收客户端发送的数据
           byte[] requestData = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最
多64k（包含UDP首部8byte）
           DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length);
           System.out.println("------------------------------------------------
---");
           System.out.println("等待接收UDP数据报...");
           // 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
           socket.receive(requestPacket);
           System.out.printf("客户端IP：%s%n",
requestPacket.getAddress().getHostAddress());
           System.out.printf("客户端端口号：%s%n", requestPacket.getPort());
           // 7.接收到的数据作为请求，根据请求数据执行业务，并返回响应
           for (int i = 0; i < requestData.length; i++) {
               byte b = requestData[i];
               if(b == '\3') {
                   // 7-1.读取请求的数据：读取到约定好的结束符（\3），取结束符之前的内容
                   String request = new String(requestData, 0, i);
                   // 7-2.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列
出下一级子文件
                   //请求的文件列表目录
                   System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
request);
                   File dir = new File(BASE_PATH + request);
                   //获取下一级子文件，子文件夹
                   File[] children = dir.listFiles();
                   // 7-3.构造要返回的响应内容：每个文件及目录名称为一行
                   StringBuilder response = new StringBuilder();
                   if(children != null){
                       for (File child : children) {
                           response.append(child.getName()+"\n");
                      }
                  }
                   //响应也要约定结束符
                   response.append("\3");
                   byte[] responseData =
response.toString().getBytes(StandardCharsets.UTF_8);
                   // 7-4.构造返回响应的数据报DatagramPacket，注意接收的客户端数据报包
含IP和端口号，要设置到响应的数据报中
                   DatagramPacket responsePacket = new
DatagramPacket(responseData, responseData.length,
requestPacket.getSocketAddress());
                   // 7-5.发送返回响应的数据报
                   socket.send(responsePacket);
                   break;
              }
          }
      }
  }
}

以上服务端运行结果和示例一是一样的：

---------------------------------------------------
等待接收UDP数据报...

UDP客户端

package org.example.udp.demo2;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class UdpClient {
   // 服务端socket地址，包含域名或IP，及端口号
   private static final SocketAddress ADDRESS = new
InetSocketAddress("localhost", 8888);
   public static void main(String[] args) throws IOException {
       // 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
       DatagramSocket socket = new DatagramSocket();
       // 5-1.准备要发送的数据：这里调整为键盘输入作为发送的内容
       Scanner scanner = new Scanner(System.in);
       while(true){
           System.out.println("------------------------------------------------
---");
           System.out.println("请输入要展示的目录：");
           // 5-2.每输入新行（回车），就作为UDP发送的数据报，为了接收端获取有效的内容（去除
空字符串），约定\3为结束
           String request = scanner.nextLine() + "\3";
           byte[] requestData = request.getBytes(StandardCharsets.UTF_8);
           // 5-3.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
           DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length, ADDRESS);
           // 6.发送UDP数据报
           socket.send(requestPacket);
           // 8.接收服务端响应的数据报，并根据响应内容决定下个步骤（我们这里简单的打印即可）
           // 8-1.创建数据报，用于接收服务端返回（发送）的响应
           byte[] responseData = new byte[1024];
           DatagramPacket responsePacket = new DatagramPacket(responseData,
responseData.length);
           // 8-2.接收响应数据报
           socket.receive(responsePacket);
           System.out.println("该目录下的文件列表为：");
           // byte[]下次解析的起始位置
           int next = 0;
           for (int i = 0; i < responseData.length; i++) {
               byte b = responseData[i];
               if(b == '\3')//结束符退出
                   break;
               if(b == '\n'){//换行符时进行解析
                   //起始位置到换行符前一个索引位置为要解析的内容
                   String fileName = new String(responseData, next, i-next);
                   System.out.println(fileName);
                   //下次解析从换行符后一个索引开始
                   next = i+1;
              }
          }
      }
  }
}

客户端启动后会等待输入要展示的路径：

---------------------------------------------------
请输入要展示的目录

在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：

---------------------------------------------------
请输入要展示的目录：
/
该目录下的文件列表为：
1
2
60441b1b8a74be3695ccc0d970693815
8f25103aa249707ee4ab17635142cd0e
---------------------------------------------------
请输入要展示的目录：

此时服务端也会打印接收到的客户端请求数据：

---------------------------------------------------
等待接收UDP数据报...
客户端IP：127.0.0.1
客户端端口号：57297
客户端请求的文件列表路径为：E:/TMP/
---------------------------------------------------
等待接收UDP数据报...

TCP流套接字编程

和刚才UDP类似.实现一个简单的英译汉的功能

ServerSocket API

ServerSocket是创建TCP服务端Socket的API。
ServerSocket构造方法：
在这里插入图片描述
ServerSocket方法：

Socket API

Socket是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket构造方法
在这里插入图片描述
Socket方法：

在这里插入图片描述
TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数
据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：

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

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

由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在一个线程中运行。
一次阻塞等待对应着一次请求、响应，不停处理也就是长连接的特性：一直不关闭连接，不停的处理请求。

实际应用时，服务端一般是基于NIO（即同步非阻塞IO）来实现长连接，性能可以极大的提升。

示例一：一发一收（短连接）

以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：

TCP服务端

package org.example.tcp.demo1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
   //服务器socket要绑定固定的端口
   private static final int PORT = 8888;
   public static void main(String[] args) throws IOException {
       // 1.创建一个服务端ServerSocket，用于收发TCP报文
       ServerSocket server = new ServerSocket(PORT);
       // 不停的等待客户端连接
       while(true) {
           System.out.println("------------------------------------------------
---");
           System.out.println("等待客户端建立TCP连接...");
           // 2.等待客户端连接，注意该方法为阻塞方法
           Socket client = server.accept();
           System.out.printf("客户端IP：%s%n",
client.getInetAddress().getHostAddress());
           System.out.printf("客户端端口号：%s%n", client.getPort());
           // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
           System.out.println("接收到客户端请求：");
           InputStream is = client.getInputStream();
           // 为了方便获取字符串内容，可以将以上字节流包装为字符流
           BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
           String line;
           // 一直读取到流结束：TCP是基于流的数据传输，一定要客户端关闭Socket输出流才表示服
务端接收IO输入流结束
           while ((line = br.readLine()) != null) {
               System.out.println(line);
          }
           // 6.双方关闭连接：服务端是关闭客户端socket连接
           client.close();
      }
  }
}

运行后，服务端就启动了，控制台输出如下：

---------------------------------------------------
等待客户端建立TCP连接...

可以看出，此时代码是阻塞等待在 server.accept()代码行，直到有新的客户端申请建立连接。

TCP客户端

package org.example.tcp.demo1;
import java.io.*;
import java.net.Socket;
public class TcpClient {
   //服务端IP或域名
   private static final String SERVER_HOST = "localhost";
   //服务端Socket进程的端口号
   private static final int SERVER_PORT = 8888;
   public static void main(String[] args) throws IOException {
       // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
       Socket client = new Socket(SERVER_HOST, SERVER_PORT);
       // 4.发送TCP数据，是通过socket中的输出流进行发送
       OutputStream os = client.getOutputStream();
       // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
       PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
       // 4-1.发送数据：
       pw.println("hello world!");
       // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
       pw.flush();
       // 7.双方关闭连接：客户端关闭socket连接
       client.close();
  }
}

客户端启动后会发送一个"hello world!"的字符串到服务端，在服务端接收后，控制台输出内容如下：

---------------------------------------------------
等待客户端建立TCP连接...
客户端IP：127.0.0.1
客户端端口号：51118
接收到客户端请求：
hello world!
---------------------------------------------------
等待客户端建立TCP连接...

以上客户端与服务端建立的为短连接，每次客户端发送了TCP报文，及服务端接收了TCP报文后，双方都会关闭连接。

示例二：请求响应（短连接）

示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：
构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务
（1）客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
（2）发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
（3）服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。
（4）服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。
（5）客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。
以下为服务端和客户端代码：
TCP服务端

package org.example.tcp.demo2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
   //服务器socket要绑定固定的端口
   private static final int PORT = 8888;
   //本地文件目录要展示的根路径
   private static final String BASE_PATH = "E:/TMP";
   public static void main(String[] args) throws IOException {
       // 1.创建一个服务端ServerSocket，用于收发TCP报文
       ServerSocket server = new ServerSocket(PORT);
       // 不停的等待客户端连接
       while(true) {
           System.out.println("------------------------------------------------
---");
           System.out.println("等待客户端建立TCP连接...");
           // 2.等待客户端连接，注意该方法为阻塞方法
           Socket socket = server.accept();
           System.out.printf("客户端IP：%s%n",
socket.getInetAddress().getHostAddress());
           System.out.printf("客户端端口号：%s%n", socket.getPort());
           // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
           InputStream is = socket.getInputStream();
           // 为了方便获取字符串内容，可以将以上字节流包装为字符流
           BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
           // 客户端请求只发送一行数据，我们也只需要读取一行
           String request = br.readLine();
           // 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文
件
           //请求的文件列表目录
           System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
request);
           File dir = new File(BASE_PATH + request);
           //获取下一级子文件，子文件夹
           File[] children = dir.listFiles();
           // 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
           OutputStream os = socket.getOutputStream();
           // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
           PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-
8"));
           // 7-1.返回的响应内容：每个文件及目录名称为一行
           if(children != null){
               for (File child : children) {
                   pw.println(child.getName());
              }
          }
           // 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
           pw.flush();
           // 7-3.双方关闭连接：服务端是关闭客户端socket连接
           socket.close();
      }
  }
}

以上服务端运行结果和示例一是一样的：

---------------------------------------------------
等待客户端建立TCP连接...

TCP客户端

package org.example.tcp.demo2;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class TcpClient {
   //服务端IP或域名
   private static final String SERVER_HOST = "localhost";
   //服务端Socket进程的端口号
   private static final int SERVER_PORT = 8888;
   public static void main(String[] args) throws IOException {
       // 准备要发送的数据：这里调整为键盘输入作为发送的内容
       Scanner scanner = new Scanner(System.in);
       while(true) {
           System.out.println("------------------------------------------------
---");
           System.out.println("请输入要展示的目录：");
           // 每输入新行（回车），就作为发送的TCP请求报文
           String request = scanner.nextLine();
           // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
           Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
           // 4.发送TCP数据，是通过socket中的输出流进行发送
           OutputStream os = socket.getOutputStream();
           // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
           PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-
8"));
           // 4-1.发送数据：
           pw.println(request);
           // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
           pw.flush();
           // 8.接收返回的响应数据：通过socket中的输入流获取
           System.out.println("接收到服务端响应：");
           InputStream is = socket.getInputStream();
           // 为了方便获取字符串内容，可以将以上字节流包装为字符流
           BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
           String line;
           // 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客
户端接收的IO输入流结束
           while ((line = br.readLine()) != null) {
               System.out.println(line);
          }
           // 9.双方关闭连接：客户端关闭socket连接
           socket.close();
      }
  }
}

客户端启动后会等待输入要展示的路径：

---------------------------------------------------
请输入要展示的目录：

在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：

---------------------------------------------------
请输入要展示的目录：
/
接收到服务端响应：
1
2
60441b1b8a74be3695ccc0d970693815
8f25103aa249707ee4ab17635142cd0e
---------------------------------------------------
请输入要展示的目录：

此时服务端也会打印接收到的客户端请求数据：

---------------------------------------------------
等待客户端建立TCP连接...
客户端IP：127.0.0.1
客户端端口号：52493
客户端请求的文件列表路径为：E:/TMP/
---------------------------------------------------
等待客户端建立TCP连接...

目前TCP客户端和服务端实现的功能和UDP差不多，但都存在几个问题：

对于服务端来说，处理一次请求并返回响应后，才能再次处理下一次请求和响应，效率是比较低的。这个问题比较好解决：可以使用多线程，每次的请求与响应都在线程中处理。这样多个客户端请求的话，可以在多个线程中并发并行的执行。
服务端解析请求，是只读取了一行，而客户端解析响应，是一直读取到流结束。可以想想为什么解析请求时，没有读取到流结束？

目前的业务，双方都已约定好业务是展示目录下的文件列表，且都只需要一种数据：请求传输的数据代表要展示的目录；响应传输的数据代表文件列表：每一行为一个文件名。
如要提供更多的业务，如文件重命名，文件删除等操作时，就不能了。此时就需要提供更多的字段来标识。一般我们需要设计更强大的协议。

再谈协议

回顾并理解为什么需要协议
以上我们实现的UDP和TCP数据传输，除了UDP和TCP协议外，程序还存在应用层自定义协议，可以想想分别都是什么样的协议格式。
对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：

客户端发送请求和服务端解析请求要使用相同的数据格式。
服务端返回响应和客户端解析响应也要使用相同的数据格式。
请求格式和响应格式可以相同，也可以不同。
约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。

封装/分用 vs序列化/反序列化

在这里插入图片描述

一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java一般就是将对象转换为某种协议格式），即对发送数据时的数据包装动作来说：

如果是使用知名协议，这个动作也称为封装
如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为特定的数据格式。
接收端应用程序，接收数据时的数据转换，即对接收数据时的数据解析动作来说：
如果是使用知名协议，这个动作也称为分用
如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的格式，转换为程序中的对象

如何设计协议

对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
对于定长的字段：

可以基于长度约定，如int字段，约定好4个字节即可

对于不定长的字段：

可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：
- “数据”字段本身，不定长，需要通过“长度”字段来解析；
- “长度”字段，标识该“数据”的长度，即用于辅助解析“数据”字段；

示例三：多线程+自定义协议

详情见讲义。

补充：

在这里插入图片描述

旧时言

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaEE - 网络初始之TCP/IP五层模型

网络编程网络编程基础什么是网络编程网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：进程A：编程来获取网络资源进程B：编程来提供网络资源网络编程中的基本概念发送端和接收端
复制链接

扫一扫