# 概述
通过本篇笔记的整理，对网络通讯相关的知识点进行整理，以及巩固对 `JAVA` 基础体系中 “网络编程” 相关的知识点。
# 目录
[TOC]
# 主要内容
## 0x01：概述
问题一：如何准确地定位网络上一台或多台主机；以及定位主机上的特定的应用
- IP地址
- 端口号
问题二：找到主机后，如何可靠、高效的进行数据传输
遵循一定的规则（即：网络通信协议。有两套参考模型）
- `OSI`参考模型：模型过于理想化，未能在因特网上进行广泛推广
- `TCP/IP`参考模型(或TCP/IP协议)：事实上的国际标准。
| OSI参考模型 | TCP/IP参考模型 | TCP/IP参考模型各层对应协议 |
| ----------- | --------------- | -------------------------- |
| 应用层 | 应用层 | HTTP、FTP、Telnet、DNS… |
| 表示层 | | |
| 会话层 | | |
| 传输层 | 传输层 | TCP、UDP、… |
| 网络层 | 网络层 | IP、ICMP、ARP… |
| 数据链路层 | 物理+数据链路层 | Link |
数据包的封装与解封过程
## 0x02：网络通讯的要素概述
### 要素一：IP地址和端口号
IP地址：`InetAddress`
- 唯一的标识 `Internet` 上的计算机（通信实体）
- 本地回环地址(hostAddress)：`127.0.0.1` 主机名(hostName)：`localhost`
- IP地址分类方式一：`IPV4`和`IPV6`
- IPV4：由`4`个字节组成，4个`0-255`。大概 `42`亿个，其中`30`亿都在北美，亚洲`4`亿。在`2011`年初就已经用尽。以点分十进制表示，如 `192.168.0.1`
- IPV6：`128`位（16个字节），写成`8`个无符号整数，每个整数用 `4` 个十六进制位表示，数之间用冒号`:`分开，如：`3ffe:3201:1401:1280:c8ff:fe4d:db39:1984`
- IP地址分类方式二：公网地址(万维网使用)和私有地址(局域网使用)。通常`192.168.`以及`172.16.`、`10.`开头的就是私有址址，范围即为`192.168.0.0-192.168.255.255`、`172.16.0.0-172.16.255.255`、`10.0.0.0-10.255.255.255`，专门为组织机构内部使用。
特点：不易记忆
端口号：标识正在计算机上运行的进程（程序）
- 不同的进程有不同的端口号
- 被规定为一个`16`位的整数`0~65535`。
- 端口分类：
- 公认端口：`0~1023`。被预先定义的服务通信占用（如：`HTTP`占用端口`80`，FTP占用端口21，Telnet占用端口23）
- 注册端口：`1024~49151`。分配给用户进程或应用程序。（如：`Tomcat`占用端口`8080`，`MySQL`占用端口`3306`，`Oracle`占用端口`1521`等）。
- 动态/私有端口：49152~65535。
应用使用端口进行通信，如下图
- “端口号”与“IP地址”的组合得出一个网络套接字：`Socket`。
#### 工具类：InetAddress
Internet上的主机有两种方式表示地址：
- 域名(hostName)：www.atguigu.com
- IP地址(hostAddress)：202.108.35.210
InetAddress 类主要表示 “IP地址” ，并且有两个子类：
- `Inet4Address`
- `Inet6Address`
- `InetAddress` 类对象含有一个 `Internet` 主机地址的域名和IP地址：`www.atguigu.com` 和 `202.108.35.210`。
域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务 (`DNS`) 负责将 "域名" 转化成 "IP地址"，这样才能和主机建立连接。这个过也称作为 "域名解析" 。
`InetAddress` 类没有提供 “公共的构造器” ，而是提供了如下几个静态方法来获取 `InetAddress` 实例
- public static InetAddress getLocalHost()
- public static InetAddress getByName(String host)
InetAddress 提供了如下几个常用的方法
- `public String getHostAddress()`：
返回 IP 地址字符串（以文本表现形式）
- `public String getHostName()`：
获取此 IP 地址的主机名
- `public boolean isReachable(int timeout)`：
测试是否可以达到该地址
使用例子
```java
public static void main(String[] args) {
try {
//File file = new File("hello.txt");
InetAddress inet1 = InetAddress.getByName("192.168.10.14");
System.out.println(inet1);
InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
System.out.println(inet2);
InetAddress inet3 = InetAddress.getByName("127.0.0.1");
System.out.println(inet3);
//获取本地ip
InetAddress inet4 = InetAddress.getLocalHost();
System.out.println(inet4);
//getHostName()
System.out.println(inet2.getHostName());
//getHostAddress()
System.out.println(inet2.getHostAddress());
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
```
输出结果
```java
/192.168.10.14
www.atguigu.com/223.111.24.71
/127.0.0.1
DESKTOP-OE6FHSH/192.168.43.196
www.atguigu.com
223.111.24.71
Process finished with exit code 0
```
### 要素二：网络协议
#### 概述
网络通信协议
- 计算机网络中实现通信必须有一些约定，即通信协议， 对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。
问题：网络协议太复杂
- 计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？
通信协议分层的思想
- 在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。
#### TCP/IP协议簇
- 传输层协议中有两个非常重要的协议：
- 传输控制协议 `TCP `(Transmission Control Protocol)
- 用户数据报协议 `UDP` (User Datagram Protocol)。
- `TCP/IP` 以其两个主要协议：传输控制协议(TCP)和网络互联协议(IP)而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。
- IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信。
- TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层、 IP层、传输层和应用层。
#### TCP和UDP概述
TCP协议：
- 使用TCP协议前，须先建立 `TCP` 连接，形成传输数据通道
- 传输前，采用 “三次握手” 方式对连接可靠性进行验证，点对点通信。
- `TCP` 协议进行通信的两个应用进程：客户端、 服务端。
- 在连接中可进行大数据量的传输。
- 传输完毕，需释放已建立的连接， 效率低。
常见的使用场景：对数据的可靠性较高，例如即时通讯（微信、QQ等）
`TCP` 三次握手过程
> 为什么不进行第四次握手?
>
> 经过三次握手后，基本就能保证这次连接是可靠的。再进行第四次握手的花对于可靠性提升较小，且会使整个握手流程的耗时增加，性价比低。
在TCP连接结束时需要经过四次挥手，过程如下图所示
**UDP 协议：**
- 将数据、源、目的封装成数据包， 不需要建立连接。
- 每个数据报的大小限制在 `64K` 内
- 发送不管对方是否准备好，接收方收到也不确认， 故是不可靠的。
- 可以广播发送。
- 发送数据结束时无需释放资源，开销小，速度快。
使用场景：对数据的可靠性要求较低，允许一部分数据的丢失、追求性能，例如 网络视频、其他流媒体、游戏等。
#### Socket 套接字
> 概述
- 利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。
- 网络上具有唯一标识的 `IP` 地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
- 通信的两端都要有`Socket`，是两台机器间通信的端点。
- 网络通信其实就是 `Socket` 间的通信。
- `Socket` 允许程序把网络连接当成一个流， 数据在两个 `Socket` 间通过 `IO` 传输。
- 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
Socket的分类
- 流套接字（stream socket）：使用 `TCP `提供可依赖的字节流服务
- 数据报套接字（datagram socket）：使用 `UDP` 提供“尽力而为”的数据报服务
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()`
获取套接字绑定的本地地址。 即本端的IP地址
- `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。 即不能通过此套接字的输出流发送任何数据。
## 0x03：TCP网络编程
> 基于Socket的TCP编程
`Java` 语言的基于套接字编程分为 "服务端 " 编程和 "客户端编程"，其通信模型如图所示：
### **客户端**
客户端 `Socket` 的工作过程包含以下四个基本的步骤：
- 创建 Socket： 根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
- 打开连接到 `Socket` 的输入/出流： 使用 `getInputStream()` 方法获得输入流，使用 `getOutputStream()` 方法获得输出流，进行数据传输
- 按照一定的协议对 `Socket` 进行读/写操作： 通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
- 关闭 `Socket`： 断开客户端到服务器的连接，释放线路
客户端程序可以使用 `Socket` 类创建对象， 创建的同时会自动向服务器方发起连接。 `Socket` 的构造器是：
- `Socket(String host,int port)throws UnknownHostException,IOException`：
向服务器(域名是 `host`。端口号为`port` )发起 `TCP`连接，若成功，则创建 `Socket` 对象，否则抛出异常。
- `Socket(InetAddress address,int port) throws IOException`：
根据 InetAddress 对象所表示的IP地址以及端口号 `port` 发起连接。
客户端建立 `socketAtClient` 对象的过程就是向服务器发出套接字连接请求
```java
Socket s = newSocket(“192.168.40.165” ,9999);
OutputStream out = s.getOutputStream();
out.write(" hello".getBytes());
s.close();
```
### **服务端**
- 服务器程序的工作过程包含以下四个基本的步骤：
- 调用 `ServerSocket(int port)` ： 创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
- 调用 `accept()`： 监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
- 调用 该 `Socket`类对象的 `getOutputStream()` 和 `getInputStream ()`： 获取输出流和输入流，开始网络数据的发送和接收。
- 关闭 `ServerSocket` 和 `Socket` 对象： 客户端访问结束，关闭通信套接字
ServerSocket 对象负责等待客户端 "请求建立" 套接字连接，类似邮局某个窗口中的业务员。也就是说， 服务器必须事先建立一个等待客户请求建立套接字连接的 `ServerSocket` 对象。
所谓“接收”客户的套接字请求，就是 `accept()` 方法会返回一个 `Socket` 对象，如下代码所示
```java
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept ();
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int num = in.read(buf);
String str = new String(buf,0,num);
System.out.println(s.getInetAddress().toString()+” :” +str);
s.close();
ss.close();
```
### 案例一：实现基本的字符串收发
需求：客户端向服务端发送一个字符串，服务端收到后输出到控制台。
客户端代码
```java
@Test
public void client() {
Socket socket = null;
OutputStream os = null;
try {
//1.创建Socket对象，指明服务器端的ip和端口号
InetAddress inet = InetAddress.getByName("127.0.0.1"); //IP地址可以填自己的内网IP地址
socket = new Socket(inet,8899);
//2.获取一个输出流，用于输出数据
os = socket.getOutputStream();
//3.写出数据的操作
os.write("你好，我是客户端mm".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源的关闭
if(os != null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```
服务端代码
```java
//服务端
@Test
public void server() {
ServerSocket ss = null;
Socket socket = null;
InputStream is = null;
ByteArrayOutputStream baos = null;
try {
//1.创建服务器端的ServerSocket，指明自己的端口号
ss = new ServerSocket(8899);
//2.调用accept()表示接收来自于客户端的socket
socket = ss.accept();
//3.获取输入流
is = socket.getInputStream();
//不建议这样写，可能会有乱码
// byte[] buffer = new byte[1024];
//int len;
// while((len = is.read(buffer)) != -1){
// String str = new String(buffer,0,len);
// System.out.print(str);
// }
//4.读取输入流中的数据
baos = new ByteArrayOutputStream();
byte[] buffer = new byte[5];
int len;
while((len = is.read(buffer)) != -1){
baos.write(buffer,0,len);
}
System.out.println(baos.toString());
System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
} catch (IOException e) {
e.printStackTrace();
} finally {
if(baos != null){
//5.关闭资源
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(is != null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(ss != null){
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```
输出结果
### 案例二：文件的发送与接收
需求：客户端向服务端发送一个文件，服务端接收文件并且写入到本地
客户端代码
```java
/*
这里涉及到的异常，应该使用try-catch-finally处理
*/
@Test
public void client() throws IOException {
//1.
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
//2.
OutputStream os = socket.getOutputStream();
//3.
FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
//4.
byte[] buffer = new byte[1024];
int len;
while((len = fis.read(buffer)) != -1){
os.write(buffer,0,len);
}
//5.
fis.close();
os.close();
socket.close();
}
```
服务端代码
```java
/*
这里涉及到的异常，应该使用try-catch-finally处理
*/
@Test
public void server() throws IOException {
//1.
ServerSocket ss = new ServerSocket(9090);
//2.
Socket socket = ss.accept();
//3.
InputStream is = socket.getInputStream();
//4.
FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
//5.
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer,0,len);
}
System.out.println("文件接收成功！");
//6.
fos.close();
is.close();
socket.close();
ss.close();
}
```
运行结果如下
并且将接收到的文件写入到了本地
在上述的代码基础上，我们增加一个功能：服务端接收到文件后， 向客户端返回一个 “接收成功” 的消息给客户端。
客户端代码，作出以下的修改
- 完成文件的发送后，使用 `shutdownOutput()` 关闭输出流
- 并构建一个"输入流"输入流，接收服务端的反馈信息
```java
/*
这里涉及到的异常，应该使用try-catch-finally处理
*/
@Test
public void client() throws IOException {
//1.
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
//2.
OutputStream os = socket.getOutputStream();
//3.
FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
//4.
byte[] buffer = new byte[1024];
int len;
while((len = fis.read(buffer)) != -1){
os.write(buffer,0,len);
}
//关闭数据的输出
socket.shutdownOutput();
//5.接收来自于服务器端的数据，并显示到控制台上
InputStream is = socket.getInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] bufferr = new byte[20];
int len1;
while((len1 = is.read(buffer)) != -1){
baos.write(buffer,0,len1);
}
System.out.println(baos.toString());
//6.
fis.close();
os.close();
socket.close();
baos.close();
}
```
服务端代码，作出以下的修改
- 在完成文件的接收后，创建一个输出流向客户端发送指定的字符串信息
```java
/*
这里涉及到的异常，应该使用try-catch-finally处理
*/
@Test
public void server() throws IOException {
//1.
ServerSocket ss = new ServerSocket(9090);
//2.
Socket socket = ss.accept();
//3.
InputStream is = socket.getInputStream();
//4.
FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
//5.
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer,0,len);
}
System.out.println("图片传输完成");
//6.服务器端给予客户端反馈
OutputStream os = socket.getOutputStream();
os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
//7.
fos.close();
is.close();
socket.close();
ss.close();
os.close();
}
```
输出结果
服务端
客户端
接收到的文件写入到本地
## 0x04：UDP网络编程
需求：发送端（客户端）向接收端你发送一段字符串信息，接收端（服务端）接收到数据后输出到控制台
发送端代码如下
```java
//发送端
@Test
public void sender() throws IOException {
DatagramSocket socket = new DatagramSocket();
String str = "我是UDP方式发送的导弹";
byte[] data = str.getBytes();
InetAddress inet = InetAddress.getLocalHost();
DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
socket.send(packet);
socket.close();
}
```
接收端代码如下
```java
//接收端
@Test
public void receiver() throws IOException {
DatagramSocket socket = new DatagramSocket(9090);
byte[] buffer = new byte[100];
DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
socket.receive(packet);
System.out.println(new String(packet.getData(),0,packet.getLength()));
socket.close();
}
```
输出结果如下
在以 `UDP` 方式进行传输数据时，发送端无需等待服务端的确认（无论是否连接成功），相对于以 `TCP` 的方式进行传输时，如果客户端无法连接到服务端，会抛出 `ConnectException` 异常 ，如下
## 0x05：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
片段名：即锚点，例如看小说，直接定位到章节
参数列表格式：`参数名=参数值&参数名=参数值....`
为了表示 `URL`， `java.net` 中实现了类 `URL`。我们可以通过下面的构造器来初始化一个 `URL` 对象：
- public URL (String spec)：
通过一个表示URL地址的字符串可以构造一个URL对象。
例如： `URL url = new URL ("http://www. atguigu.com/");`
- public URL(URL context, String spec)：
通过 “基URL” 和 “相对 URL” 构造一个 "URL对象"。
例如： `URL downloadUrl = new URL(url, “download.html")`
- public URL(String protocol, String host, String file);
例如： `new URL("http","www.atguigu.com", “download. html");`
- public URL(String protocol, String host, int port, String file);
例如： `URL gamelan = newURL("http", "www.atguigu.com", 80, “download.html");`
URL 类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 `try-catch` 语句进行捕获 。
一个 `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的查询名
如下案例
```java
public static void main(String[] args) {
try {
URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");
// public String getProtocol( ) 获取该URL的协议名
System.out.println(url.getProtocol());
// public String getHost( ) 获取该URL的主机名
System.out.println(url.getHost());
// public String getPort( ) 获取该URL的端口号
System.out.println(url.getPort());
// public String getPath( ) 获取该URL的文件路径
System.out.println(url.getPath());
// public String getFile( ) 获取该URL的文件名
System.out.println(url.getFile());
// public String getQuery( ) 获取该URL的查询名
System.out.println(url.getQuery());
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
```
输出结果
```java
http
localhost
8080
/examples/beauty.jpg
/examples/beauty.jpg?username=Tom
username=Tom
Process finished with exit code 0
```
案例：将图片文件下载至本地
```java
public static void main(String[] args) {
HttpURLConnection urlConnection = null;
InputStream is = null;
FileOutputStream fos = null;
try {
URL url = new URL("https://uposs.codeyee.com/blog/chrome_sHWOX5JaYu.png");
urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.connect();
is = urlConnection.getInputStream();
fos = new FileOutputStream("day10\\blog.png");
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer,0,len);
}
System.out.println("下载完成");
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(is != null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(urlConnection != null){
urlConnection.disconnect();
}
}
}
```
运行结果
成功将文件下载至本地
预览文件
# 总结
通过上述的内容的复习整理，巩固了 `JAVA` 的网络编程相关的知识点，例如通过编写 `JAVA` 代码来实现“文件、数据”在不同协议下的网络传输，以及其一些相关的理论知识。
【Java进阶】网络编程
