JavaSE补充 | 网络编程

冷不防 2024-03-24 03:29 53阅读 0赞

**目录**

一：网络编程

1. 网络编程概述

2. 网络通信要素

3. 传输层协议：TCP 与 UDP 协议

4. 网络编程 API

5. TCP网络编程

6. UDP 网络编程

7. URL编程

--------------------

## 一：网络编程 ##

#### 1. 网络编程概述 ####

> Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。
> 
> Java提供的网络类库，可以实现无痛（丝滑）的网络连接，联网的底层细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库，`程序员面对的是一个统一的网络编程环境`。

**（1）软件架构**

**C/S架构** ：全称为Client/Server结构，是指客户端和服务器结构。

常见程序有QQ、美团app、360安全卫士等软件。

## ![8339e357d5484208b8e70f95f68ff47c.png][] ##

**B/S 架构 ：**全称为 Browser/Server 结构，是指浏览器和服务器结构。

常见浏览器有 IE、谷歌、火狐等。

#### ![fe851922182e48289655400440a61d00.png][] ####

**总结：**两种架构各有优势，但是无论哪种架构，都离不开网络的支持；网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

**（2）网络基础**

> **计算机网络：** 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成 一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。
> 
> **网络编程的目的：**直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

**网络编程中有三个主要的问题：**

> 问题 1：如何准确地定位网络上一台或多台主机？**IP地址**
> 
> 问题 2：如何定位主机上的特定的应用？**端口号**
> 
> 问题 3：找到主机后，如何可靠、高效地进行数据传输？ **网络通信协议**

#### 2. 网络通信要素 ####

如何实现网络中的主机互相通信？

> 通信双方地址：IP、端口号。
> 
> 一定的规则：不同的硬件、操作系统之间的通信，所有的这一切都需要一种规则；而我们就把这种规则称为协议，即网络通信协议。

生活类比：

![52a5f8ef1cad409d8dedd5ecd87f94f2.png][]

**通信要素一：IP地址和域名**

> **IP地址：指互联网协议地址（Internet Protocol Address）**，俗称IP。IP地址用来给网络中的一台计算机设备做唯一的编号；假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

**IP地址分类方式一：**

> **`IPv4`：**是一个**32位的二进制数**，通常被分为**4个字节**，表示成`a.b.c.d` 的形式，以点分`十进制`表示，例如`192.168.65.100` 。其中a、b、c、d都是0~255之间的十进制整数。

![f21d39dba2944565918a8b71071cc828.png][]

IP地址 = 网络地址 +主机地址

> 网络地址：标识计算机或网络设备所在的网段；
> 
> 主机地址：标识特定主机或网络设备；

![e8c00fa13c33431bb254b5260b0cb563.png][]

**注：**其中，E 类用于科研！

> **IPv6：**由于互联网的蓬勃发展，IP 地址的需求量愈来愈大，但是网络地址资源有限，使得 IP 的分配越发紧张。

> 为了扩大地址空间，拟通过 IPv6 重新定义地址空间，采用 **128 位地址**长度，共 **16 个字节**，写成 8 个无符号整数，每个整数用四个十六进制位表示，数之间用冒号 （:）分开。比如：ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，按保守方法估算 IPv6 实际可分配的地址，整个地球的每平方米面积上仍可分配 1000 多个地 址，这样就解决了网络地址资源数量不够的问题。
> 
> 在 IPv6 的设计过程中除了一劳永逸地解决了地址短缺问题以外，还考虑了在 IPv4 中解决不好的其它问题，主要有端到端 IP 连接、服务质量（QoS）、安全性、多 播、移动性、即插即用等。

**IP 地址分类方式二：**

