12 . Python3之网络编程

# 1. 首先要通过各种物理连接介质连接
# 2. 找准确对方计算机(准确到软件)的位置
# 3. 通过统一的标准(一般子协议)进行数据的转发

# 物理连接介质，这个是网络工程师所考虑的，后面也会给大家简单的讲到，咱们主要就是学习这统一的标准。

# 英语成为世界上所有人通信的统一标准，如果把计算机看成分布于世界各地的人，那么连接两台计算机之间的internet实际上就是一系列统一的标准，这些标准称之为互联网协议，互联网的本质就是一系列的协议，总称为‘互联网协议’（Internet Protocol Suite).

# 互联网协议的功能：定义计算机如何接入internet，以及接入internet的计算机通信的标准。

# C/S 架构
	C: 客户端
	S: 服务端

# B/S 架构
	B: 浏览器
	S: 服务端
        
# C/S架构:  需要安装一下才能使用
# 		client  客户端:  我们用的  需要安装的
# 		server	服务端

# B/S架构： 百度 博客园 谷歌 码云
# 		browser	浏览器
# 		server	服务器

# b/s和c/s什么关系?
# B/S架构是C/S架构的一种

# C/S架构的好处
# 	可以离线使用/功能更完善/安全性更好

# B/S架构
# 	不用安装就可以使用
# 	统一PC端用户的入口

# 手机端: 好像C/S架构比较火，其实不然，微信小程序，支付宝第三方接口都类似于B/S架构
# 目的都在于统一接口: 聚集用户群

# PC端: BS比较火
# 本质: B/S架构本身也是C/S架构

# 服务端: 24小时不间断提供服务，谁来我就服务谁
# 客户端: 想体验服务的时候，就去找服务端体验服务

# 开发C/S架构的软件

# 开发B/S架构的软件

# 绝大部分先进技术的兴起基本来自于军事，网络编程这项技术来源于美国军事，为了实现数据的远程传输.

# 插电话线的电话
# 插网线的大屁股电脑
# 插无线网卡的笔记本电脑

# 综上我们能够总结出第一个规律:要想实现远程通信第一个需要具备的条件就是: 物理连接介质
# 再来想人与人之间交流，中国人说中文，外国人说外语,
# 那如果想实现不同国家的人之间无障碍沟通交流是不是得规定一个大家都能听得懂的语言>>>英语
# 再回来看计算机领域,计算机之间要想实现远程通信除了需要有物理连接介质之外是不是也应该有一套公共的标准?这套标准就是
# >>>OSI七层协议(也叫OSI七层模型)

# 应用层
# 表示层
# 会话层
# 传输层
# 网络层
# 数据链路层
# 物理连接层

# 也有人将其归纳为五层
# 应用层
# 传输层
# 网络层
# 数据链路层
# 物理连接层

# 实现计算机之间物理连接，传输的数据都是010101的二进制
# 电信号工作原理: 点只有高低电平

# head包含：(固定18个字节)
    # 发送者／源地址，6个字节
	# 接收者／目标地址，6个字节
	# 数据类型，6个字节
    
# data包含: (最短46字节，最长1500字节)
	# 数据包的具体内容
# head长度 + data长度 = 最短64字节，最长1518字节，超过限制就分片发送

# 1. 规定了二进制数据的分组方式
# 2. 规定了只要是接入互联网的计算机，都必须有一块网卡
# 网卡上刻有世界唯一的编号
# 每块网卡出厂时都会被烧制上一个世界上唯一的mac地址
#  长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）   
#  我们管网卡上刻有的编号叫电脑的>>>mac地址  
#  —–>上面的两个规定其实就是 “以太网协议”！

# 基于以太网协议通信: 通信基本靠吼!!!  弊端: 广播风暴
# 交换机: 如果没有交换机，你的电脑就变成了马蜂窝，有了交换机吼，所有的电脑只需要一个网卡连接交换机，即可实现多台电脑之间物理连接

#​ 规定了计算机都必须有一个ip地址  
# ip地址特点:点分十进制  
#​ 有两个版本ipv4和ipv6 为了能够兼容更多的计算机  
# 最小:0.0.0.0  
#​ 最大:255.255.255.255  
# IP协议可以跨局域网传输
# ip地址能够唯一标识互联网中独一无二的一台机器！
# [http://14.215.177.39/](http://14.215.177.39/)

