[网络协议]网络编程笔记

【?络编程】
主要内容
软件架构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)😉
   {
   // 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();
   /*
6. 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();
}
}