网络编程必须了解的基本概念

MAC地址：是全球唯一标示的网络接口，每一个网卡接口、交换机接口、路由器接口的mac地址均不相同。mac地址是通信子网内部相互通信的标识，交换机根据mac地址区分用户。mac地址是物理层的概念。

IP地址：ip是网络层的网络协议，通过路径检测和逻辑寻址等方法使得两个端系统(pc与服务器、手机与服务器、手机与PC等)可经由通信子网中多个节点传输数据。ip是跨越2个端系统跨越多个通信子网相互通信的前提。常见协议有IPv4和IPv6。

端口：端口是应用层的概念，ip解决了不同的端系统之间相互通信的问题，但进行网络通信的实际上是端系统内部的不同进程之间进行的，可能存在多个进程。为了区分端系统内部不同进程所以引入了端口的概念。有个比较形象的比方，ip地址好比大楼地址、端口好比房间号码。一条进程可使用多端口，但一个端口只能被一条进程独占使用，其他进程访问被已被占用的端口会报端口冲突。

TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议。建立连接需要三次握手，断开连接需要四次挥手。优点：有确认、窗口、重传、拥塞控制机制，传递数据可以保证稳定和可靠。缺点：效率低、占用系统资源高、易被攻击 。常见的TCP应用及其端口有ssh:22、ftp:21、smtp:25、http:80、telnet:23、https:443、MYSQL:3306等。

UDP协议：是用户数据报协议，提供面向事务的简单不可靠信息传送服务。使用UDP协议不用建立连接，它强调性能且不保证数据安全完整到达。优点传输速度快，比TCP协议安全性略高。缺点：不可靠，不稳定。常见的UDP应用及其端口有name server域名服务:53、bootps下载引导程序消息服务端:67、bootpc下载引导程序消息客户端:68、TFTP简单文件传输协议:69、RPC远程过程调用:111、NTP网络时间协议:123、SNMP简单网络管理协议:161、QQ:4000等。

TCP协议socket

• 服务端方法：

1. 创建socket实例。

sk = socket.socket() 

2. 绑定ip和端口。

sk.bind(('127.0.0.1',9001))

说明：该方法有一个参数，类型是元组(元组的第一个元素是IP，第二个元素是端口)。无返回值。

3. 开启监听。

sk.listen()

说明：该方法有一个参数，类型是int。可以指定指定系统允许暂未 accept 的连接数，超过后将拒绝新连接。未指定则自动设为合理的默认值，一般使用缺省值即可。无返回值。

4. 接入客户端，被动接受TCP客户端连接,(阻塞式)等待连接的到来。

conn, ip_port = sk.accept()

说明：该方法无参数。返回2个值，第一个是socket实例，第二个是元组(元组的第一个元素是IP，第二个元素是端口)。如果server端需要服务多个客户，那么accept()应该放入循环，每次成功接入后开启新的线程为新的客户端服务。

• 客户端方法：

1. 创建socket实例。

sk = socket.socket() 

2. 连接服务端。

sk.connect(('127.0.0.1',9001))

说明：该方法有一个参数，类型是元组(元组的第一个元素是IP，第二个元素是端口)。无返回值。

• 公共方法：

1. 发送数据。

sk.sendall()

2. 接收数据。

sk.recv()

• 案例代码：以下写一个回声的简单案例，服务端多线程提供服务，接收客户端发来的信息，并返回时间戳。
• 服务端

import socket
from threading import Thread
from threading import enumerate as en
import time

HOST = '127.0.0.1'        # IP地址
PORT = 50007              # 端口
max_connect = 5           # 最大连接数


def talk(conn):
    while True:
        data = conn.recv(1024).decode()
        if data == 'q' or data == 'Q':
            return
        conn.sendall(
            f"服务端于{time.strftime('%Y年%m月%d日%H时%M分%S秒')}收到了你发来的“{data}”信息！".encode())


def main():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((HOST, PORT))
        s.listen()
        while True:
            conn, _ = s.accept()
            if len(en()) < max_connect:  # 如果线程数未超过最大连接数，那么开启线程接入客户端提供服务
                Thread(target=talk, args=(conn,)).start()


if __name__ == "__main__":
    main()

• 客户端

import socket
import sys