# TCP，UDP基于端口工作的协议！  
# 其实计算机之间通信其实是计算机上面的应用程序于应用之间的通信  
# 端口(port)：唯一标识一台计算机上某一个基于网络通信的应用程序  
# 端口范围:0~~65535(动态分配)  
# 注意：0~~1024通常是归操作系统分配的端口号  
# 通常情况下，我们写的软件端口号建议起在8000之后  
# flask框架默认端口5000  
# django框架默认端口8000  
#​ mysql数据库默认端口3306  
# redis数据库默认端口6379  
# 注意:一台计算机上同一时间一个端口号只能被一个应用程序占用

# 小总结:  
# IP地址：唯一标识全世界接入互联网的独一无二的机器  
# port端口号:唯一标识一台计算机上的某一个应用程序  
# ip+port :能够唯一标识全世界上独一无二的一台计算机上的某一个应用程序

# 补充:  
# arp协议:根据ip地址解析mac地址

# 三次握手四次挥手
# 三次握手建连接
# 四次挥手断连接

# Tcp(语音聊天/视频聊天),线下缓存高强电影\QQ远程控制
# 需要先建立连接，然后才能通信
# 占用连接\可靠(消息不会丢失)\实时性高\慢

# UDP(发消息) - 在线播放视频\QQ发消息\微信消息
# 不需要建立连接，就可以通信
# 不占用连接\不可靠\消息因为网络不稳定丢失\快

socket.socket([family[,type[,proto]]])

import socket
socket.socket(socket_family,socket_type,protocal=0)
 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

 获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)
服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

# family:  套接字家族可以使AF_UNIX或者FA_INET
# type: 套接字类型可以根据市面向连接的还是非连接氛围SOCK_STREAM或SOCK_DGRAM.
# protocol: 一般默认为0.

# server.py
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9000))

# 等着别人连我
sk.listen()
# 等待客户链接我,并且会有一个链接地址
conn,addr = sk.accept()
print(conn,"CCCCCCCCCOOO")
print(addr,"IPAIP")
conn.send(b'hello')
msg = conn.recv(1024)
print(msg)
# 最多接收1024字节数据
conn.recv(1024)
conn.close()
# 把他关掉，不让别人链接了
sk.close()

# client.py
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9000))
msg = sk.recv(1024)
print(msg)
sk.send(b'byebyte')
sk.close()

# 我们使用socket模块的socket函数来创建一个socket对象，socket对象可以通过调用其他函数来设置一个socket服务.
# 现在我们可以通过bind(hostname,port)函数来指定服务的port(端口)
# 接着，我们调用socket对象的acoepl方法，该方法等待客户端的连接，并返回connection对象，表示已连接客户端。

#!/usr/bin/python3
# 文件名：server.py

# 导入socket、sys模块
import socket
import sys

# 创建socket对象
serversocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 获取本机主机名
host = socket.gethostname()
port = 9999

# 绑定端口号
serversocket.bind((host,port))

# 设置最大连接数，超过后排队
serversocket.listen(5)

while True:
        # 建立客户端连接
    clientsocket,addr = serversocket.accept()      
    print("连接地址: %s" % str(addr))
    msg='欢迎访问YouMenDemo！'+ "\r\n"
    clientsocket.send(msg.encode('utf-8'))
    clientsocket.close()

# 接下来我们写一个简单的客户端实例连接以上创建的服务，端口号为9999
# socket.connect(hostname,port)方法打开一个TCP连接到主机为hostname端口为port的服务商，
# 连接后我们就可以从服务端获取数据，记住，操作完成后需要关闭连接.

#!/usr/bin/python3
# 文件名：client.py
import socket
import sys

# 创建socket对象
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 获取本地主机名
host = socket.gethostname()

# 设置端口号
port = 9999

# 连接服务，指定主机和端口
s.connect((host,port))

# 接受小于1024字节的数据
msg = s.recv(1024)

s.close()
print(msg.decode('utf-8'))

# 欢迎访问YouMenDemo！

# 同时打开第一个终端，会出现以下信息输出:
# 连接地址: ('172.19.0.2', 51157)

