网络编程
1. 网络编程概述
- Java是Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。
- Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在Java 的本机安装系统里，由JVM 进行控制。并且Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。
- 网络编程的目的：直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
- 网络编程中有两个主要的问题：
①如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
②找到主机后如何可靠高效地进行数据传输
拓展小知识
什么是计算机网络？
它是把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。
2. 网络通信要素概述
网络通信的要素（解决上述的两个问题）：
- 通信双方地址（IP+端口号）
- 一定的规则（网络通信协议）两套参考模型：
①OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
②TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
2.1 IP和端口号
2.1.1 IP地址
IP地址是计算机在Internet上的唯一标识（通信实体），在Java类中有InetAddress类代表IP
一、IP地址分类方式
- IPV4和IPV6
IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1
IPV6：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984 - 公网地址(万维网使用)和私有地址(局域网使用)。192.168.开头的就是私有地址，范围即为192.168.0.0–192.168.255.255，专门为组织机构内部使用。
二、本地回环地址
本地回路地址(hostAddress)：127.0.0.1
对应着的主机名(hostName)：localhost
三、Internet上的主机有两种方式表示地址
- 域名(hostName)：www.atguigu.com
- IP地址(hostAddress)：202.108.35.210
IP地址和域名的特点
IP地址：不易记忆
域名：容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。-------域名解析
解析流程：
- 先找本机hosts文件，是否有该域名地址的记录，有则直接访问
- 没有的话通过DNS服务器寻找主机地址
hosts文件在日后开发常用，可以先做了解
四、InetAddress类
主要表示IP地址，两个子类：Inet4Address、Inet6Address。
InetAddress类对象含有一个Internet主机地址的域名和IP地址：www.atguigu.com和202.108.35.210。
如何实例化InetAddress:两个方法：getByName(String host) 、 getLocalHost()
两个常用方法：getHostName() / getHostAddress()
使用示例
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddressTest {
public static void main(String[] args) {
try {
InetAddress inet1 = InetAddress.getByName("192.168.10.14"); // /192.168.10.14
System.out.println(inet1);
InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
System.out.println(inet2); // www.atguigu.com/60.217.246.27
InetAddress inet3 = InetAddress.getByName("127.0.0.1");
System.out.println(inet3); // /127.0.0.1
//获取本地ip
InetAddress inet4 = InetAddress.getLocalHost();
System.out.println(inet4);
//getHostName() 获取域名
System.out.println(inet2.getHostName()); // www.atguigu.com
//getHostAddress() 获取IP地址
System.out.println(inet2.getHostAddress()); // 60.217.246.27
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
2.1.2 端口号
端口号标识正在计算机上运行的进程（程序）
- 要求：不同的进程有不同的端口号
- 范围：被规定为一个16 位的整数0~65535。
端口分类：
- 公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23）
- 注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）。
- 动态/私有端口：49152~65535。
端口号与IP地址的组合得出一个网络套接字：Socket。
2.2 网络通信协议
计算机网络中实现通信必须有一些约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。
计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？
在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。
TCP和UDP网络通信协议的对比
传输层协议中有两个非常重要的协议：传输控制协议TCP(Transmission Control Protocol)和用户数据报协议UDP(User Datagram Protocol)。
TCP/IP以其两个主要协议：传输控制协议(TCP)和网络互联协议(IP)而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。
- IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信。
- TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层、IP层、传输层和应用层。
一、TCP协议：
使用TCP协议前，须先建立TCP连接，形成传输数据通道
传输前，采用“三次握手”方式，点对点通信，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端。
在连接中可进行大数据量的传输?传输完毕，需释放已建立的连接，效率低
二、UDP协议：
将数据、源、目的封装成数据包，不需要建立连接
每个数据报的大小限制在64K内
发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
可以广播发送
发送数据结束时无需释放资源，开销小，速度快
知识拓展：TCP三次握手和四次挥手
1. 三次握手
①简述：首先Client端发送连接请求报文，Server端接受连接后回复ACK报文，并为这次连接分配资源。Client端接收到ACK报文后也向Server端发生ACK报文，并分配资源，这样TCP连接就建立了。
②图解：
最初两端的TCP进程都处于CLOSED关闭状态，A（客户端）主动打开连接，而B（服务器）被动打开连接。（A、B关闭状态CLOSED——B收听状态LISTEN——A同步已发送状态SYN-SENT——B同步收到状态SYN-RCVD——A、B连接已建立状态ESTABLISHED）
③详解：
首先说几个概念：
SYN：synchronous 同步位（用来建立连接）
ACK：acknowledgement 确认位（1表示确认连接）
ack：确认编号（ack number）
seq：数据包的顺序号码（Sequence number）
TCB：传输控制块（Transmission Control Block），存储每一个连接中的重要信息。
1. B的TCP服务器进程先创建传输控制块TCB，准备接受客户进程的连接请求。然后服务器进程就处于LISTEN（收听）状态，等待客户的连接请求。若有，则作出响应。
2. 第一次握手：A的TCP客户进程也是首先创建传输控制块TCB，然后向B发出连接请求报文段，（首部的同步位SYN=1，初始序号seq=x），（SYN=1的报文段不能携带数据）但要消耗掉一个序号，此时TCP客户进程进入SYN-SENT（同步已发送）状态。
3. 第二次握手：B收到连接请求报文段后，如同意建立连接，则向A发送确认，在确认报文段中（SYN=1，ACK=1，确认号ack=x+1，初始序号seq=y），测试TCP服务器进程进入SYN-RCVD（同步收到）状态；
4. 第三次握手：TCP客户进程收到B的确认后，要向B给出确认报文段（ACK=1，确认号ack=y+1，序号seq=x+1）（初始序号为seq=x，所以发送的第二个报文段要+1），ACK报文段可以携带数据，不携带数据则不消耗序号。TCP连接已经建立，A进入ESTABLISHED（已建立连接）。
5. 当B收到A的确认后，也进入ESTABLISHED状态。④总结：
第一次握手：起初两端都处于CLOSED关闭状态，Client将标志位SYN置为1，随机产生一个值seq=x，并将该数据包发送给Server，Client进入SYN-SENT状态，等待Server确认；
第二次握手：Server收到数据包后由标志位SYN=1得知Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=x+1，随机产生一个值seq=y，并将该数据包发送给Client以确认连接请求，Server进入SYN-RCVD状态，此时操作系统为该TCP连接分配TCP缓存和变量；
第三次握手：Client收到确认后，检查ack是否为x+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=y+1，并且此时操作系统为该TCP连接分配TCP缓存和变量，并将该数据包发送给Server，Server检查ack是否为y+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client和Server就可以开始传输数据。
拓展问题1：为什么要三次握手，两次不行吗？
答：
1.阻止重复历史连接的初始化
防止已失效的连接请求报文突然传送到服务器，因而产生错误。假设这样一个场景：A发送一个请求连接报文因为网络问题长时间滞留，到第二次连接通信释放连接后才到B，这是一个失效的请求连接报文，此时B以为是A发送的新的请求连接，于是发出确认字符，如果没有三次握手，该连接建立，但是A并没有发出请求连接，所以B就会一直等待A发送确认字符，这样B等了很久，白白浪费B的资源。
2. 序列号可靠同步:（TCP的可靠传输）
如果是两次握手，服务端无法确定客户端是否已经接收到自己发送的初始序列号，如果第二次握手报文丢失，那么客户端就无法知道服务端的初始序列号，那TCP的可靠性就无从谈起。
3. 确认双方的收发能力
第一次握手：服务器端得到结论：客户端发送正常，服务器接收正常。
第二次握手：客户端得到结论：服务器接收、发送正常，客户端接收、发送正常。但是此时服务器并不能确定客户端的接收能力是否正常。
第三次握手：服务器端得到结论：客户端接收、发送正常，服务器端接收、发送正常。
拓展问题2：为什么Server端易受到SYN攻击？
答：服务器端的资源分配是在二次握手时分配的，而客户端的资源是在完成三次握手时分配的，所以服务器容易受到SYN洪泛攻击。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server则回复确认包，并等待Client确认。由于源地址不存在，因此Server需要不断重发直至超时，这些伪造的SYN包将长时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络拥塞甚至系统瘫痪。
防范SYN攻击措施：降低主机的等待时间使主机尽快的释放半连接的占用，短时间受到某IP的重复SYN则丢弃后续请求。
2. 四次挥手
①简述
- Client端发起中断连接请求（发送FIN报文）。
意思是说：我Client端没有数据要发给你（Server端）了，但是如果你（Server端）还有数据没有发送完成，则不必急着关闭Socket，可以继续发送数据。- Server端接到FIN报文后，发送ACK回送给Client端。
意思是说：你（Client端）的请求我收到了，但是我（Server端）还没准备好，请你继续等我的消息。- Client端进入FIN_WAIT状态，继续等待Server端的FIN报文。
- Server端确定数据已发送完成，向Client端发送FIN报文。
意思是说：告诉Client端，我这边数据发完了，准备好关闭连接了。- Client端收到FIN报文后，发送ACK进入TIME_WAIT状态。
意思是说：Client端收到FIN报文后就知道可以关闭连接了，但是他还是不相信网络，怕Server端不知道要关闭，所以发送ACK后进入TIME_WAIT状态，如果Server端没有收到ACK则可以重传。- Server端收到ACK后关闭连接。
- Client端等待了2MSL后依然没有收到回复，证明Server端已正常关闭，Client端也关闭连接。
- TCP连接关闭。
②图解
数据传输结束后，通信的双方都可释放连接，A和B都处于ESTABLISHED状态。（A、B连接建立状态ESTABLISHED——A终止等待1状态FIN-WAIT-1——B关闭等待状态CLOSE-WAIT——A终止等待2状态FIN-WAIT-2——B最后确认状态LAST-ACK——A时间等待状态TIME-WAIT——B、A关闭状态CLOSED）
③详解
FIN：关闭连接
1. 第一次挥手：A的应用进程先向其TCP发出连接释放报文段（FIN=1，序号seq=u），并停止再发送数据，主动关闭TCP连接，进入FIN-WAIT-1（终止等待1）状态，等待B的确认。
2.第二次挥手 B收到连接释放报文段后即发出确认报文段，（ACK=1，确认号ack=u+1，序号seq=v），B进入CLOSE-WAIT（关闭等待）状态，此时的TCP处于半关闭状态，A到B的连接释放。
3. A收到B的确认后，进入FIN-WAIT-2（终止等待2）状态，等待B发出的连接释放报文段。
4.第三次挥手 B没有要向A发出的数据，B发出连接释放报文段（FIN=1，ACK=1，序号seq=w，确认号ack=u+1），B进入LAST-ACK（最后确认）状态，等待A的确认。
5. 第四次挥手 A收到B的连接释放报文段后，对此发出确认报文段（ACK=1，seq=u+1，ack=w+1），A进入TIME-WAIT（时间等待）状态。此时TCP未释放掉，需要经过时间等待计时器设置的时间2MSL后，A才进入CLOSED状态。
拓展问题1：为什么A在TIME-WAIT状态必须等待2MSL的时间？
MSL最长报文段寿命Maximum Segment Lifetime，MSL=2
答：
- 保证A发送的最后一个ACK报文段能够到达B。这个ACK报文段有可能丢失，使得处于LAST-ACK状态的B收不到对已发送的FIN+ACK报文段的确认，B超时重传FIN+ACK报文段。
而A能在2MSL时间内收到这个重传的FIN+ACK报文段，接着A重传一次确认，重新启动2MSL计时器，最后A和B都进入到CLOSED状态。
若A在TIME-WAIT状态不等待一段时间，而是发送完ACK报文段后立即释放连接，则无法收到B重传的FIN+ACK报文段，所以不会再发送一次确认报文段，则B无法正常进入到CLOSED状态。- 防止“已失效的连接请求报文段”出现在本连接中。A在发送完最后一个ACK报文段后，再经过2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失，使下一个新的连接中不会出现这种旧的连接请求报文段。
拓展问题2：为什么连接的时候是三次握手，关闭的时候却是四次？
答：因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，“你发的FIN报文我收到了”。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步。
3. TCP网络编程
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 实现TCP的网络编程
* 例子1：客户端发送信息给服务端，服务端将数据显示在控制台上
*/
public class TCPTest {
//客户端
@Test
public void client() {
Socket socket = null;
OutputStream os = null;
try {
//1.创建Socket对象，指明服务器端的ip和端口号
InetAddress inet = InetAddress.getByName("192.168.14.100");
socket = new Socket(inet,8899);
//2.获取一个输出流，用于输出数据
os = socket.getOutputStream();
//3.写出数据的操作
os.write("你好，我是客户端HH".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();
}
}
}
}
//服务端
@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();
}
}
}
}
}
练习1：客户端发送文件给服务端，服务端将文件保存在本地。
import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPTest2 {
/**
* 这里涉及到的异常，应该使用try-catch-finally处理
* @throws IOException
*/
@Test
public void test() throws IOException {
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
OutputStream os = socket.getOutputStream();
FileInputStream fis = new FileInputStream(new File("164.jpg"));
byte[] buffer = new byte[1024];
int len;
while((len = fis.read(buffer)) != -1){
os.write(buffer,0,len);
}
fis.close();
os.close();
socket.close();
}
/**
* 这里涉及到的异常，应该使用try-catch-finally处理
* @throws IOException
*/
@Test
public void test2() throws IOException {
ServerSocket ss = new ServerSocket(9090);
Socket socket = ss.accept();
InputStream is = socket.getInputStream();
FileOutputStream fos = new FileOutputStream(new File("1641.jpg"));
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer,0,len);
}
fos.close();
is.close();
socket.close();
ss.close();
}
}
练习2：从客户端发送文件给服务端，服务端保存到本地。返回“发送成功”给客户端，并关闭相应的连接。
import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPTest3 {
/**
* 这里涉及到的异常，应该使用try-catch-finally处理
* @throws IOException
*/
@Test
public void test() throws IOException {
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
OutputStream os = socket.getOutputStream();
FileInputStream fis = new FileInputStream(new File("164.jpg"));
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());
fis.close();
os.close();
socket.close();
baos.close();
}
/**
* 这里涉及到的异常，应该使用try-catch-finally处理
* @throws IOException
*/
@Test
public void test2() throws IOException {
ServerSocket ss = new ServerSocket(9090);
Socket socket = ss.accept();
InputStream is = socket.getInputStream();
FileOutputStream fos = new FileOutputStream(new File("1642.jpg"));
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());
fos.close();
is.close();
socket.close();
ss.close();
os.close();
}
}
4. UDP网络编程
DatagramSocket类和DatagramPacket类实现了基于UDP 协议网络程序。
UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。
流程：
DatagramSocket与DatagramPacket- 建立发送端，接收端
- 建立数据包
- 调用Socket的发送、接收方法
- 关闭Socket
示例
import org.junit.Test;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDPd协议的网络编程
*/
public class UDPTest {
//发送端
@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();
}
//接收端
@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();
}
}
5. URL编程
URL：统一资源定位符，对应着互联网的某一资源地址
格式：
http://127.0.0.1:8080/work/164.jpg?username=zhangsan
协议 主机名 端口号 资源地址 参数列表
import java.net.MalformedURLException;
import java.net.URL;
/**
* URL网络编程
* 1.URL:统一资源定位符，对应着互联网的某一资源地址
* 2.格式：
* http://127.0.0.1:8080/work/164.jpg?username=subei
* 协议 主机名 端口号 资源地址 参数列表
*/
public class URLTest {
public static void main(String[] args) {
try {
URL url = new URL("http://127.0.0.1:8080/work/164.jpg?username=zhangsan");
// public String getProtocol( ) 获取该URL的协议名
System.out.println(url.getProtocol()); // http
// public String getHost( ) 获取该URL的主机名
System.out.println(url.getHost()); // 127.0.0.1
// public String getPort( ) 获取该URL的端口号
System.out.println(url.getPort()); // 8080
// public String getPath( ) 获取该URL的文件路径
System.out.println(url.getPath()); // /work/164.jpg
// public String getFile( ) 获取该URL的文件名
System.out.println(url.getFile()); // /work/164.jpg?username=zhangsan
// public String getQuery( ) 获取该URL的查询名
System.out.println(url.getQuery()); // username=zhangsan
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
5.1 URL网络编程实现Tomcat服务端数据下载
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class URLTest1 {
public static void main(String[] args) {
HttpURLConnection urlConnection = null;
InputStream is = null;
FileOutputStream fos = null;
try {
URL url = new URL("http://127.0.0.1:8080/work/164.jpg");
// 打开连接
urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.connect();
// 获取文件输入流
is = urlConnection.getInputStream();
// 指定文件的输出位置
fos = new FileOutputStream("day10\\1643.jpg");
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();
}
}
}
}
6. URI、URL和URN的区别
URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。
URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。
URN，uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。
也就是说，URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。URL和URN都是一种URI。
在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。而URL类则不仅符合语义，还包含了定位该资源的信息，因此它不能是相对的。
祝各位2022年新年快乐~
| 上一篇 | 总目录 | 下一篇 |
|---|---|---|
| 十五、IO流 | Java基础总目录 | 未完待续 |