|
【?络编程】
主要内容
软件架构CS／BS
?络通信三要素
TCP通信
Socket套接字
ServerSocket
第?章 ?络编程??
1.1软件结构
C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常?程序有ＱＱ、迅雷等软件。
B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常?浏览器有?歌、?狐等。两种架构各有优势，但是?论哪种架构，都离不开?络的?持。?络编程，就是在?定的协议下，实现
两台计算机的通信的程序。
1.2 ?络通信协议
?络通信协议：通过计算机?络可以使多台计算机实现连接，位于同?个?络中的计算机在进?连
接和通信时需要遵守?定的规则，这就好?在道路中?驶的汽??定要遵守交通规则?样。在计算
机?络中，这些连接和通信的规则被称为?络通信协议，它对数据的传输格式、传输速率、传输步
骤等做了统?规定，通信双?必须同时遵守才能完成数据交换。
TCP/IP协议： 传输控制协议/因特?互联协议( Transmission Control Protocol/Internet
Protocol)，是Internet最基本、最?泛的协议。它定义了计算机如何连?因特?，以及数据如何在
它们之间传输的标准。它的内部包含?系列的?于处理数据通信的协议，并采?了4层的分层模
型，每?层都呼叫它的下?层所提供的协议来完成??的需求。上图中，TCP/IP协议中的四层分别是应?层、传输层、?络层和链路层，每层分别负责不同的通信功
能。
链路层：链路层是?于定义物理传输通道，通常是对某些?络连接设备的驱动协议，例如针对光纤、?
线提供的驱动。
?络层：?络层是整个TCP/IP协议的核?，它主要?于将传输的数据进?分组，将分组数据发送到?标
计算机或者?络。
运输层：主要使?络程序进?通信，在进??络通信时，可以采?TCP协议，也可以采?UDP协议。
应?层：主要负责应?程序的协议，例如HTTP协议、FTP协议等。
1.3 协议分类
通信的协议还是?较复杂的， java.net 包中包含的类和接?，它们提供低层次的通信细节。我们可以
直接使?这些类和接?，来专注于?络程序开发，?不?考虑通信的细节。
java.net 包中提供了两种常?的?络协议的?持：
UDP：?户数据报协议(User Datagram Protocol)。UDP是?连接通信协议，即在数据传输时，数
据的发送端和接收端不建?逻辑连接。简单来说，当?台计算机向另外?台计算机发送数据时，发
送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是
否收到数据。
由于使?UDP协议消耗资源?，通信效率?，所以通常都会?于?频、视频和普通数据的传输例如
视频会议都使?UDP协议，因为这种情况即使偶尔丢失?两个数据包，也不会对接收结果产?太?
影响。
但是在使?UDP协议传送数据时，由于UDP的?向?连接性，不能保证数据的完整性，因此在传输
重要数据时不建议使?UDP协议。UDP的交换过程如下图所示。特点:数据被限制在64kb以内，超出这个范围就不能发送了。
数据报(Datagram):?络传输的基本单位
TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是?向连接的通信协议，即传输
数据之前，在发送端和接收端建?逻辑连接，然后再传输数据，它提供了两台计算机之间可靠?差
错的数据传输。
在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都
需要经过“三次握?”。
三次握?：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连
接的可靠。
第?次握?，客户端向服务器端发出连接请求，等待服务器确认。
第?次握?，服务器端向客户端回送?个响应，通知客户端收到了连接请求。
第三次握?，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所
示。
完成三次握?，连接建?后，客户端和服务器就可以开始进?数据传输了。由于这种?向连接的特
性，TCP协议可以保证传输数据的安全，所以应??分?泛，例如下载?件、浏览??等。
1.4 ?络编程三要素
协议
协议：计算机?络通信必须遵守的规则，已经介绍过了，不再赘述。
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之间的?进制整数，那么最多可以表示42亿个。
IPv6：由于互联?的蓬勃发展，IP地址的需求量愈来愈?，但是?络地址资源有限，使得IP的分配
越发紧张。
为了扩?地址空间，拟通过IPv6重新定义地址空间，采?128位地址?度，每16个字节?组，分成
8组?六进制数，表示成 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 ，号称可以为全世界的
每?粒沙?编上?个?址，这样就解决了?络地址资源数量不够的问题。
常?命令
查看本机IP地址，在控制台输?：
检查?络是否连通，在控制台输?：
特殊的IP地址
本机IP地址： 127.0.0.1 、 localhost 。
端?号
?络的通信，本质上是两个进程（应?程序）的通信。每台计算机都有很多的进程，那么在?络通信
时，如何区分这些进程呢？
如果说IP地址可以唯?标识?络中的设备，那么端?号就可以唯?标识设备中的进程（应?程序）了。
端?号：?两个字节表示的整数，它的取值范围是065535。其中，01023之间的端?号?于?
些知名的?络服务和应?，普通的应?程序需要使?1024以上的端?号。如果端?号被另外?个
服务或应?所占?，会导致当前程序启动失败。
利? 协议 + IP地址 + 端?号 三元组合，就可以标识?络中的进程了，那么进程间的通信就可以利?这个
标识与其它进程进?交互。
第?章 TCP通信程序
2.1 概述
TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端
（Server）。
ipconfig windows
ifconfig macOS
ping 空格 IP地址
ping 112.80.248.76两端通信时步骤：
- 服务端程序，需要事先启动，等待客户端的连接。
- 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。
在Java中，提供了两个类?于实现TCP通信程序： - 客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请
求，两者建?连接开始通信。 - 服务端： java.net.ServerSocket 类表示。创建 ServerSocket 对象，相当于开启?个服务，
并等待客户端的连接。
2.2 Socket类
Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。
构造?法
public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端
?号。如果指定的host是null ，则相当于指定地址为回送地址。
?贴?：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要?于?络软件测
试以及本地机进程间通信，?论什么程序，?旦使?回送地址发送数据，?即返回，不进?
任何?络传输。
构造举例，代码如下：
成员?法
public InputStream getInputStream() ： 返回此套接字的输?流。
如果此Scoket具有相关联的通道，则?成的InputStream 的所有操作也关联该通道。
关闭?成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream() ： 返回此套接字的输出流。
如果此Scoket具有相关联的通道，则?成的OutputStream 的所有操作也关联该通道。
关闭?成的OutputStream也将关闭相关的Socket。
public void close() ：关闭此套接字。
?旦?个socket被关闭，它不可再使?。
关闭此socket也将关闭相关的InputStream和OutputStream 。
public void shutdownOutput() ： 禁?此套接字的输出流。
任何先前写出的数据将被发送，随后终?输出流。
2.3 ServerSocket类
ServerSocket 类：这个类实现了服务器套接字，该对象等待通过?络的请求。
Socket client = new Socket(“127.0.0.1”, 6666);构造?法
public ServerSocket(int port) ：使?该构造?法在创建ServerSocket对象时，就可以将其
绑定到?个指定的端?号上，参数port就是端?号。
构造举例，代码如下：
成员?法
public Socket accept() ：侦听并接受连接，返回?个新的Socket对象，?于和客户端实现通
信。该?法会?直阻塞直到建?连接。
2.4 简单的TCP?络程序
TCP通信分析图解 - 【服务端】启动,创建ServerSocket对象，等待连接。
- 【客户端】启动,创建Socket对象，请求连接。
- 【服务端】接收连接,调?accept?法，并返回?个Socket对象。
- 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
- 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。
到此，客户端向服务端发送数据成功。
?此，服务端向客户端回写数据。 - 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
- 【客户端】Scoket对象，获取InputStream，解析回写数据。
- 【客户端】释放资源，断开连接。
客户端向服务器发送数据
服务端实现：
ServerSocket server = new ServerSocket(6666);
public class ServerTCP {客户端实现：
服务器向客户端回写数据
服务端实现：
public static void main(String[] args) throws IOException {
System.out.println("服务端启动 , 等待连接 … ");
// 1.创建 ServerSocket对象，绑定端?，开始等待连接
ServerSocket ss = new ServerSocket(6666);
// 2.接收连接 accept ?法, 返回 socket 对象.
Socket server = ss.accept();
// 3.通过socket 获取输?流
InputStream is = server.getInputStream();
// 4.?次性读取数据
// 4.1 创建字节数组
byte[] b = new byte[1024];
// 4.2 据读取到字节数组中.
int len = is.read(b)；
// 4.3 解析数组,打印字符串信息
String msg = new String(b, 0, len);
System.out.println(msg);
//5.关闭资源.
is.close();
server.close();
}
}
public class ClientTCP {
public static void main(String[] args) throws Exception {
System.out.println(“客户端 发送数据”);
// 1.创建 Socket ( ip , port ) , 确定连接到哪?.
Socket client = new Socket(“localhost”, 6666);
// 2.获取流对象 . 输出流
OutputStream os = client.getOutputStream();
// 3.写出数据.
os.write(“亲，我是tcp客户端操作”.getBytes());
// 4. 关闭资源 .
os.close();
client.close();
}
}
public class ServerTCP {
public static void main(String[] args) throws IOException {
System.out.println("服务端启动 , 等待连接 … ");
// 1.创建 ServerSocket对象，绑定端?，开始等待连接
ServerSocket ss = new ServerSocket(6666);客户端实现：
第三章 综合案例
// 2.接收连接 accept ?法, 返回 socket 对象.
Socket server = ss.accept();
// 3.通过socket 获取输?流
InputStream is = server.getInputStream();
// 4.?次性读取数据
// 4.1 创建字节数组
byte[] b = new byte[1024];
// 4.2 据读取到字节数组中.
int len = is.read(b)；
// 4.3 解析数组,打印字符串信息
String msg = new String(b, 0, len);
System.out.println(msg);
// =回写数据=======
// 5. 通过 socket 获取输出流
OutputStream out = server.getOutputStream();
// 6. 回写数据
out.write(“亲，我是tcp服务端。”.getBytes());
// 7.关闭资源.
out.close();
is.close();
server.close();
}
}
public class ClientTCP {
public static void main(String[] args) throws Exception {
System.out.println(“客户端 发送数据”);
// 1.创建 Socket ( ip , port ) , 确定连接到哪?.
Socket client = new Socket(“localhost”, 6666);
// 2.通过Scoket,获取输出流对象
OutputStream os = client.getOutputStream();
// 3.写出数据.
os.write(“亲，我是tcp客户端”.getBytes());
// 解析回写===========
// 4. 通过Scoket,获取 输?流对象
InputStream in = client.getInputStream();
// 5. 读取数据数据
byte[] b = new byte[100];
int len = in.read(b);
System.out.println(new String(b, 0, len));
// 6. 关闭资源 .
in.close();
os.close();
client.close();
}
}第三章 综合案例
3.1 ?件上传案例
?件上传分析图解 - 【客户端】输?流，从硬盘读取?件数据到程序中。
- 【客户端】输出流，写出?件数据到服务端。
- 【服务端】输?流，读取?件数据到服务端程序。
- 【服务端】输出流，写出?件数据到服务器硬盘中。
基本实现
服务端实现：
public class FileUpload_Server {
public static void main(String[] args) throws IOException {
System.out.println("服务器 启动… ");
// 1. 创建服务端ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
// 2. 建?连接
Socket accept = serverSocket.accept();
// 3. 创建流对象
// 3.1 获取输?流,读取?件数据
BufferedInputStream bis = new
BufferedInputStream(accept.getInputStream());
// 3.2 创建输出流,保存到本地 .
BufferedOutputStream bos = new BufferedOutputStream(new
FileOutputStream(“copy.jpg”));
// 4. 读写数据
byte[] b = new byte[1024 * 8];
int len;
while ((len = bis.read(b)) != -1) {
bos.write(b, 0, len);
}客户端实现：
?件上传优化分析
- ?件名称写死的问题
服务端，保存?件的名称如果写死，那么最终导致服务器硬盘，只会保留?个?件，建议使?系统
时间优化，保证?件名称唯?，代码如下：
//5. 关闭 资源
bos.close();
bis.close();
accept.close();
System.out.println(“?件上传已保存”);
}
}
public class FileUPload_Client {
public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 创建输?流,读取本地?件
BufferedInputStream bis = new BufferedInputStream(new
FileInputStream(“test.jpg”));
// 1.2 创建输出流,写到服务端
Socket socket = new Socket(“localhost”, 6666);
BufferedOutputStream bos = new
BufferedOutputStream(socket.getOutputStream());
//2.写出数据.
byte[] b = new byte[1024 * 8 ];
int len ;
while (( len = bis.read(b))!=-1) {
bos.write(b, 0, len);
bos.flush();
}
System.out.println(“?件发送完毕”);
// 3.释放资源
bos.close();
socket.close();
bis.close();
System.out.println(“?件上传完毕 “);
}
}
FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+”.jpg”)
// ?件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);2. 循环接收的问题
服务端，指保存?个?件就关闭了，之后的?户?法再上传，这是不符合实际的，使?循环改进，
可以不断的接收不同?户的?件，代码如下： - 效率问题
服务端，在接收??件时，可能耗费?秒钟的时间，此时不能接收其他?户上传，所以，使?多线
程技术优化，代码如下：
优化实现
// 每次接收新的连接,创建?个Socket
while（true）{
Socket accept = serverSocket.accept();
…
}
while（true）{
Socket accept = serverSocket.accept();
// accept 交给?线程处理.
new Thread(new Runnable(){
…
InputStream bis = accept.getInputStream();
…
}).start();
}
public class FileUpload_Server {
public static void main(String[] args) throws IOException {
System.out.println("服务器 启动… ");
// 1. 创建服务端ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
// 2. 循环接收,建?连接
while (true) {
Socket accept = serverSocket.accept();
/* - socket对象交给?线程处理,进?读写操作
Runnable接?中,只有?个run?法,使?lambda表达式简化格式
*/
new Thread(new Runnable(){
try (
//3.1 获取输?流对象
BufferedInputStream bis = new
BufferedInputStream(accept.getInputStream());
//3.2 创建输出流对象, 保存到本地 .
FileOutputStream fis = new
FileOutputStream(System.currentTimeMillis() + “.jpg”);信息回写分析图解
前四步与基本?件上传?致. - 【服务端】获取输出流，回写数据。
- 【客户端】获取输?流，解析回写数据。
回写实现
BufferedOutputStream bos = new BufferedOutputStream(fis)😉
{
// 3.3 读写数据
byte[] b = new byte[1024 * 8];
int len;
while ((len = bis.read(b)) != -1) {
bos.write(b, 0, len);
}
//4. 关闭 资源
bos.close();
bis.close();
accept.close();
System.out.println(“?件上传已保存”);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
}
public class FileUpload_Server {
public static void main(String[] args) throws IOException {
System.out.println("服务器 启动… ");
// 1. 创建服务端ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
// 2. 循环接收,建?连接
while (true) {客户端实现：
Socket accept = serverSocket.accept();
/* - socket对象交给?线程处理,进?读写操作
Runnable接?中,只有?个run?法,使?lambda表达式简化格式
*/
new Thread(() -> {
try (
//3.1 获取输?流对象
BufferedInputStream bis = new
BufferedInputStream(accept.getInputStream());
//3.2 创建输出流对象, 保存到本地 .
FileOutputStream fis = new
FileOutputStream(System.currentTimeMillis() + “.jpg”);
BufferedOutputStream bos = new BufferedOutputStream(fis);
) {
// 3.3 读写数据
byte[] b = new byte[1024 * 8];
int len;
while ((len = bis.read(b)) != -1) {
bos.write(b, 0, len);
}
// 4.=信息回写=====================
System.out.println(“back …”);
OutputStream out = accept.getOutputStream();
out.write(“上传成功”.getBytes());
out.close();
//================================
//5. 关闭 资源
bos.close();
bis.close();
accept.close();
System.out.println(“?件上传已保存”);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
}
public class FileUpload_Client {
public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 创建输?流,读取本地?件 BufferedInputStream bis = new BufferedInputStream(new
FileInputStream(“test.jpg”));
// 1.2 创建输出流,写到服务端
Socket socket = new Socket(“localhost”, 6666);
BufferedOutputStream bos = new
BufferedOutputStream(socket.getOutputStream());
//2.写出数据.
byte[] b = new byte[1024 * 8 ];
int len ;
while (( len = bis.read(b))!=-1) {
bos.write(b, 0, len);
}
// 关闭输出流,通知服务端,写出数据完毕
socket.shutdownOutput();
System.out.println(“?件发送完毕”);
// 3. =解析回写========
InputStream in = socket.getInputStream();
byte[] back = new byte[20];
in.read(back);
System.out.println(new String(back));
in.close();
// ============================
// 4.释放资源
socket.close();
bis.close();
}
}
|