# Server端
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9005))
sk.listen()

while True:
    conn,addr = sk.accept()
    print("conn :" ,conn)
    while True:
        send_msg = input('>>>')
        if send_msg.upper() == 'Q':
            break
        conn.send(send_msg.encode('utf-8'))
        msg = conn.recv(1024).decode('utf-8')
        if msg.upper() == 'Q':
            break
        print(msg)
    conn.close()
sk.close()

# Client端
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9005))

while True:
    msg = sk.recv(1024)
    msg2 = msg.decode('utf-8')
    if msg2.upper() == 'Q':break

    print(msg,msg2)
    send_msg = input('>>>')
    if send_msg.upper() == 'Q':
        break
    sk.send(send_msg.encode('utf-8'))

sk.close()

tcps = socket() #创建服务器套接字
tcps.bind()      #把地址绑定到套接字
tcps.listen()      #监听链接
while True:      #服务器无限循环
    tcpc = tcps.accept() #接受客户端链接
    while True:         #通讯循环
        tcpc.recv()/tcpc.send() #对话(接收与发送)
    tcpc.close()    #关闭客户端套接字
tcps.close()        #关闭服务器套接字(可选)

#!/usr/bin/python3
# -*-coding:utf-8 -*-
from socket import *
import time
COD = 'utf-8'
HOST = '192.168.164.141' # 主机ip
PORT = 21566 # 软件端口号
BUFSIZ = 1024
ADDR = (HOST, PORT)
SIZE = 10 
tcpS = socket(AF_INET, SOCK_STREAM) # 创建socket对象
tcpS.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #加入socket配置，重用ip和端口
tcpS.bind(ADDR) # 绑定ip端口号
tcpS.listen(SIZE)  # 设置最大链接数
while True:
    print("服务器启动，监听客户端链接")
    conn, addr = tcpS.accept() 
    print("链接的客户端", addr)
    while True:
        try:
            data = conn.recv(BUFSIZ) # 读取已链接客户的发送的消息
        except Exception:
            print("断开的客户端", addr)
            break
        print("客户端发送的内容:",data.decode(COD))
        if not data:
            break
        msg = time.strftime("%Y-%m-%d %X") #获取结构化事件戳
        msg1 = '[%s]:%s' % (msg, data.decode(COD))
        conn.send(msg1.encode(COD)) #发送消息给已链接客户端
    conn.close() #关闭客户端链接
tcpS.closel()

tcpc = socket()    # 创建客户端套接字
tcpc.connect()    # 尝试连接服务器
while True:        # 通讯循环
    tcpc.send()/tcpc.recv()    # 对话(发送/接收)
tcpc.close()      # 关闭客户套接字

#!/usr/bin/python3
# -*-coding:utf-8 -*-
from socket import *
from time import ctime
HOST = '192.168.164.141' #服务端ip
PORT = 21566 #服务端端口号
BUFSIZ = 1024
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM) #创建socket对象
tcpCliSock.connect(ADDR) #连接服务器
while True:
    data = input('>>').strip()
    if not data:
        break
    tcpCliSock.send(data.encode('utf-8')) #发送消息
    data = tcpCliSock.recv(BUFSIZ) #读取消息
    if not data:
        break
    print(data.decode('utf-8'))
tcpCliSock.close() #关闭客户端

每个 socket 被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。

write()/send() 并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它们何时被发送到网络，这些都是TCP协议负责的事情。

TCP协议独立于 write()/send() 函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制。

read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取。

这些I/O缓冲区特性可整理如下：

1.I/O缓冲区在每个TCP套接字中单独存在；
2.I/O缓冲区在创建套接字时自动生成；
3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据；
4.关闭套接字将丢失输入缓冲区中的数据。

输入输出缓冲区的默认大小一般都是 8K，可以通过 getsockopt() 函数获取：

1.unsigned optVal;
2.int optLen = sizeof(int);
3.getsockopt(servSock, SOL_SOCKET, SO_SNDBUF,(char*)&optVal, &optLen);
4.printf("Buffer length: %d\n", optVal);

socket缓冲区解释

socket缓存区的详细解释:
    
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。    

# 只出现在TCP协议中，因为TCP协议多条消息之间没有边界，并且还有一大堆优化算法.