> **公网地址( 万维网使用）**和 **私有地址( 局域网使用）**。**192.168.开头的就是私有地址**，范围即为 192.168.0.0-------->192.168.255.255，专门为组织机构内部使用。

**常用命令：**

查看本机 IP 地址，在控制台输入：

ipconfig #查看ip

检查网络是否连通，在控制台输入：

ping www.baidu.com.cn #ping百度

特殊的 IP 地址：

本地回环地址(hostAddress)：127.0.0.1 
    主机名(hostName)：localhost

域名：

Internet 上的主机有两种方式表示地址：

> 域名(hostName)：www.baidu.com.cn
> 
> IP 地址(hostAddress)：120.232.145.144

域名解析：

> 因为 IP 地址数字不便于记忆，因此出现了域名。域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS，Domain Name System，域名系统)负责将域名转化成 IP 地址，这样才能和主机建立连接。

简单理解：

![9556144af07342c59cfda2aa8912b611.png][]

**通信要素二：端口号**

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

> 如果说 **IP 地址可以唯一标识网络中的设备**，那么**端口号就可以唯一标识设备中的进程（应用程序）**；**不同的进程，设置不同的端口号（防止造成端口冲突）**！

端口号：用两个字节表示的整数，它的**取值范围是 0~65535**

> 公认端口：0~1023；被预先定义的服务通信占用，如：HTTP（80），FTP （21），Telnet（23）。
> 
> 注册端口：1024~49151。分配给用户进程或应用程序，如：Tomcat （8080），MySQL（3306），Oracle（1521）。
> 
> 动态/ 私有端口：49152~65535。
> 
> **注：**如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败！

**通信要素三：网络通信协议**

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样！

> 网络通信协议：在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤、出错控制等做了统一规定，通信双方必须 同时遵守才能完成数据交换。

新的问题：网络协议涉及内容太多、太复杂；如何解决？

> 计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？
> 
> **答：通信协议分层思想！**在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系；各层互不影响，利于系统的开发和扩展。

两套参考模型：

> **OSI 参考模型：模型过于理想化，未能在因特网上进行广泛推广 。**
> 
> **TCP/IP 参考模型(或 TCP/IP 协议)：事实上的国际标准。**

![ce275eeb84014426b22c04f591a4f4f5.png][]

TCP/IP 参考模型(或 TCP/IP 协议)：事实上的国际标准

> **TCP/IP 协议：** 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，TCP/IP 以其两个主要协议：**传输控制协议(TCP)和网络互联协议(IP)**而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。 是 Internet 最基本、最广泛的协议。

![ced5376aedbc49359d7a963fe2231141.png][]

TCP/IP 协议中的四层介绍：

> **应用层：**应用层决定了向用户提供应用服务时通信的活动。主要协议有：**HTTP协议**、FTP 协议、SNMP（简单网络管理协议）、SMTP（简单邮件传输协议）和 POP3 （Post Office Protocol 3 的简称,即邮局协议的第 3 个版）等。

> **传输层：**主要使网络程序进行通信，在进行网络通信时，可以采用 **TCP 协议**，也可以采用 **UDP 协议**。
> 
> **TCP（Transmission Control Protocol）协议：**即传输控制协议，是 一种**面向连接的、可靠的、基于字节流的传输层通信协议**。
> 
> **UDP(User Datagram Protocol，用户数据报协议)：**是一个**无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务**。

> **网络层：**网络层是整个 TCP/IP 协议的核心，支持网间互连的数据通信。它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。而 IP 协议是一种非常重要的协议。**IP（internet protocal）又称为互联网协议**。IP 的责任就是把数据从源传送到目的地。它在源地址和目的地址之间传送一种称之为数据包的东西，它还提供对数据大小的重新组装功能，以适应不同网络对包大小的要求。

> **物理+数据链路层**：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。

![3d6d441d4cd34ef38443c785a5e1a5a5.png][]

#### **3. 传输层协议：TCP 与 UDP 协议** ####

> 通信的协议还是比较复杂的，**java.net** 包中包含的类和接口，它们提供低层次 的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

**java.net 包**中提供了两种常见的网络协议的支持：

> UDP：用户数据报协议(User Datagram Protocol)。
> 
> TCP：传输控制协议 (Transmission Control Protocol)。

**（1）TCP 协议与 UDP 协议**

**TCP 协议：**

> ①TCP 协议进行通信的两个应用进程：客户端、服务端；
> 
> ②使用 TCP 协议前，须**先建立 TCP 连接**，形成基于字节流的传输数据通道；
> 
> ③传输前，采用“三次握手”方式，点对点通信，**是可靠的**。TCP 协议使用**重发机制**，当一个通信实体发送一个消息给另一个通信实体后，需要收到另一个通信实体确认信息，如果没有收到另一个通信实体确认信息，则会再次重复刚才发送的消息；
> 
> ④在连接中可进行**大数据量的传输；**
> 
> ⑤传输完毕，需**释放已建立的连接，效率低。**

**TCP 生活案例：打电话；**

**UDP 协议：**

> ①UDP 协议进行通信的两个应用进程：发送端、接收端。
> 
> ②将数据、源、目的封装成数据包（传输的基本单位），**不需要建立连接**
> 
> ③发送不管对方是否准备好，接收方收到也不确认，不能保证数据的完整性，故是**不可靠的**④每个数据报的**大小限制在 64K** 内。
> 
> ⑤发送数据结束时**无需释放资源，开销小，通信效率高**。
> 
> ⑥适用场景：音频、视频和普通数据的传输；例如视频会议（丢失几帧也没事）。

**UDP 生活案例：发送短信、发电报 ；**

**（2）三次握手**

> TCP 协议中，在发送数据的准备阶段，客户端与服务器之间的**三次交互，以保证连接的可靠**
> 
> ①第一次握手，客户端向服务器端发起 TCP 连接的请求；
> 
> ②第二次握手，服务器端发送针对客户端 TCP 连接请求的确认；
> 
> ③第三次握手，客户端发送确认的确认；

![612c2b744f0a40a786998f76af67c051.png][]

> ①客户端会随机一个初始序列号 seq=x，设置 SYN=1 ，表示这是 SYN 握手报文。然后就可以把这个 SYN 报文发送给服务端了，表示 向服务端发起连接，之后客户端处于**同步已发送**状态。
> 
> ②服务端收到客户端的 SYN 报文后，也随机一个初始序列号 (seq=y)，设置 ack=x+1，表示收到了客户端的 x 之前的数据，希望客户端下次发送的数据从 x+1 开始。 设置 SYN=1 和 ACK=1。表示这是一个 SYN 握手和 ACK 确认应答报文。最后把该报文发给客户端，该报文也不包含应用层数据，之后服务端处于**同步已接收**状态。
> 
> ③客户端收到服务端报文后，还要向服务端回应最后一个应答报文， 将 ACK 置为 1 ，表示这是一个应答报文 ack=y+1 ，表示收到了服务器的 y 之前的数据，希望服务器下次发送的数据从 y+1 开始。 最后把报文发送给服务端，这次报文可以携带数据，之后客户端处于连接 已建立状态。服务器收到客户端的应答报文后，也进入**连接已建立**状 态。

**总结：**

> 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，**TCP 协议**可以保证传输数据的安全，所以应用十分广 泛，例如：**下载文件、浏览网页等！**

**（3）四次挥手**

> TCP 协议中，在发送数据结束后，**释放连接时需要经过“四次挥手”！**
> 
> ①第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
> 
> ②第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
> 
> ③第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
> 
> ④第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待 2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待 2MSL 后，没有收到，那么彻底断开。

![a1d10215f02c4485bd6b649259195106.png][]

> ①客户端打算断开连接，向服务器发送 FIN 报文(FIN 标记位被设置为 1，1 表示为 FIN，0 表示不是)，FIN 报文中会指定一个序列号，之后客户端进入 FINWAIT1 状态。也就是客户端发出连接释放报文段(FIN 报文)，指定序列号 seq = u，主动关闭 TCP 连接，等待服务器的确认。
> 
> ②服务器收到连接释放报文段(FIN 报文)后，就向客户端发送 ACK 应 答报文，以客户端的 FIN 报文的序列号 seq+1 作为 ACK 应答报文段 的确认序列号 ack = seq+1 = u + 1。接着服务器进入 CLOSEWAIT(等 待关闭)状态，此时的 TCP 处于半关闭状态(下面会说什么是半关闭状 态)，客户端到服务器的连接释放。客户端收到来自服务器的 ACK 应答 报文段后，进入 FINWAIT\_2 状态。
> 
> ③服务器也打算断开连接，向客户端发送连接释放(FIN)报文段，之后 服务器进入 LASK\_ACK(最后确认)状态，等待客户端的确认。服务器的连接释放(FIN)报文段的 FIN=1，ACK=1，序列号 seq=m，确认序列号 ack=u+1。
> 
> ④客户端收到来自服务器的连接释放(FIN)报文段后，会向服务器发送 一个 ACK 应答报文段，以连接释放(FIN)报文段的确认序号 ack 作为 ACK 应答报文段的序列号 seq，以连接释放(FIN)报文段的序列号 seq+1 作为确认序号 ack。

**总结：**

> 之后客户端进入 TIMEWAIT(时间等待)状态，服务器收到 ACK 应答报文 段后，服务器就进入 CLOSE(关闭)状态，到此服务器的连接已经完成关闭。客户端处于 TIMEWAIT 状态时，此时的 TCP 还未释放掉，需要 等待 2MSL 后，客户端才进入 CLOSE 状态。

#### 4. 网络编程 API ####

**（1）InetAddress类**

> InetAddress 类主要表示 IP 地址，两个子类：Inet4Address、Inet6Address！

InetAddress类没有提供公共的构造器，而是提供了静态方法来获取InetAddress实例：

public static InetAddress getLocalHost() //  返回本地主机的地址
    public static InetAddress getByName(String host) // 确定主机的IP地址，给定主机名

①获取本机的IP对应的InetAddress的实例

package com.zl.net;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class InetAddressTest {
        public static void main(String[] args) {
            try {
                InetAddress localHost = InetAddress.getLocalHost();
                System.out.println(localHost); // LAPTOP-NTM9SN7U/192.168.2.2
            } catch (UnknownHostException e) {
                throw new RuntimeException(e);
            }
        }
    }

②获取指定的IP对应的InetAddress的实例

package com.zl.net;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class InetAddressTest {
        public static void main(String[] args) {
            try {
                // 直接传IP地址的字符串
                InetAddress address = InetAddress.getByName("192.168.2.2");
                System.out.println(address); // /192.168.2.2
    
                // 或者传域名（通过域名解析IP地址）
                InetAddress inetAddress = InetAddress.getByName("www.baidu.com.cn");
                System.out.println(inetAddress); // www.baidu.com.cn/120.232.145.144
    
            } catch (UnknownHostException e) {
                throw new RuntimeException(e);
            }
        }
    }

InetAddress 提供了如下几个常用的方法：

public String getHostAddress() // 返回 IP 地址字符串（以文本表现形式） 
    public String getHostName() // 获取此 IP 地址的主机名

获取域名和IP

package com.zl.net;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class InetAddressTest {
        public static void main(String[] args) {
            try {
                InetAddress inet = InetAddress.getByName("www.baidu.com.cn");
                // 获取域名
                String hostName = inet.getHostName();
                System.out.println(hostName); // www.baidu.com.cn
                // 获取IP
                String hostAddress = inet.getHostAddress();
                System.out.println(hostAddress); // 120.232.145.185
            } catch (UnknownHostException e) {
                throw new RuntimeException(e);
            }
        }
    }

**（2）Socket类**

> ①网络上具有唯一标识的**IP地址和端口号**组合在一起构成唯一能识别的标识符套接字（Socket）。
> 
> ②利用**套接字(Socket)**开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。**网络通信其实就是Socket间的通信。** 
> 
> ③通信的两端都要有Socket，是两台机器间通信的端点。
> 
> ④Socket允许程序把网络连接当成一个流，数据在**两个Socket间通过IO传输**。
> 
> ⑤一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

**Socket分类：**

流套接字（stream socket）：使用**TCP**提供可依赖的字节流服务

> ①**ServerSocket：**此类实现TCP服务器套接字，**服务器套接字**等待请求通过网络传入。
> 
> ②**Socket：**此类实现**客户端套接字**（也可以就叫“套接字”）。套接字是两台机器间通信的端点。

数据报套接字（datagram socket）：使用**UDP**提供“尽力而为”的数据报服务

> ①**DatagramSocket：**此类表示用来**发送和接收UDP数据包的套接字**。

**（3）Socket相关类API**

①ServerSocket类

**ServerSocket类的构造方法：**

ServerSocket(int port)  // 创建绑定到特定端口的服务器套接字。

**ServerSocket类的常用方法：**

Socket accept() // 侦听并接受到此套接字的连接。

②Socket类

**Socket类的常用构造方法**：

public Socket(InetAddress address,int port) // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
    public Socket(String host,int port) // 创建一个流套接字并将其连接到指定主机上的指定端口号。

**Socket类的常用方法**：

public InputStream getInputStream() // 返回此套接字的输入流，可以用于接收消息
    public OutputStream getOutputStream() // 返回此套接字的输出流，可以用于发送消息
    public InetAddress getInetAddress() // 此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null
    public InetAddress getLocalAddress() // 获取套接字绑定的本地地址
    public int getPort() // 此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0
    public int getLocalPort() // 返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1
    public void close() // 关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。 
    public void shutdownInput() // 如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
    public void shutdownOutput() // 禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。

**注意：**先后调用Socket的shutdownInput()和shutdownOutput()方法，仅仅关闭了输入流和输出流，并不等于调用Socket的close()方法。在通信结束后，仍然要调用Scoket的close()方法，因为只有该方法才会释放Socket占用的资源，比如：占用的本地端口号等。

③DatagramSocket类

**DatagramSocket 类的常用方法：**

public DatagramSocket(int port)  // 创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择
    public DatagramSocket(int port,InetAddress laddr) // 创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址，IP 地址由内核选择
    public void close() // 关闭此数据报套接字
    public void send(DatagramPacket p) // 从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号
    public void receive(DatagramPacket p) // 从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。 此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短
    public InetAddress getLocalAddress() // 获取套接字绑定的本地地址
    public int getLocalPort() // 返回此套接字绑定的本地主机上的端口号
    public InetAddress getInetAddress() // 返回此套接字连接的地址。如果套接字未连接，则返回 null
    public int getPort() // 返回此套接字的端口。如果套接字未连接，则返回 -1

#### 5. TCP网络编程 ####

**（1）通信模型**

Java语言的基于套接字TCP编程分为服务端编程和客户端编程，其通信模型如图所示：

![0a737c565fab487e9e989c68fda1b0a8.png][]

**（2）开发步骤**

**客户端程序包含以下四个基本的步骤 ：**

> ①创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路；若连接失败，会出现异常。
> 
> ②打开连接到 Socket 的输入/ 出流： 使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输。
> 
> ③按照一定的协议对 Socket 进行读/ 写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线路。
> 
> ④关闭 Socket ：断开客户端到服务器的连接，释放线路 。

package com.zl.net;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    // 客户端
    public class SocketTest {
        public static void main(String[] args) {
            OutputStream os = null;
            Socket socket = null;
            try {
                // 第一步：创建一个Socket对象（构造方法指定对方的IP地址和端口号）
                // IP
                InetAddress inetAddress = InetAddress.getByName("192.168.2.2");
                // 端口号
                int port = 8989;
                socket = new Socket(inetAddress, port);
                // 第二步：拿到输出流
                os = socket.getOutputStream();
                // 第三步：写数据
                os.write("你好，我是客户端".getBytes()); // 传的是一个字节数组
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 第四步：关闭资源（socket和流都要关闭）
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                try {
                    if (os != null) {
                        os.close();
                    }
                } catch (IOException e) {
                   e.printStackTrace();
                }
            }
    
    
        }
    }

**服务器端程序包含以下四个基本的步骤：**

> ①调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上，用于监听客户端的请求。
> 
> ②调用 accept() ：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
> 
> ③调用该Socket 类对象的 getOutputStream() 和 getInputStream () ：获取输出流和输入流，开始网络数据的发送和接收。
> 
> ④ 关闭Socket 对象：客户端访问结束，关闭通信套接字。

package com.zl.net;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    
    public class ServerSocketTest {
        public static void main(String[] args)  {
            Socket socket = null;
            InputStream is = null;
            try {
                // 第一步：创建一个ServerSocket
                int port = 8989;
                ServerSocket serverSocket = new ServerSocket(port);
                // 第二步：调用accept方法，接收客户端的Socket
                // accept方法是阻塞式的方法，如果没有客户端连接，会一直处于等待状态
                socket = serverSocket.accept();
                // 第三步：接收数据
                // 问题：此时可能会出现乱码问题，如果数据设的比较小，没有一次性读完，就有可能把一个汉字（两个字节）
                // 或者一个中文逗号（三个字节）拆分开，最终会导致乱码；可以使用转换流，一次性读取一个字符
                is = socket.getInputStream();
    
    
               /* byte[] bytes = new byte[4];
                int readCount = 0;
                while ((readCount = is.read(bytes)) != -1){
                    System.out.print(new String(bytes,0,readCount));
                }*/
                // 转换成字符流
                InputStreamReader isr = new InputStreamReader(is);
                // 使用char数组
                char[] chars = new char[4];
                int readCount = 0;
                while ((readCount = isr.read(chars)) != -1){
                    System.out.print(new String(chars,0,readCount));
                }
                System.out.println("\n数据接收完毕");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 第四步：关闭Socket（对于服务器端ServerSocket不会关闭）
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (is != null) {
                        is.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

**注意：**

> ①必须先开启服务器端，客户端才能连接上，不然会报java.net.ConnectException: Connection refused: connect错误！
> 
> ②可能会出现乱码的问题，因为一个汉字是两个字节，一个中文逗号是三个字节；我们按照字节的方式进行读取可能会把一个汉字拆分开进行显示，最终导致乱码；提供两种解决方案

解决方案一：使用转换流（把字节流转换成字符流）

// 转换成字符流
    InputStreamReader isr = new InputStreamReader(is);
    // 使用char数组
    char[] chars = new char[4];
    int readCount = 0;
    while ((readCount = isr.read(chars)) != -1){
       System.out.print(new String(chars,0,readCount));
    }

解决方案二：使用ByteArrayOutputStream流

> ByteArrayOutputStream 是对byte类型数据进行写入的类相当于一个中间缓冲层，将类写入到文件等其他outputStream。它是对字节进行操作，**属于内存操作流！**

// 使用ByteArrayOutputStream
    // 底层是一个byte数组，先写到内存里了
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] bytes = new byte[4];
    int readCount = 0;
    while ((readCount = is.read(bytes)) != -1){
        baos.write(bytes,0,readCount); // 写到内存里了
    }
    // 调用toString方法进行打印
    System.out.print(baos.toString());

补充：实际上accept可以写多个，接收多个Socket，所以就可以通过调用方法获取是那个Socket

InetAddress inetAddress = socket.getInetAddress();
    System.out.println(inetAddress.getHostAddress() + "客户端连接成功！！");

**（3）例题与练习**

**需求：**客户端发送文件给服务端，服务端将文件保存在本地！

客户端Client

package com.zl.net;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    // 客户端
    public class Client {
        public static void main(String[] args) {
            OutputStream os = null;
            Socket socket = null;
            FileInputStream fis = null;
            try {
                // 第一步：创建一个Socket对象（构造方法指定对方的IP地址和端口号）
                InetAddress inetAddress = InetAddress.getByName("192.168.2.2");
                // 端口号
                int port = 8989;
                socket = new Socket(inetAddress, port);
                // 第二步：创建File实例、FileInputStream的实例
                File file = new File("1.jpg");
                fis = new FileInputStream(file);
                System.out.println(fis);
                // 第三步：通过Socket，获取输出流
                os = socket.getOutputStream();
                // 进行读写数据
                byte[] bytes = new byte[1024];
                int readCount = 0;
                while ((readCount = fis.read(bytes)) != -1){ // 读
                    // 写
                    os.write(bytes,0,readCount);
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 第四步：关闭资源（socket和流都要关闭）
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    if (os != null) {
                        os.close();
                    }
                } catch (IOException e) {
                   e.printStackTrace();
                }
                try {
                    if (fis != null) {
                        fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }

服务端Server

package com.zl.net;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
        public static void main(String[] args)  {
            Socket socket = null;
            InputStream is = null;
            FileOutputStream fos = null;
            try {
                // 第一步：创建一个ServerSocket
                int port = 8989;
                ServerSocket serverSocket = new ServerSocket(port);
                // 第二步：调用accept方法，接收客户端的Socket
                // accept方法是阻塞式的方法，如果没有客户端连接，会一直处于等待状态
                socket = serverSocket.accept();
                // 第三步：获取输入流，读取数据
                is = socket.getInputStream();
                // 创建File类、FileOutputStream的实例
                File file = new File("pic_copy.jpg");
                fos = new FileOutputStream(file);
                // 读写数据
                int readCount = 0;
                byte[] bytes = new byte[1024];
                while ((readCount = is.read(bytes)) != -1){
                    fos.write(bytes,0,readCount);
                }
                System.out.println("\n数据接收完毕");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 第四步：关闭Socket（对于服务器端ServerSocket不会关闭）
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (is != null) {
                        is.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (fos != null) {
                        fos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

#### 6. UDP 网络编程 ####

> UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协 议、提供面向事务的简单不可靠的信息传送服务，类似于短信。

**（1）通信模型**

> UDP 协议是一种**面向非连接**的协议，面向非连接指的是在正式通信前不必与对 方先建立连接，不管对方状态就直接发送，至于对方是否可以接收到这些数据 内容，UDP 协议无法控制，因此说，UDP 协议是一种**不可靠**的协议。无连接的 好处就是快，省内存空间和流量，因为维护连接需要创建大量的数据结构。
> 
> UDP 会尽最大努力交付数据，但不保证可靠交付，没有 TCP 的确认机制、重传机制，如果因为网络原因没有传送到对端，UDP 也不会给应用层返回错误信息。

> UDP 协议是**面向数据报文**的信息传送服务。UDP 在发送端没有缓冲区，对于应用层交付下来的报文在添加了首部之后就直接交付于 ip 层，不会进行合并，也不会进行拆分，而是一次交付一个完整的报文。比如我们要发送 100 个字节的 报文，我们调用一次 **send()**方法就会发送 100 字节，接收方也需要用 **receive()** 方法一次性接收 100 字节，**不能使用循环每次获取 10 个字节，获取十次这样 的做法。**

> UDP 协议**没有拥塞控制**，所以当网络出现的拥塞不会导致主机发送数据的速率 降低。虽然 UDP 的接收端有缓冲区，但是这个缓冲区只负责接收，并不会保证 UDP 报文的到达顺序是否和发送的顺序一致。因为网络传输的时候，由于网络 拥塞的存在是很大的可能导致先发的报文比后发的报文晚到达。如果此时缓冲 区满了，后面到达的报文将直接被丢弃。这个对实时应用来说很重要，比如： 视频通话、直播等应用。

> 类 **DatagramSocket** 和 **DatagramPacket** 实现了基于 UDP 协议网络程序。UDP 数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证 UDP 数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。DatagramPacket 对象封装了 UDP 数据报，在数据报中包含了发送端的 IP 地址和端口号以及接收端的 IP 地址和端口号。UDP 协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接 收方的连接；如同发快递包裹一样。

**（2）开发步骤**

**发送端程序包含以下四个基本的步骤：**

> ①创建 DatagramSocket ：默认使用系统随机分配端口号。
> 
> ②创建 DatagramPacket：将要发送的数据用字节数组表示，并指定要发送的数据长度，接收方的 IP 地址和端口号。
> 
> ③调用该 DatagramSocket 类对象的 send() 方法 ：发送数据报 DatagramPacket 对象。
> 
> ④关闭 DatagramSocket 对象：发送端程序结束，关闭通信套接字。

package com.zl.net;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    
    public class Send {
        public static void main(String[] args)  {
            DatagramSocket ds = null;
            try {
                // 创建DatagramSocket的实例
                ds = new DatagramSocket();
                // 将数据、目的地ip，目的地的端口号都封装在DatagramPacket数据报中
                InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
                int port = 9090;
                byte[] bytes = "我是发送端".getBytes();
                DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, inetAddress, port);
                // 发送数据
                ds.send(packet);
            } catch (IOException e) {
                throw new RuntimeException(e);
            } finally {
                if (ds != null) {
                    // 关闭
                    ds.close();
                }
            }
    
        }
    
    }

**接收端程序包含以下四个基本的步骤：**

> ①创建 DatagramSocket ：指定监听的端口号。
> 
> ②创建 DatagramPacket：指定接收数据用的字节数组，起到临时数据缓冲区的效果， 并指定最大可以接收的数据长度。
> 
> ③调用 该 DatagramSocket 类对象的 receive 方法 ：接收数据报 DatagramPacket 对 象。。 ④关闭 DatagramSocket ：接收端程序结束，关闭通信套接字。

package com.zl.net;
    
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.lang.String;
    
    public class Receiver {
        public static void main(String[] args)  {
            DatagramSocket ds = null;
            try {
                // 创建DatagramSocket的实例
                int port = 9090;
                ds = new DatagramSocket(port);
                // 创建数据报的对象，用于接收发送端发过来的数据
                byte[] bytes = new byte[1024*64];
                DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
                // 接收数据
                ds.receive(packet);
                // 获取数据，进行打印
                String str = new String(packet.getData(), 0, packet.getLength());
                System.out.println(str);
            } catch (IOException e) {
                throw new RuntimeException(e);
            } finally {
                if (ds != null) {
                    // 关闭
                    ds.close();
                }
            }
        }
    }

**总结：**因此 UDP 适用于一次只传送少量数据、对可靠性要求不高的应用环境，数据报 大小限制在 64K 以下。

####  ####

#### 7. URL编程 ####

**（1）URL 类**

> ①URL(Uniform Resource Locator)：**统一资源定位符**，它表示 Internet 上某一资源的地 址。
> 
> ②通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www，ftp 站 点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

**URL 的基本结构由 5 部分组成：****传输协议>://主机名>:端口号>/文件名>\#片段名?参数列表 ，**例如：[http://192.168.1.100:8080/helloworld/index.jsp\#a?username=shkstart&password=123][http_192.168.1.100_8080_helloworld_index.jsp_a_username_shkstart_password_123]

> 为了表示URL，java.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象；public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象。
> 
> 例如：

URL url = new URL("http://www.baidu.com/");

**注：**URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获。

**（2）URL类常用方法**

一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性：

public String getProtocol( )   // 获取该URL的协议名
    public String getHost( )      // 获取该URL的主机名
    public String getPort( )      // 获取该URL的端口号
    public String getPath( )      // 获取该URL的文件路径
    public String getFile( )      // 获取该URL的文件名
    public String getQuery( )    // 获取该URL的查询名

package com.zl.net;
    
    import java.net.MalformedURLException;
    import java.net.URL;
    
    public class URLTest {
        public static void main(String[] args) {
            try {
                URL url = new URL("http://localhost:8080/examples/myTest.txt?name=zhangsan");
                // 获取该URL的协议名
                String protocol = url.getProtocol();
                System.out.println(protocol); // http
                //  获取该URL的主机名
                String host = url.getHost();
                System.out.println(host); // localhost
                //  获取该URL的端口号
                int port = url.getPort();
                System.out.println(port); // 8080
                //  获取该URL的文件路径
                String path = url.getPath();
                System.out.println(path); // /examples/myTest.txt
                // 获取该URL的文件名
                String file = url.getFile(); // /examples/myTest.txt?name=zhangsan
                System.out.println(file);
                // 获取该URL的查询名
                String query = url.getQuery();
                System.out.println(query); // name=zhangsan
            } catch (MalformedURLException e) {
                throw new RuntimeException(e);
            }
        }
    }

**需求：**将URL代表的资源下载到本地

package com.zl.net;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class URLTest {
        public static void main(String[] args)  {
            InputStream is = null;
            FileOutputStream fos = null;
            try {
                // 获取URL的实例
                URL url = new URL("https://img0.baidu.com/it/u=1684532727,1424929765&fm=253&fmt=auto&app=120&f=JPEG?w=1200&h=675");
                // 建立与服务器之间的连接
                HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                // 获取连接的输入流，创建输出流
                is = urlConnection.getInputStream();
                File file = new File("dest.jpg");
                fos = new FileOutputStream(file);
                // 读写数据
                byte[] bytes = new byte[1024];
                int readData = 0;
                while ((readData = is.read(bytes)) != -1){
                    fos.write(bytes,0,readData); //
                }
                System.out.println("文件下载完成！");
            } catch (IOException e) {
                throw new RuntimeException(e);
            } finally {
                try {
                    if (fos != null) {
                        fos.close();
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                try {
                    if (is != null) {
                        is.close();
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
    
        }
    }

[8339e357d5484208b8e70f95f68ff47c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/390162f929144c8b97daeefae6cc4cec.png
[fe851922182e48289655400440a61d00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/42acb24b4faa4fb7a329cce003988a6c.png
[52a5f8ef1cad409d8dedd5ecd87f94f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/aef19c8545a644d484d480b67824940c.png
[f21d39dba2944565918a8b71071cc828.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a27ca859729848db98dc5254b538a659.png
[e8c00fa13c33431bb254b5260b0cb563.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/926988b65eb949a0b0a71b899128fb23.png
[9556144af07342c59cfda2aa8912b611.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/adc3c21a7c8c4737bfd81e16fad93aff.png
[ce275eeb84014426b22c04f591a4f4f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e08028a21b854494b54a50eabd5998b0.png
[ced5376aedbc49359d7a963fe2231141.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3f1a5250a9c240deab1a3df50d9934cd.png
[3d6d441d4cd34ef38443c785a5e1a5a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5bfaa4020e854d4abf6402daab0438fe.png
[612c2b744f0a40a786998f76af67c051.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c4be17dd4c024a15a74d9fc020b719eb.png
[a1d10215f02c4485bd6b649259195106.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3ee67e45f49347ac851002695f114a75.png
[0a737c565fab487e9e989c68fda1b0a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5f4166ffc68c4fc197901c37c327f241.png
[http_192.168.1.100_8080_helloworld_index.jsp_a_username_shkstart_password_123]: http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123