【⽹络编程】
主要内容
软件架构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地址可以唯⼀标识⽹络中的设备，那么端⼝号就可以唯⼀标识设备中的进程（应⽤程序）了。
端⼝号：⽤两个字节表示的整数，它的取值范围是0_{65535。其中，0}1023之间的端⼝号⽤于⼀
些知名的⽹络服务和应⽤，普通的应⽤程序需要使⽤1024以上的端⼝号。如果端⼝号被另外⼀个
服务或应⽤所占⽤，会导致当前程序启动失败。
利⽤ 协议 + IP地址 + 端⼝号 三元组合，就可以标识⽹络中的进程了，那么进程间的通信就可以利⽤这个
标识与其它进程进⾏交互。
第⼆章 TCP通信程序
2.1 概述
TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端
（Server）。
ipconfig windows
ifconfig macOS
ping 空格 IP地址
ping 112.80.248.76两端通信时步骤：

1. 服务端程序，需要事先启动，等待客户端的连接。
2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。
   在Java中，提供了两个类⽤于实现TCP通信程序：
3. 客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请
   求，两者建⽴连接开始通信。
4. 服务端： 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通信分析图解
5. 【服务端】启动,创建ServerSocket对象，等待连接。
6. 【客户端】启动,创建Socket对象，请求连接。
7. 【服务端】接收连接,调⽤accept⽅法，并返回⼀个Socket对象。
8. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
9. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。
   到此，客户端向服务端发送数据成功。
   ⾃此，服务端向客户端回写数据。
10. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
11. 【客户端】Scoket对象，获取InputStream，解析回写数据。
12. 【客户端】释放资源，断开连接。
    客户端向服务器发送数据
    服务端实现：
    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 ⽂件上传案例
    ⽂件上传分析图解
13. 【客户端】输⼊流，从硬盘读取⽂件数据到程序中。
14. 【客户端】输出流，写出⽂件数据到服务端。
15. 【服务端】输⼊流，读取⽂件数据到服务端程序。
16. 【服务端】输出流，写出⽂件数据到服务器硬盘中。

基本实现
服务端实现：
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);
}客户端实现：
⽂件上传优化分析

1. ⽂件名称写死的问题
   服务端，保存⽂件的名称如果写死，那么最终导致服务器硬盘，只会保留⼀个⽂件，建议使⽤系统
   时间优化，保证⽂件名称唯⼀，代码如下：
   //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. 循环接收的问题
   服务端，指保存⼀个⽂件就关闭了，之后的⽤户⽆法再上传，这是不符合实际的，使⽤循环改进，
   可以不断的接收不同⽤户的⽂件，代码如下：
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();
   /*
3. 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”);信息回写分析图解
   前四步与基本⽂件上传⼀致.
4. 【服务端】获取输出流，回写数据。
5. 【客户端】获取输⼊流，解析回写数据。
   回写实现
   BufferedOutputStream bos = new BufferedOutputStream(fis)