# 两种情况会粘包:
# 发送端: 接收方没有及时接受缓冲区的包，造成多个包接受(客户端发送了一段数据，服务端只收了一部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包)

# 接受端: 发送端需要等缓冲区满才能发送出去，造成粘包(发送数据时间间隔很短，数据也很小，会合在一起，产生粘包)

# 1. udp协议客户端允许发空
# 2. udp协议不会粘包
# 3. udp协议服务端不存在的情况下，客户端照样不会报错

# Socket_Server_UDP.py
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)

server = ('127.0.0.1',8089)

while True:
    msg = input('>>>')
    if msg.upper() == 'Q': break
    sk.sendto(b'ip,port,server',server)
    msg = sk.recv(1024)
    if msg.upper() == 'Q': break
    print(msg)
# Socket_Client_UDP.py
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8089))

while True:
    msg,addr = sk.recvfrom(1024)
    print(msg)
    msg=input(">>>")
    sk.sendto(msg.encode('utf-8'),addr)

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

# 服务端
import socket

server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8000))

msg,addr=server.recvfrom(1024)
print(msg.decode('utf-8'))
server.send(b'hello',addr)

server.close()

#!/usr/bin/env python3
#-*- coding:utf-8 -*-

# 客户端
import socket

client=socket.socket(type=socket.SOCK_DGRAM)
server_addr=('127.0.0.1',8000)

client.sendto(b'hello server baby!',server_addr)
msg,addr=client.recvfrom(1024)
print(msg,addr)

"""
# udp特点    >>>    无链接,类似于发短信，发了就行对方爱回不回，没有任何关系
# 将服务端关了，客户端起起来照样能够发数据。因为不需要考虑服务端能不能收到
"""
# 验证udp协议有无粘包问题
import socket
server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
print(server.recvfrom(1024))
print(server.recvfrom(1024))
print(server.recvfrom(1024))

import socket
client = socket.socket(type=socket.SOCK_DGRAM)
server_addr = ('127.0.0.1',8080)
client.sendto(b'hello',server_addr)
client.sendto(b'hello',server_addr)
client.sendto(b'hello',server_addr)

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

# 服务端
import socket

server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8000))

while True:
    msg,addr=server.recvfrom(1024)
    print(addr)
    print(msg.decode('utf-8'))
    info=input('>>>:').encode('utf-8')
    server.sendto(info,addr)

server.close()

#!/usr/bin/env python3
#-*- coding:utf-8 -*-

# 客户端
import socket

client=socket.socket(type=socket.SOCK_DGRAM)
server_addr=('127.0.0.1',8000)

while True:
    info=input('>>>:')
    info=('来自客户端1的消息:%s'%info).encode('utf-8')

    client.sendto(info,server_addr)
    msg,addr=client.recvfrom(1024)
    print(msg.decode('utf-8'),addr)

client.close()

import socket
import subprocess
import json
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8001))

phone.listen(5)
file_positon = r'd:\上传下载'

conn, client_addr = phone.accept()



# # 1，接收固定4个字节
ret = conn.recv(4)
#
# 2,利用struct模块将ret反解出head_dic_bytes的总字节数。
head_dic_bytes_size = struct.unpack('i',ret)[0]
#
# 3,接收 head_dic_bytes数据。
head_dic_bytes = conn.recv(head_dic_bytes_size)

# 4,将head_dic_bytes解码成json字符串格式。
head_dic_json = head_dic_bytes.decode('utf-8')


# 5,将json字符串还原成字典模式。
head_dic = json.loads(head_dic_json)

file_path = os.path.join(file_positon,head_dic['file_name'])
with open(file_path,mode='wb') as f1:
    data_size = 0
    while data_size < head_dic['file_size']:
        data = conn.recv(1024)
        f1.write(data)
        data_size += len(data)
    


conn.close()
phone.close()

import socket
import struct
import json
import os
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1', 8001))  # 与客户端建立连接， 拨号

# 1 制定file_info
file_info = {
    'file_path': r'D:\lnh.python\pyproject\PythonReview\网络编程\08 文件的上传下载\low版\aaa.mp4',
    'file_name': 'aaa.mp4',
    'file_size': None,
}
# 2 获取并设置文件大小
file_info['file_size'] = os.path.getsize(file_info['file_path'])