HOST = '127.0.0.1'        # IP地址
PORT = 50007              # 端口
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    while True:
        message = input("输入你想发给服务端的信息：")
        if not message:
            continue
        s.sendall(message.encode())
        if message == 'q' or message == 'Q':
            break
        data = s.recv(1024).decode()
        print(f'收到服务端发来的信息：{data}')

• 常见问题：
• 粘包问题：因为TCP协议是流式协议所以数据包之间没有边界，那么有时会因为操作系统缓存机制、网络延迟等原因造成2次间隔时间较短、数据量较少的数据合并成一次发送。因而影响了数据的完整性。
• 解决策略：常见的解决方式是通过自定义协议厘清数据包之间的边界。常见的方法是发送数据前先发4字节的数据包长度然后再发信息，接收时先接收4字节的数据包长度再按长度接收信息。
• 发送方： 1.发送数据包前先计算长度，再将int型长度数据转换成4字节的bytes型； 2.先发送4字节bytes型长度数据，再发送数据包。
• 接收方： 1.先接收4字节bytes型长度数据，将其转换成int型长度数据。 2.只接收指定长度的数据。 以上协议是服务端和终端双方均要遵守的自定义协议。这样就可以解决粘包问题。
• stuct模块pack和unpack缺陷：处理粘包问题我查阅了很多资料，看到绝大多数人都是import struct，使用struct.pack和unpack来完成int数据与bytes相互转换的工作。但是我觉得struct模块的pack和unpack有2个缺陷：一是表示数值范围是-2147483648至2147483647，负值在计算数据长度完全用不上，会造成上传、下载文件大小不能超过2个G，unpack返回的是一个元组，还要对元组解包才能使用。所以我尝试自己写了一个pack和unpack在下面分享给大家。

• 自定义pack和unpack

def pack(n):
    if n >= 4294967296 or n < 0:
        raise ValueError('The value is out of range.')
    values = ((0b11111111000000000000000000000000, 24),
              (0b111111110000000000000000, 16), (0b1111111100000000, 8), (0b11111111, 0))
    ret = b''
    for i in values:
        x = (n & i[0]) >> i[1]
        x = x.to_bytes(length=1, byteorder="big")
        ret += x
    return ret

def unpack(numlist):
    if len(numlist) != 4:
        raise ValueError("The bytes length must be 4.")
    values = (24, 16, 8, 0)
    ret = 0
    i = 0
    while i < 4:
        n = numlist[i]
        ret += n << values[i]
        i += 1
    return ret

• 代码说明： 自定义的pack函数表示范围是0-4294967295，上传、下载文件长度在4个g以内都不会报错。 在该函数中通过按位与配合位移算法以及python3内置函数to_bytes()来完成功能，不需要另外import。 自定义的unpack函数直接返回int型数值，不需要解包。在这个函数里全部是自定义的代码，没有引用任何函数也没有导包，通过位移运算完成bytes转换成int。
• 自定义类处理收发消息和文件
• 编写TCP协议socket应用时经常会遇到发送消息和发送文件2种需求，如果将发送文件和发送消息封装到类中，会很方便。
• 代码案例：
• common.py文件，存放了Transeiver类：

from os.path import getsize  # 导入os模块中getsize函数，方便检查文件大小


