共计 12571 个字符，预计需要花费 32 分钟才能阅读完成。
网络编程
内容介绍
网络通信协定
UDP 通信
TCP 通信
内容学习指标
可能独立实现“文件上传”案例的源代码编写、编译、运行的操作
网络通信协定
通过计算机网络能够使多台计算机实现连贯，位于同一个网络中的计算机在进行连贯和通信时须要恪守肯定的规定，这就好比在路线中行驶的汽车肯定要恪守交通规则一样。在计算机网络中，这些连贯和通信的规定被称为网络通信协定，它对数据的传输格局、传输速率、传输步骤等做了对立规定，通信单方必须同时恪守能力实现数据交换。网络通信协定有很多种，目前利用最宽泛的是 TCP/IP 协定 (Transmission Control Protocal/Internet Protoal 传输控制协议 / 英特网互联协定)，它是一个包含 TCP 协定和 IP 协定，UDP（User Datagram Protocol）协定和其它一些协定的协定组，在学习具体协定之前首先理解一下 TCP/IP 协定组的层次结构。
在进行数据传输时，要求发送的数据与收到的数据齐全一样，这时，就须要在原有的数据上增加很多信息，以保证数据在传输过程中数据格式完全一致。TCP/IP 协定的层次结构比较简单，共分为四层，如图所示。
上图中，TCP/IP 协定中的四层别离是应用层、传输层、网络层和链路层，每层别离负责不同的通信性能，接下来针对这四层进行具体地解说。
链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设施的驱动协定，例如针对光纤、网线提供的驱动。
网络层：网络层是整个 TCP/IP 协定的外围，它次要用于将传输的数据进行分组，将分组数据发送到指标计算机或者网络。
运输层：次要使网络程序进行通信，在进行网络通信时，能够采纳 TCP 协定，也能够采纳 UDP 协定。
应用层：次要负责应用程序的协定，例如 HTTP 协定、FTP 协定等。
IP 地址和端口号
要想使网络中的计算机可能进行通信，必须为每台计算机指定一个标识号，通过这个标识号来指定承受数据的计算机或者发送数据的计算机。在 TCP/IP 协定中，这个标识号就是 IP 地址，它能够惟一标识一台计算机，目前，IP 地址宽泛应用的版本是 IPv4，它是由 4 个字节大小的二进制数来示意，如：
00001010000000000000000000000001。因为二进制模式示意的 IP 地址十分不便记忆和解决，因而通常会将 IP 地址写成十进制的模式，每个字节用一个十进制数字 (0-255) 示意，数字间用符号“.”离开，如“192.168.1.100”。随着计算机网络规模的不断扩大，对 IP 地址的需要也越来越多，IPV4 这种用 4 个字节示意的 IP 地址面临枯竭，因而 IPv6 便应运而生了，IPv6 应用 16 个字节示意 IP 地址，它所领有的地址容量约是 IPv4 的 8×1028 倍，达到 2128 个（算上全零的），这样就解决了网络地址资源数量不够的问题。
通过 IP 地址能够连贯到指定计算机，但如果想拜访指标计算机中的某个应用程序，还须要指定端口号。在计算机中，不同的应用程序是通过端口号辨别的。端口号是用两个字节（16 位的二进制数）示意的，它的取值范畴是 065535，其中，01023 之间的端口号用于一些出名的网络服务和利用，用户的一般应用程序须要应用 1024 以上的端口号，从而防止端口号被另外一个利用或服务所占用。
接下来通过一个图例来形容 IP 地址和端口号的作用，如下图所示。
从上图中能够分明地看到，位于网络中一台计算机能够通过 IP 地址去拜访另一台计算机，并通过端口号拜访指标计算机中的某个应用程序。
InetAddress
理解了 IP 地址的作用，咱们看学习下 JDK 中提供了一个 InetAdderss 类，该类用于封装一个 IP 地址，并提供了一系列与 IP 地址相干的办法，下表中列出了 InetAddress 类的一些罕用办法。
办法申明
性能形容
InetAddress getByName(String host)
参数 host 示意指定的主机，该办法用于在给定主机名的状况下确定主机的 IP 地址
InetAddress getLocalHost()
创立一个示意本地主机的 InetAddress 对象
String getHostName()
失去 IP 地址的主机名，如果是本机则是计算机名，不是本机则是主机名，如果没有域名则是 IP 地址
String getHostAddress()
失去字符串格局的原始 IP 地址
上表中，列举了 InetAddress 的四个罕用办法。其中，前两个办法用于取得该类的实例对象，第一个办法用于取得示意指定主机的 InetAddress 对象，第二个办法用于取得示意本地的 InetAddress 对象。通过 InetAddress 对象便可获取指定主机名，IP 地址等，接下来通过一个案例来演示 InetAddress 的罕用办法，如下所示。
import java.net.InetAddress;
public class Example01 {
public static void main(String[] args) throws Exception {
InetAddress localAddress = InetAddress.getLocalHost();
InetAddress remoteAddress = InetAddress.getByName(“www.atguigu.cn”);
System.out.println(“ 本机的 IP 地址：” +
localAddress.getHostAddress());
System.out.println(“atguigu 的 IP 地址：” +
remoteAddress.getHostAddress());
System.out.println(“atguigu 的主机名为：” + remoteAddress.getHostName());
}
UDP 与 TCP 协定
在介绍 TCP/IP 构造时，提到传输层的两个重要的高级协定，别离是 UDP 和 TCP，其中 UDP 是 User Datagram Protocol 的简称，称为用户数据报协定，TCP 是 Transmission Control Protocol 的简称，称为传输控制协议。
UDP 协定介绍
UDP 是无连贯通信协议，即在数据传输时，数据的发送端和接收端不建设逻辑连贯。简略来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会收回数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。因为应用 UDP 协定耗费资源小，通信效率高，所以通常都会用于音频、视频和一般数据的传输例如视频会议都应用 UDP 协定，因为这种状况即便偶然失落一两个数据包，也不会对接管后果产生太大影响。然而在应用 UDP 协定传送数据时，因为 UDP 的面向无连接性，不能保证数据的完整性，因而在传输重要数据时不倡议应用 UDP 协定。UDP 的替换过程如下图所示。
TCP 协定介绍
TCP 协定是面向连贯的通信协议，即在传输数据前先在发送端和接收端建设逻辑连贯，而后再传输数据，它提供了两台计算机之间牢靠无差错的数据传输。在 TCP 连贯中必须要明确客户端与服务器端，由客户端向服务端收回连贯申请，每次连贯的创立都须要通过“三次握手”。第一次握手，客户端向服务器端收回连贯申请，期待服务器确认，第二次握手，服务器端向客户端回送一个响应，告诉客户端收到了连贯申请，第三次握手，客户端再次向服务器端发送确认信息，确认连贯。整个交互过程如下图所示。
因为 TCP 协定的面向连贯个性，它能够保障传输数据的安全性，所以是一个被宽泛采纳的协定，例如在下载文件时，如果数据接管不残缺，将会导致文件数据失落而不能被关上，因而，下载文件时必须采纳 TCP 协定。
UDP 通信
DatagramPacket
后面介绍了 UDP 是一种面向无连贯的协定，因而，在通信时发送端和接收端不必建设连贯。UDP 通信的过程就像是货运公司在两个码头间发送货物一样。在码头发送和接管货物时都须要应用集装箱来装载货物，UDP 通信也是一样，发送和接管的数据也须要应用“集装箱”进行打包，为此 JDK 中提供了一个 DatagramPacket 类，该类的实例对象就相当于一个集装箱，用于封装 UDP 通信中发送或者接管的数据。
想要创立一个 DatagramPacket 对象，首先须要理解一下它的构造方法。在创立发送端和接收端的 DatagramPacket 对象时，应用的构造方法有所不同，接收端的构造方法只须要接管一个字节数组来寄存接管到的数据，而发送端的构造方法岂但要接管寄存了发送数据的字节数组，还须要指定发端口号送端 IP 地址和。接下来依据 API 文档的内容，对 DatagramPacket 的构造方法进行逐个具体地解说。
DatagramPacket(byte[] buf,int length):
应用该构造方法在创立 DatagramPacket 对象时，指定了封装数据的字节数组和数据的大小，没有指定 IP 地址和端口号。很显著，这样的对象只能用于接收端，不能用于发送端。因为发送端肯定要明确指出数据的目的地(ip 地址和端口号)，而接收端不须要明确晓得数据的起源，只须要接管到数据即可。
DatagramPacket(byte[] buf,int length,InetAddress addr,int port):
应用该构造方法在创立 DatagramPacket 对象时，不仅指定了封装数据的字节数组和数据的大小，还指定了数据包的指标 IP 地址（addr）和端口号（port）。该对象通常用于发送端，因为在发送数据时必须指定接收端的 IP 地址和端口号，就如同发送货物的集装箱下面必须表明接管人的地址一样。
下面咱们解说了 DatagramPacket 的构造方法，接下来对 DatagramPacket 类中的罕用办法进行具体地解说，如下表所示。
办法申明
性能形容
InetAddress getAddress()
该办法用于返回发送端或者接收端的 IP 地址，如果是发送端的 DatagramPacket 对象，就返回接收端的 IP 地址，反之，就返回发送端的 IP 地址
int getPort()
该办法用于返回发送端或者接收端的端口号，如果是发送端的 DatagramPacket 对象，就返回接收端的端口号，反之，就返回发送端的端口号
byte[] getData()
该办法用于返回将要接管或者将要发送的数据，如果是发送端的 DatagramPacket 对象，就返回将要发送的数据，反之，就返回接管到的数据
int getLength()
该办法用于返回接管或者将要发送数据的长度，如果是发送端的 DatagramPacket 对象，就返回将要发送的数据长度，反之，就返回接管到数据的长度
DatagramSocket
DatagramPacket 数据包的作用就如同是“集装箱”，能够将发送端或者接收端的数据封装起来。然而运输货物只有“集装箱”是不够的，还须要有码头。在程序中须要实现通信只有 DatagramPacket 数据包也同样不行，为此 JDK 中提供的一个 DatagramSocket 类。DatagramSocket 类的作用就相似于码头，应用这个类的实例对象就能够发送和接管 DatagramPacket 数据包，发送数据的过程如下图所示。
在创立发送端和接收端的 DatagramSocket 对象时，应用的构造方法也有所不同，上面对 DatagramSocket 类中罕用的构造方法进行解说。
DatagramSocket():
该构造方法用于创立发送端的 DatagramSocket 对象，在创立 DatagramSocket 对象时，并没有指定端口号，此时，零碎会调配一个没有被其它网络程序所应用的端口号。
DatagramSocket(int port):
该构造方法既可用于创立接收端的 DatagramSocket 对象，又能够创立发送端的 DatagramSocket 对象，在创立接收端的 DatagramSocket 对象时，必须要指定一个端口号，这样就能够监听指定的端口。
下面咱们解说了 DatagramSocket 的构造方法，接下来对 DatagramSocket 类中的罕用办法进行具体地解说。
办法申明
性能形容
void receive(DatagramPacket p)
该办法用于将接管到的数据填充到 DatagramPacket 数据包中，在接管到数据之前会始终处于阻塞状态，只有当接管到数据包时，该办法才会返回
void send(DatagramPacket p)
该办法用于发送 DatagramPacket 数据包，发送的数据包中蕴含将要发送的数据、数据的长度、近程主机的 IP 地址和端口号
void close()
敞开以后的 Socket，告诉驱动程序开释为这个 Socket 保留的资源
UDP 网络程序
解说了 DatagramPacket 和 DatagramSocket 的作用，接下来通过一个案例来学习一下它们在程序中的具体用法。
下图为 UDP 发送端与接收端交互图解，原图为 UDP 图解.bmp
要实现 UDP 通信须要创立一个发送端程序和一个接收端程序，很显著，在通信时只有接收端程序先运行，能力防止因发送端发送的数据无奈接管，而造成数据失落。因而，首先须要来实现接收端程序的编写。
/*
- 应用 UDP 实现数据的发送
- 发送端
- 1, 创立 DatagramSocket 对象
- 2，创立 DatagramPacket 对象，并封装数据
- 3，发送数据
- 4，开释流资源
*/
public class UDPSend {
public static void main(String[] args) throws IOException {
//1, 创立 DatagramSocket 对象
DatagramSocket sendSocket = new DatagramSocket();
//2，创立 DatagramPacket 对象，并封装数据
//public DatagramPacket(byte[] buf, int length, InetAddress address, int port)
// 结构数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
byte[] buffer = “hello,UDP”.getBytes();
DatagramPacket dp = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(“192.168.74.58”), 12306);
//3，发送数据
//public void send(DatagramPacket p) 从此套接字发送数据报包
sendSocket.send(dp);
//4，开释流资源
sendSocket.close();
}
}
/* - 应用 UDP 实现数据的发送
- 发送端
- 1, 创立 DatagramSocket 对象
- 2，创立 DatagramPacket 对象，并封装数据
- 3，发送数据
- 4，开释流资源
*/
public class UDPSend {
public static void main(String[] args) throws IOException {
//1, 创立 DatagramSocket 对象
DatagramSocket sendSocket = new DatagramSocket();
//2，创立 DatagramPacket 对象，并封装数据
//public DatagramPacket(byte[] buf, int length, InetAddress address, int port)
// 结构数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
byte[] buffer = “hello,UDP”.getBytes();
DatagramPacket dp = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(“192.168.74.58”), 12306);
//3，发送数据
//public void send(DatagramPacket p) 从此套接字发送数据报包
sendSocket.send(dp);
//4，开释流资源
sendSocket.close();
}
}
复制代码
TCP 通信
学习了如何实现 UDP 通信，再来学习下实现 TCP 通信。TCP 通信同 UDP 通信一样，都能实现两台计算机之间的通信，通信的两端都须要创立 socket 对象。区别在于，UDP 中只有发送端和接收端，不辨别客户端与服务器端，计算机之间能够任意地发送数据。而 TCP 通信是严格辨别客户端与服务器端的，在通信时，必须先由客户端去连贯服务器端能力实现通信，服务器端不能够被动连贯客户端，并且服务器端程序须要当时启动，期待客户端的连贯。
在 JDK 中提供了两个类用于实现 TCP 程序，一个是 ServerSocket 类，用于示意服务器端，一个是 Socket 类，用于示意客户端。通信时，首先创立代表服务器端的 ServerSocket 对象，该对象相当于开启一个服务，并期待客户端的连贯，而后创立代表客户端的 Socket 对象向服务器端收回连贯申请，服务器端响应申请，两者建设连贯开始通信。整个通信过程如图所示。原图 TCP 图解 1.bmp
ServerSocket
通过后面的学习晓得，在开发 TCP 程序时，首先须要创立服务器端程序。JDK 的 java.net 包中提供了一个 ServerSocket 类，该类的实例对象能够实现一个服务器段的程序。通过查阅 API 文档可知，ServerSocket 类提供了多种构造方法，接下来就对 ServerSocket 的构造方法进行逐个地解说。
ServerSocket(int port)：
应用该构造方法在创立 ServerSocket 对象时，就能够将其绑定到一个指定的端口号上（参数 port 就是端口号）。端口号能够指定为 0，此时零碎就会为咱们调配一个还没有被其它网络程序所应用的端口号。因为客户端须要依据指定的端口号来拜访服务器端程序，因而端口号随机调配的状况并不罕用，通常都会让服务器端程序监听一个指定的端口号。
在以上介绍的构造方法中，第二个构造方法是最常应用的。理解了如何通过 ServerSocket 的构造方法创建对象，接下来学习一下 ServerSocket 的罕用办法，如表所示。
办法申明
性能形容
Socket accept()
该办法用于期待客户端的连贯，在客户端连贯之前始终处于阻塞状态，如果有客户端连贯就会返回一个与之对应的 Socket 对象
InetAddress getInetAddress()
该办法用于返回一个 InetAddress 对象，该对象中封装了 ServerSocket 绑定的 IP 地址
ServerSocket 对象负责监听某台计算机的某个端口号，在创立 ServerSocket 对象后，须要持续调用该对象的 accept() 办法，接管来自客户端的申请。当执行了 accept()办法之后，服务器端程序会产生阻塞，直到客户端收回连贯申请，accept()办法才会返回一个 Scoket 对象用于和客户端实现通信，程序能力持续向下执行。
Socket
解说了 ServerSocket 对象能够实现服务端程序，但只实现服务器端程序还不能实现通信，此时还须要一个客户端程序与之交互，为此 JDK 提供了一个 Socket 类，用于实现 TCP 客户端程序。通过查阅 API 文档可知 Socket 类同样提供了多种构造方法，接下来就对 Socket 的罕用构造方法进行具体解说。
1、Socket()
应用该构造方法在创立 Socket 对象时，并没有指定 IP 地址和端口号，也就意味着只创立了客户端对象，并没有去连贯任何服务器。通过该构造方法创建对象后还需调用 connect(SocketAddress endpoint)办法，能力实现与指定服务器端的连贯，其中参数 endpoint 用于封装 IP 地址和端口号。
2、Socket(String host, int port)
应用该构造方法在创立 Socket 对象时，会依据参数去连贯在指定地址和端口上运行的服务器程序，其中参数 host 接管的是一个字符串类型的 IP 地址。
3、Socket(InetAddress address, int port)
该办法在应用上与第二个构造方法相似，参数 address 用于接管一个 InetAddress 类型的对象，该对象用于封装一个 IP 地址。
在以上 Socket 的构造方法中，最罕用的是第一个构造方法。理解了 Socket 构造方法的用法，接下来学习一下 Socket 的罕用办法，如表所示。
办法申明
性能形容
int getPort()
该办法返回一个 int 类型对象，该对象是 Socket 对象与服务器端连贯的端口号
InetAddress getLocalAddress()
该办法用于获取 Socket 对象绑定的本地 IP 地址，并将 IP 地址封装成 InetAddress 类型的对象返回
void close()
该办法用于敞开 Socket 连贯，完结本次通信。在敞开 socket 之前，应将与 socket 相干的所有的输出 / 输入流全副敞开，这是因为一个良好的程序应该在执行结束时开释所有的资源
InputStream getInputStream()
该办法返回一个 InputStream 类型的输出流对象，如果该对象是由服务器端的 Socket 返回，就用于读取客户端发送的数据，反之，用于读取服务器端发送的数据
OutputStream getOutputStream()
该办法返回一个 OutputStream 类型的输入流对象，如果该对象是由服务器端的 Socket 返回，就用于向客户端发送数据，反之，用于向服务器端发送数据
在 Socket 类的罕用办法中，getInputStream()和 getOutStream()办法别离用于获取输出流和输入流。当客户端和服务端建设连贯后，数据是以 IO 流的模式进行交互的，从而实现通信。接下来通过一张图来形容服务器端和客户端的数据传输，如下图所示。
简略的 TCP 网络程序
理解了 ServerSocket、Socket 类的根本用法，为了让大家更好地把握这两个类的应用，接下来通过一个 TCP 通信的案例来进一步学习。如图所示。原图 TCP 图解 2.bmp
要实现 TCP 通信须要创立一个服务器端程序和一个客户端程序，为了保障数据传输的安全性，首先须要实现服务器端程序。
/*
- TCP 服务器端
* - 1, 创立服务器 ServerSocket 对象（指定服务器端口号）
- 2，开启服务器了，期待客户端的连贯，当客户端连贯后，能够获取到连贯服务器的客户端 Socket 对象
- 3, 给客户端反馈信息
- 4, 敞开流资源
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
//1, 创立服务器 ServerSocket 对象（指定服务器端口号）
ServerSocket ss = new ServerSocket(8888);
//2，开启服务器了，期待客户端的连贯，当客户端连贯后，能够获取到连贯服务器的客户端 Socket 对象
Socket s = ss.accept();
//3, 给客户端反馈信息
/* - a, 获取客户端的输入流
- b, 在服务端端，通过客户端的输入流写数据给客户端
*/
//a, 获取客户端的输入流
OutputStream out = s.getOutputStream();
//b, 在服务端端，通过客户端的输入流写数据给客户端
out.write(“ 你曾经连贯上了服务器 ”.getBytes());
//4, 敞开流资源
out.close();
s.close();
//ss.close(); 服务器流 通常都是不敞开的
}
}
实现了服务器端程序的编写，接下来编写客户端程序。
/* - TCP 客户端
* - 1，创立客户端 Socket 对象,（指定要连贯的服务器地址与端口号）
- 2, 获取服务器端的反馈回来的信息
- 3, 敞开流资源
*/
public class TCPClient {
public static void main(String[] args) throws IOException {
//1，创立客户端 Socket 对象,（指定要连贯的服务器地址与端口号）
Socket s = new Socket(“192.168.74.58”, 8888);
//2, 获取服务器端的反馈回来的信息
InputStream in = s.getInputStream();
// 获取获取流中的数据
byte[] buffer = new byte[1024];
// 把流中的数据存储到数组中，并记录读取字节的个数
int length = in.read(buffer);
// 显示数据
System.out.println(new String(buffer, 0 , length) );
//3, 敞开流资源
in.close();
s.close();
}
}
复制代码
TCP 案例——文件上传
目前大多数服务器都会提供文件上传的性能，因为文件上传须要数据的安全性和完整性，很显著须要应用 TCP 协定来实现。接下来通过一个案例来实现图片上传的性能。如下图所示。原图：文件上传.bmp
首先编写服务器端程序，用来接管图片。
/*
文件上传 服务器端
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
//1, 创立服务器，期待客户端连贯
ServerSocket serverSocket = new ServerSocket(8888);
Socket clientSocket = serverSocket.accept();
// 显示哪个客户端 Socket 连贯上了服务器
InetAddress ipObject = clientSocket.getInetAddress();// 失去 IP 地址对象
String ip = ipObject.getHostAddress(); // 失去 IP 地址字符串
System.out.println(“ 小样，抓到你了，连贯我！！” + “IP:” + ip);
//7, 获取 Socket 的输出流
InputStream in = clientSocket.getInputStream();
//8, 创立目的地的字节输入流 D:\upload\192.168.74.58(1).jpg
BufferedOutputStream fileOut = new BufferedOutputStream(new FileOutputStream(“D:\upload\192.168.74.58(1).jpg”));
//9, 把 Socket 输出流中的数据，写入目的地的字节输入流中
byte[] buffer = new byte[1024];
int len = -1;
while((len = in.read(buffer)) != -1){
// 写入目的地的字节输入流中
fileOut.write(buffer, 0, len);
}
//—————– 反馈信息 ———————
//10, 获取 Socket 的输入流, 作用：写反馈信息给客户端
OutputStream out = clientSocket.getOutputStream();
//11, 写反馈信息给客户端
out.write(“ 图片上传胜利 ”.getBytes());
out.close();
fileOut.close();
in.close();
clientSocket.close();
//serverSocket.close();
}
}
编写客户端，实现上传图片
/*
文件上传 客户端
public void shutdownOutput() 禁用此 Socket 的输入流, 间接的相当于告知了服务器数据写入结束
*/
public class TCPClient {
public static void main(String[] args) throws IOException {
//2, 创立客户端 Socket，连贯服务器
Socket socket = new Socket(“192.168.74.58”, 8888);
//3, 获取 Socket 流中的输入流，性能：用来把数据写到服务器
OutputStream out = socket.getOutputStream();
//4, 创立字节输出流，性能：用来读取数据源(图片) 的字节
BufferedInputStream fileIn = new BufferedInputStream(new FileInputStream(“D:\NoDir\test.jpg”));
//5, 把图片数据写到 Socket 的输入流中(把数据传给服务器)
byte[] buffer = new byte[1024];
int len = -1;
while ((len = fileIn.read(buffer)) != -1){
// 把数据写到 Socket 的输入流中
out.write(buffer, 0, len);
}
//6, 客户端发送数据结束，完结 Socket 输入流的写入操作，告知服务器端
socket.shutdownOutput();
//—————– 反馈信息 ———————
//12, 获取 Socket 的输出流 作用：读反馈信息
InputStream in = socket.getInputStream();
//13, 读反馈信息
byte[] info = new byte[1024];
// 把反馈信息存储到 info 数组中，并记录字节个数
int length = in.read(info);
// 显示反馈后果
System.out.println(new String(info, 0, length) );
// 敞开流
in.close();
fileIn.close();
out.close();
socket.close();
}
}
总结
知识点总结
IP 地址：用来惟一示意咱们本人的电脑的，是一个网络标示
端口号：用来区别以后电脑中的应用程序的
UDP: 传送速度快，然而容易丢数据，如视频聊天，语音聊天
TCP: 传送稳固，不会失落数据，如文件的上传、下载
UDP 程序交互的流程发送端
1, 创立 DatagramSocket 对象
2，创立 DatagramPacket 对象，并封装数据
3，发送数据
4，开释流资源
接收端
1, 创立 DatagramSocket 对象
2, 创立 DatagramPacket 对象
3, 接收数据存储到 DatagramPacket 对象中
4, 获取 DatagramPacket 对象的内容
5, 开释流资源
TCP 程序交互的流程客户端
1, 创立客户端的 Socket 对象
2, 获取 Socket 的输入流对象
3, 写数据给服务器
4, 获取 Socket 的输出流对象
5，应用输出流，读反馈信息
6, 敞开流资源
服务器端
1，创立服务器端 ServerSocket 对象，指定服务器端端口号
2，开启服务器，期待着客户端 Socket 对象的连贯，如有客户端连贯，返回客户端的 Socket 对象
3, 通过客户端的 Socket 对象，获取客户端的输出流，为了实现获取客户端发来的数据
4, 通过客户端的输出流，获取流中的数据
5, 通过客户端的 Socket 对象，获取客户端的输入流，为了实现给客户端反馈信息
6, 通过客户端的输入流，写数据到流中
7, 敞开流资源
关键词：前端培训