# 2，利用json将head_dic 转化成字符串
head_dic_json = json.dumps(file_info)

# 3,将head_dic_json转化成bytes
head_dic_bytes = head_dic_json.encode('utf-8')


# 4，将head_dic_bytes的大小转化成固定的4个字节。
ret = struct.pack('i', len(head_dic_bytes))  # 固定四个字节

# 5, 发送固定四个字节
phone.send(ret)

# 6 发送head_dic_bytes
phone.send(head_dic_bytes)


# 发送文件：
with open(file_info['file_path'],mode='rb') as f1:
    
    data_size = 0
    while data_size < file_info['file_size']:
    # f1.read() 不能全部读出来，而且也不能send全部，这样send如果过大，也会出问题，保险起见，每次至多send(1024字节)
        every_data = f1.read(1024)
        data_size += len(every_data)
        phone.send(every_data)
        
phone.close()

import os
import socket
import hashlib

secret_key = b'alex_sb'
sk = socket.socket()
sk.bind(('127.0.0.1',9001))
sk.listen()

conn,addr = sk.accept()
# 创建一个随机的字符串
rand = os.urandom(32)
# 发送随机字符串
conn.send(rand)

# 根据发送的字符串 + secrete key 进行摘要
sha = hashlib.sha1(secret_key)
sha.update(rand)
res = sha.hexdigest()

# 等待接收客户端的摘要结果
res_client = conn.recv(1024).decode('utf-8')
# 做比对
if res_client == res:
    print('是合法的客户端')
    # 如果一致,就显示是合法的客户端
    # 并可以继续操作
    conn.send(b'hello')
else:
    conn.close()
    # 如果不一致,应立即关闭连接

import socket
import hashlib

secret_key = b'alex_sb979'
sk = socket.socket()
sk.connect(('127.0.0.1',9001))

# 接收客户端发送的随机字符串
rand = sk.recv(32)
# 根据发送的字符串 + secret key 进行摘要
sha = hashlib.sha1(secret_key)
sha.update(rand)
res = sha.hexdigest()
# 摘要结果发送回server端
sk.send(res.encode('utf-8'))
# 继续和server端进行通信
msg = sk.recv(1024)
print(msg)

import socketserver  # 引入模块

class MyServer(socketserver.BaseRequestHandler):   # 类名随便定义，但是必须继承socketserver.BaseRequestHandler此类
    
    def handle(self):  # 写一个handle方法，固定名字
        while 1:
            # self.request 相当于conn管道
            from_client_data = self.request.recv(1024).decode('utf-8')
            print(from_client_data)
            to_client_data = input('服务端回信息：').strip()
            self.request.send(to_client_data)
            


if __name__ == '__main__':
    ip_port = ('127.0.0.1',8080)
    # socketserver.TCPServer.allow_reuse_address = True  # 允许端口重用
    server = socketserver.ThreadingTCPServer(ip_port,MyServer)
    # 对 socketserver.ThreadingTCPServer 类实例化对象，将ip地址，端口号以及自己定义的类名传入，并返回一个对象
    server.serve_forever() # 对象执行serve_forever方法，开启服务端

# 在整个socketserver这个模块中，其实就干了两件事情：1、一个是循环建立链接的部分，每个客户链接都可以连接成功  2、一个通讯循环的部分，就是每个客户端链接成功之后，要循环的和客户端进行通信。
# 看代码中的：server=socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)

# 还记得面向对象的继承吗？来，大家自己尝试着看看源码：

# 查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer

# 实例化得到server，先找ThreadMinxIn中的__init__方法，发现没有init方法，然后找类ThreadingTCPServer的__init__,在TCPServer中找到，在里面创建了socket对象，进而执行server_bind（相当于bind）,server_active（点进去看执行了listen）

# 找server下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中

# 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)

# 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)

# 上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....

# 源码分析总结：

# 基于tcp的socketserver我们自己定义的类中的

　　self.server即套接字对象
　　self.request即一个链接
　　self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的

　　self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
　　self.client_address即客户端地址
```![](https://img2020.cnblogs.com/blog/1871335/202005/1871335-20200517124446986-1187051722.png)