class Transceiver:
    def __init__(self, conn, path='.', buffer=65536) -> None:
        self.conn = conn  # 绑定接口
        self.path = path  # 绑定工作目录
        self.buffer = buffer  # 绑定文件缓冲区大小

    @staticmethod  # 静态方法
    def pack(n: int) -> bytes:
        """将int型长度值转换成4字节bytes型数据"""
        if n >= 4294967296 or n < 0:
            raise ValueError('The value is out of range.')
        values = ((0b11111111000000000000000000000000, 24),
                  (0b111111110000000000000000, 16), (0b1111111100000000, 8), (0b11111111, 0))
        ret = b''
        for i in values:
            x = (n & i[0]) >> i[1]
            x = x.to_bytes(length=1, byteorder="big")
            ret += x
        return ret

    @staticmethod  # 静态方法
    def unpack(numlist: bytes) -> int:
        """将4字节bytes型转换回int型长度值"""
        if len(numlist) != 4:
            raise ValueError("The bytes length must be 4.")
        values = (24, 16, 8, 0)
        ret = 0
        i = 0
        while i < 4:
            n = numlist[i]
            ret += n << values[i]
            i += 1
        return ret

    def send(self, message: str) -> None:
        """发送字符串消息"""
        if (type(message) is str):  # 判断消息类型
            message = message.encode()  # 将消息转成bytes型，缺省参数是utf8编码
        self.conn.sendall(self.pack(len(message)))  # 发送消息前先发消息的长度
        self.conn.sendall(message)  # 发送消息

    @property
    def recv(self) -> str:
        length = self.unpack(self.conn.recv(4))
        return self.conn.recv(length).decode()  # 返回消息字符串

    def send_file(self, name: str) -> int:
        """发送文件"""
        try:
            length = getsize(self.path + '/' + name)
            if length > 4294967295:  # 文件大小超过4gb，返回 -2 ，停止发送文件
                return -2
            self.send(name + ',' + str(length))
            with open(self.path + '/' + name, mode='rb') as f:  # 二进制读模式打开指定文件
                while length >= 0:  # 如果未发送的文件数据长度大于等于0则循环
                    file = f.read(self.buffer)  # 从文件中读取指定大小的文件数据
                    self.conn.sendall(file)  # 发送文件数据
                    length -= self.buffer  # 计算未发送的文件数据长度
        except FileNotFoundError:
            return -1  # 文件找不到，返回 -1 ，停止发送文件
        return 1  # 文件正常发送完毕，返回1

    def recv_file(self) -> int:
        """接收文件"""
        try:
            name, length = self.recv.split(',')  # 获取文件名和文件长度
            with open(self.path + '/' + name, mode='wb') as f:  # 接收文件写入指定目录下
                size = 0  # 计算接收的数据大小
                length = int(length)  # 文件长度
                while length > size:  # 文件长度大于已接收的数据长度则循环
                    file = self.conn.recv(self.buffer)  # 接收文件数据
                    f.write(file)  # 写入文件数据
                    size += len(file)  # 累加已接收到的文件数据大小
        except FileNotFoundError:
            return -1  # 文件找不到，返回 -1 ，停止发送文件
        return 1  # 文件正常接收完毕，返回1

• server.py文件，服务端代码

import socket
from threading import Thread
from threading import enumerate as en
import time
import common

HOST = '127.0.0.1'        # IP地址
PORT = 50007              # 端口
max_connect = 5


def talk(conn):
    while True:
        m = common.Transceiver(conn, path='d:/2')
        data = m.recv
        if data == 'q' or data == 'Q':
            return
        elif data == 'file' or data == 'FILE':
            m.recv_file()
        else:
            m.send(
                f"服务端于{time.strftime('%Y年%m月%d日%H时%M分%S秒')}收到了你发来的“{data}”信息！")


def main():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((HOST, PORT))
        s.listen()
        while True:
            conn, _ = s.accept()
            if len(en()) <= max_connect:
                Thread(target=talk, args=(conn,)).start()


if __name__ == "__main__":
    main()

• client.py文件，客户端代码

import socket
import common

HOST = '127.0.0.1'        # IP地址
PORT = 50007              # 端口
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    m = common.Transceiver(s, path='d:/1')
    while True:
        message = input("输入你想发给服务端的信息：")
        if not message:
            continue
        m.send(message)
        if message == 'q' or message == 'Q':
            break
        elif message == 'file' or message == 'FILE':
            name = input('请输入文件名：')
            check = m.send_file(name)
            if check == 1:
                print('文件发送成功！')
            elif check == -1:
                print('该文件找不到')
            elif check == -2:
                print('该文件超过4GB，太大了，不能发送！')
            continue
        data = m.recv
        print(f'收到服务端发来的信息：{data}')

• 认真阅读并理解上述代码，从中可以发现使用类的好处。在common.py文件中定义了Transceiver收发器类。接下来在服务端和客户端中发送消息和发送文件代码都很简洁，提高了代码复用率。假设需要增加需求，发送接收文件需要校验md5，那么只需要在Transceiver收发器类中修改send_file方法和recv_file方法即可，而客户端和服务端的代码无须改动，这样面向对象的编程方法可维护性极高。