Py修行路 python基础（二十四）socket编程

时间 2019-12-09

标签修行 python 基础二十四 socket 编程栏目 Python 繁體版

原文原文链接

socket编程html

1、客户端/服务端架构linux

　　客户端/服务端架构即C/S架构，包括：一、硬件C/S架构，二、软件C/S架构。算法

　　互联网中到处都是C/S架构，学习socket 就是为了完成C/S架构的开发。shell

　C/S架构：
　　server端要：
　　　一、力求一直提供服务
　　　二、要绑定一个惟一的地址，让客户端能明确的找到服务端。编程

2、OSI七层json

　　一、一个完整的计算机系统是由硬件、操做系统、应用软件三者组成,具有了这三个条件，一台计算机系统就能够本身跟本身玩了。windows

　　若是要跟别人一块儿玩，那就须要上网了。互联网的核心就是由一堆协议组成，协议就是标准，全世界人通讯的标准是英语，若是把计算机比做人，互联网协议就是计算机界的英语。全部的计算机都学会了互联网协议，那全部的计算机都就能够按照统一的标准去收发信息从而完成通讯了。人们按照分工不一样把互联网协议从逻辑上划分了层级，详见网络通讯原理：http://www.cnblogs.com/linhaifeng/articles/5937962.html设计模式

　　二、学socket前学互联网协议的意义：缓存

　　学习socket编程目的是开发一款C/S架构软件，而这款软件是基于网络进行通讯的。网络的核心就是一堆协议，基于网络开发软件就必须遵照这些标准；同时socket对网络通讯协议进行了接口类型的封装，当须要使用某个协议的时候直接调用这个接口就能实现。服务器

3、socket

　　Socket是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来讲，一组简单的接口就是所有，让Socket去组织数据，以符合指定的协议。

　　因此，咱们无需深刻理解tcp/udp协议，socket已经为咱们封装好了，咱们只须要遵循socket的规定去编程，写出的程序天然就是遵循tcp/udp标准。

　　也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序 　　而程序的pid是同一台机器上不一样进程或者线程的标识

4、套接字

　　套接字起源于 20 世纪 70 年代，。一开始,套接字被设计用在同一台主机上多个应用程序之间的通信。这也被称进程间通信,或 IPC。

　　套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族：

名字：AF_UNIX

　　经常使用于linux环境中，由于linux中一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，能够经过访问同一个文件系统间接完成通讯。

基于网络类型的套接字家族：

名字：AF_INET

　　网络通讯中的ipv4协议，基于网络编程，几乎都使用AF_INEF。

5、套接字工做流程：

　　先从服务器端提及。服务器端先初始化Socket，而后与端口绑定(bind)，对端口进行监听(listen)，调用accept接收链接请求，等待客户端链接。在这时若是有个客户端初始化一个Socket，而后链接服务器(connect)，若是链接成功，这时客户端与服务器端的链接就创建了。客户端发送数据请求，服务器端接收请求并处理请求，而后把回应数据发送给客户端，客户端读取数据，最后关闭链接，一次交互结束。

6、socket模块的使用方法：

 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)

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的链接,(阻塞式)等待链接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器链接

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)

s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.close()           关闭套接字

7、基于TCP的套接字

　　此时就须要深入的理解TCP协议的三次握手，四次挥手！

socket通讯流程与打电话流程的相似，那就先以打电话的例子作一个简单的套接字通讯。

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
phone.bind(('127.0.0.1',8080)) #绑定手机卡

phone.listen(5) #开机  

print('starting....')

conn,addr=phone.accept() #等待电话连接
print('电话线路是',conn)
print('客户端的手机号是',addr)

data=conn.recv(1024) #收消息 
print('客户端发来的消息是',data)

conn.send(data.upper()) #将收到的数据转换成大写，发回
conn.close()
phone.close()

服务端

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080)) #拨电话

phone.send('hello'.encode('utf-8'))         #发消息,说话(只能发送字节类型)

data =s.recv(1024)                           #收消息,听话
print(data.decode('utf-8'))
phone.close()

客户端

　　上述整个流程的问题是：服务端只能接受一次链接，而后就完全关闭掉了，并且在链接的过程当中，若是直接断开客户端，服务端会由于报错而中断，或者是出现不能正常链接的状况！针对这种分析，断开实际状况应该是，服务端不断接受连接，而后循环通讯，通讯完毕后只关闭连接，服务器可以继续接收下一次连接，而且断开链接以后，服务端应马上释放TCP协议仍然存在的四次挥手time_wait状态占用的地址，优化处理，不影响其余客户的访问。下面是修改以后的代码：

#coding:utf-8
#打电话举例
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通讯
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)  #提早终止TCP四次挥手
phone.bind(("127.0.0.1",8080))  #绑定手机卡

phone.listen(5)#监听链接

print("start....")
while True:   #链接循环
    conn,addr = phone.accept()#等待 被动接收链接
    print("电话线路是：",conn)
    print("客户端的手机号是：",addr)

    while True:     #通讯循环
        #处理异常（客户端没有任何输入）
        try: #应对windows系统
            data = conn.recv(1024)  #接收消息  接收TCP数据
            # if not data:break   #linux系统
            print("客户端发来的消息是：",data.decode("utf-8"))
            conn.send(data.upper())  #将收到的数据，转成大写从新发给客户端
        except Exception:
            break
    conn.close()   #将这条线路关闭
phone.close()

服务端

#coding:utf-8
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通讯
phone.connect(("127.0.0.1",8080))  #主动初始化TCP服务器链接 发起链接(必须是元组形式，前边是地址，后边是接口)

while True:     #通讯循环
    inp = input(">>>:").strip()
    if not inp:continue
    phone.send(inp.encode("utf-8")) #字节数据 向服务端传值

    data = phone.recv(1024)   #接收服务端返回的数据
    print(data.decode("utf-8"))

phone.close()

客户端

8、基于UDP的套接字

　　此处须要理解UDP协议创建连接的两次握手

import socket

UDP_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先建立基于这种通讯协议的对象
IP_port = ("127.0.0.1",8080)  #惟一的IP地址和端口
UDP_server.bind(IP_port)  #服务端绑定信息

while True:  #通讯循环
    data,client_addr = UDP_server.recvfrom(1024)  #服务端接收发过来的数据(自定义范围值),格式:（data,客户端创建通讯链接的地址）
    print(data.decode("utf-8"))  #接收的消息
    msg = input(">>>:").strip()  #交互
    UDP_server.sendto(msg.encode("utf-8"),client_addr)  #给客户端发送消息，固定格式:（data,通讯地址）

基于UDP协议通讯-服务端-简单版

import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先建立基于这种通讯协议的对象
client_IP_port = ("127.0.0.1",8080)     #通讯IP地址和端口

while True:      #通讯循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端创建通讯，发送消息，格式:（data,服务器通讯地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印

基于UDP协议通讯-简单版-客户端

9、须知：

　　一、发消息，都是将数据发送到己端的发送缓存中；收消息都是从己端的缓存中收。

二、TCP协议通讯，是基于数据流的链接通讯！

　　2.1 send(bytes_data):发送数据流，数据流bytes_data若为空，本身这段的缓冲区也为空，操做系统不会控制tcp协议发空包，即便send无穷个空包，也跟没有同样！那么recv()就不会收到数据，这样可能就会致使通讯错误，进而促使程序卡住崩溃，因此写代码的过程当中要真对这一种状况进行异常处理。

　　2.2 tcp基于连接通讯

基于连接，就须要listen()监听，服务端须要被动等待接收链接accept()，而客户端就须要根据通讯地址，创建链接connect()。
基于连接，就必须先运行服务端，而后客户端再发起连接请求。
对于mac系统：若是一端断开了连接，那另一端的连接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通讯循环)
对于windows/linux系统：若是一端断开了连接，那另一端的连接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端通讯循环内加异常处理，捕捉到异常后就break掉通信循环）

三、UDP协议通讯，是基于数据报的链接通讯

　　服务端与客户端之间基于UDP协议创建通讯，跟TCP协议相比，服务端就不在须要监听链接地址，客户端和服务端再也不须要创建连接循环，而直接就能够实现通信循环。而且服务端和客户端之间通讯，传输的数据报，每一次通讯都是发送一整个报文（带有数据消息和连接端口具体描述信息的数据）。因为无需连接通讯，因此无论是否有一个正在运行的服务端，客户端只要发送消息，服务端就能收到消息；若是服务端没有打开，那客户端发送的数据就会丢失。

　　同时说明一点，udp协议的客户端发送空数据，其发送过去的存在缓存中的数据包却不是空数据，而是一条打上了各类标签的报文数据，服务端再把这条报文消息接收，读取到客户端发送的内容。因此服务端也能接收到客户端发来的空数据，这样就永远不用担忧出现卡机的问题。

　　还要说明一点，UDP协议不一样于TCP协议，从发送和接收数据传输过程当中，存在缓存中的数据是一条一条的而再也不是数据流，而且数据无论有没有被接收，必定时间以后都会被从缓存中清除。这样就避免了粘包的问题，能够说基于UDP协议通讯的数据，永远不会出现粘包的问题！

recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，在windows系统上发送的比接收的大直接报错
只有sendinto发送数据没有recvfrom收数据，数据丢失

　　注意：基于TCP协议的通讯，必须先创建连接才能进行数据传输，而且是必须先启动服务端，再启动客户端，不然报错！

　　而基于UDP协议的通讯，从协议定义角度去理解，不须要创建链接就能进行数据传输，因此开启服务端或是客户端没有前后顺序，就是其中一方不开也不会出问题！能够理解为基于UDP协议通讯的服务端或是客户端只是负责把数据包发出去，你在不在线，接不接收我管不到，我只负责发送。

10、粘包

　一、产生缘由

　　首先明确，粘包现象只在基于TCP协议通讯过程当中出现！

　　发送端能够是一K一K地发送数据，而接收端的应用程序能够两K两K地提走数据，固然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个总体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，所以TCP协议是面向流的协议。对于数据流的传输，咱们就根本不知道传输文件的字节流从何处开始，又是在何处结束！这也是容易出现粘包问题的缘由。所谓粘包问题主要仍是由于接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所形成的。

　　须要明白的是当对方send一条信息的时候，不管底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈如今内核缓冲区。

　　此外，发送方引发的粘包是由TCP协议自己形成的，TCP为提升传输效率，发送方每每要收集到足够多的数据后才发送一个TCP段。若连续几回须要send的数据都不多，一般TCP会根据优化算法把这些数据合成一个TCP段后再一次发送出去，这样接收方就收到了粘包数据。

　　再一种就是send()发过来的数据流大于recv()一次接收的数据流，这样就对原数据流形成了拆包。因此因为tcp的协议数据不会丢，没有收完包，下次接收会继续上次的位置继续接收，己端老是在收到ack时才会清除缓冲区内容。

　总结如下会产生粘包的两种状况：

　　一、发送端须要等缓冲区满才发送出去，形成粘包（发送数据时间间隔很短，数据了很小，会合到一块儿，产生粘包）

　　二、接收方不及时接收缓冲区的包，形成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候仍是从缓冲区拿上次遗留的数据，产生粘包）

二、解决粘包的方法：

　　1）利用时间模块，给send()或是recv()加上延迟，从TCP协议上下手，粗暴的解决！这种方式理解就好！

　　2）首先想下问题的根源，关键点就是：接收端不知道发送端将要传送的字节流的长度，因此解决粘包的方法就是围绕：如何让发送端在发送数据前，把本身将要发送的字节流总大小让接收端知晓，而后接收端来一个死循环接收完全部数据。能够想象一下，若是直接接收的话，小的数据流还能够，若是碰到一个好几T的文件，那得须要多好的设备，才能让设备接收的时候不一下卡死！因此仍是固定一个接收的范围，循环的接收直至数据接收完成。

　　这种方式有个弊端：就是不知道数据传输过程当中的网络延迟可否遇上程序的运行速度！

　　3）基于第2种的方法的优化，就是给字节流加上自定义固定长度报头，报头中包含字节流长度，而后一次send到对端，对端在接收时，先从缓存中取出定长的报头，而后再取真实数据。

　　报头：固定长度
　　　　　包含对将要发送数据的描述信息

　　基于这种方式就须要用到 struct 模块（打包，解包），该模块能够把一个类型，如数字，转成固定长度的bytes。

服务端利用struct模块，将数据的大小打包一下生成一个固定bytes格式的报头；客户端先接收这个报头，解包拿出数据流的大小。而后服务端发送数据，客户端根据这个值死循环以固定格式接收这个数据流，接受完成以后再打印。

#coding:utf-8
import socket,subprocess,struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
IP_port = ("127.0.0.1",8080)
phone.bind(IP_port)

phone.listen(5)

while True:
    conn,addr = phone.accept()
    print("client addr:",addr)
    while True:
        try:
            cmd = conn.recv(1024).decode("utf-8")
            res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            out_res = res.stdout.read()
            err_res = res.stderr.read()
            data_size = len(out_res)+len(err_res)

            #发送报头（数据的大小）
            conn.send(struct.pack("i",data_size))
            #发送数据部分
            conn.send(out_res)
            conn.send(err_res)
        except Exception:
            break
    conn.close()
phone.close()

服务端-初始方法

import socket,struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
IP_port = ("127.0.0.1",8080)
phone.connect(IP_port)

while True:
    cmd = input(">>>:").strip()
    if not cmd:continue
    phone.send(bytes(cmd,encoding="utf-8"))

    #收报头
    header = phone.recv(4)
    data_size = struct.unpack("i",header)[0]

    #收数据
    recv_size = 0
    recv_data = b''
    while recv_size < data_size:
        data = phone.recv(1024)
        recv_size += len(data)
        recv_data += data
    print(recv_data.decode("utf-8"))

phone.close()

客户端-初始方法

　　针对这种方式，咱们能够再深刻的去理解下，报头既然是描述数据流信息的，那要不要把报头写成一个字典形式，里边写入真实数据的具体信息。服务端和客户端经过这个报头，进行更细致的操做！

socket通讯发送，接收的都是bytes格式的数据，而且bytes只能和字符串进行编码解码的转换！因此就须要先把字典类型的报头json序列化，获取json字符串的长度，而后用struct将序列化后的数据长度打包成4个字节（4个本身足够用了），再把json字符串的报头转成bytes格式，等待传输。

发送时：

先发报头长度

再编码报头内容而后发送

最后发真实内容

接收时：

先接收报头长度，用struct取出来

根据取出的长度收取报头内容，而后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，而后去取真实的数据内容

#coding:utf-8
#首先明确一点：
#一、无论是发数据或是接收数据，都是先发送到缓存中，或是从缓存中读取！
#二、TCP协议为了传输数据，有本身的处理方法：为了不网络延迟致使的数据传输问题，对很小的多段数据，会和到一块儿处理成一个大的数据包，而后再发送
#或者是一次性发送的数据过大，大于自定义的最大接收数据的值，数据就会先被接收一部分，剩余的还存在缓存之中不会丢失。
#这样再发送新数据的话，就会和上次剩余的数据在缓存中拼接在一块儿。这两种状况都会致使 粘包
#三、基于socket的TCP协议通讯，在通讯管道中数据是以 字节数据流 的形式传输，对于这个数据流咱们不知道它是从哪里开始，有是到哪里结束。

#为了不粘包，在传递真实数据以前，先自定义一个报头，报头中写入要传递的数据的信息，先把报头的长度 打包 发送给客户端；
# 客户端拿到数据以后，解包收到的内容（即报头的长度），而后再根据收到的数据 自定义接收报头的 字节 长度（减小缓存中的占用，须要多少用多少）；
#服务端再将已经转码成字节格式的报头发送给客户端，客户端接收到报头以后，将字节转码成字符串，而后利用json将字符串类型的数据转成真实的数据类型（字典）；
#而后客户端在获得的字典中获取真实数据的大小，根据这个大小获取服务端发送给客户端全部的数据，进行 循环 接收；
# 避免大数据传输中一次性接收，设备缓存的资源不足问题。同时数据不接收完不打印，避免粘包。

import socket,subprocess,struct,json
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #先声明一个基于socket通讯对象
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #处理time_wait
IP_port = ("127.0.0.1",8080)  #服务端惟一通讯地址和端口
phone.bind(IP_port)    #做为本机的惟一标签，绑定到本机

phone.listen(5)  #等待通讯

while True: #链接循环
    conn,addr = phone.accept()  #等待链接
    print("client addr:",addr)
    while True:  #通信循环
        try: #异常判断
            cmd = conn.recv(1024).decode("utf-8")   #接收从客户端发来的数据（bytes数据）
                          # 1024 指定义的从缓存中一次拿取数据的最大量，取值范围是（单位：字节）：0-1024
            res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)  #在当前操做系统中执行操做
            out_res = res.stdout.read()  #正确的命令，按照操做获得正确的内容 （bytes数据）
            err_res = res.stderr.read()  #错误的命名，获得错误的提示   （bytes数据）
            data_size = len(out_res)+len(err_res)   #计算获得的数据 字节长度

            #报头内容
            head_dic = {"data_size":data_size}  #作一个字典格式的报头，里边囊括全部关于真实数据的信息

            head_json = json.dumps(head_dic)   #将字典类型的报头转成json格式的字符串
            head_bytes = head_json.encode("utf-8")  #将字符串转成bytes，由于socket通讯传输的都是字节数据

            #part1:先发送报头长度
            conn.send(struct.pack("i",len(head_json)))  #将报头的长度打包发送（字符串格式的长度）

            #part2:再发送报头
            conn.send(head_bytes)  #将报头发送

            #part3:发送数据
            conn.send(out_res)  #将真实的数据发送
            conn.send(err_res)
        except Exception:   #捕获异常
            break  #退出
    conn.close()    #关闭通信
phone.close()

解决粘包问题-改进版-带具体报头信息-服务端

#coding:utf-8
import socket,struct,json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #先声明一个基于socket通讯对象
IP_port = ("127.0.0.1",8080)   #链接地址
phone.connect(IP_port)   #与服务端创建通讯链接
#通信循环
while True:
    #发消息
    cmd = input(">>>:").strip()  #用户交互发送消息
    if not cmd:continue
    phone.send(bytes(cmd,encoding="utf-8"))

    #part1:先收报头的长度
    head_struct = phone.recv(4)  #收到从服务端返回的报头数据
    head_len = struct.unpack("i",head_struct)[0]  #解包字节数据，获取报头的长度

    #part2:再收报头
    head_bytes = phone.recv(head_len)   #根据报头的长度，接收报头（字节数据）
    head_json = head_bytes.decode("utf-8")  #将接收到的报头转码成字符串
    head_dic = json.loads(head_json)  #再将json字符串，反序列化成字典
    print(head_dic)

    data_size = head_dic["data_size"]   #获取真实数据的大小

    #part3:收数据
    recv_size = 0
    recv_data = b''
    while recv_size < data_size:  #循环从缓存中获取真实数据，不取完不打印
        data = phone.recv(1024)
        recv_size += len(data)
        recv_data += data
    print(recv_data.decode("utf-8"))

phone.close()

解决粘包问题-改进版-带具体报头信息-客户端

11、socketserver实现并发（基于类实现的多线程并发，每创建一次链接就在服务端产生一个对象！客户端的代码不变！）

　　前边写的通讯程序，都是一个服务器与一个客户端链接，进行通信循环。可是若是多个客户端与该服务端链接，其余的客户端就得处于等待挂起的状态，只能是等待创建链接的那个客户端断开，其余的客户端才能一一的进行链接通讯。
　　这种方式的通讯只能实现一对一的通讯，不能实现并行通讯，形成这种现象的缘由，实质就是：服务端的链接循环不能实现多个链接，进而不能实现并发通讯。
　　基于这个缘由，咱们使用socketserver这个模块，实现并发通讯！（此处用到了多线程）

socketserver模块中分两大类：server类（解决连接问题）和request类（解决通讯问题）

　　server类

　　request类

　　继承关系

1）基于多线程的并发继承关系

2）基于多进程的并发继承关系

#基于TCP协议实现 多并发 服务端 编写模版
import socketserver  #导入socketserver模块

class 类名(socketserver.BaseRequestHandler):  #创建通信  class建立一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self):  #注意此处没有__init__而是直接引用handle(self):函数，实例化对象直接调用此方法
        print("=-====>",self)
        # print(self.request)
        while True:  #通讯循环 （这里就能够任意编写）
            server = self.request  #创建通信链接，与tcp协议中accept功能一致！收到的是client_addr的通讯线路
            data = server.recv(1024)  #接收数据
            print(data.decode("utf-8"))
            server.send(data.upper())  #发送数据

IP_port = ("IP地址",端口)  #给定惟一的地址
if __name__ == '__main__':  #判断是否为主函数
    obj = socketserver.ThreadingTCPServer(IP_port,类名)#实例化一个 TCP服务 对象（绑定地址，建立的类）
    obj.serve_forever() #该对象创建连接循环

实现TCP协议并发通讯模版

#基于UDP协议实现 多并发 服务端 编写模版
import socketserver  #导入socketserver模块

class 类名(socketserver.BaseRequestHandler): #创建通信  class建立一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self): #注意此处没有__init__而是直接继承引用handle(self):函数，实例化对象直接调用此方法
#        print("=-====>",self)
        data = self.request[0]       #从客户端收到的数据
        print(data.decode("utf-8"))  #打印
        UDP_server_conn = self.request[1] #创建通信链接，获得一个客户端与服务端链接创建的套接字对象！
        UDP_client = self.client_address  #获取服务端的地址
        msg = input(">>>:").strip()   #回复内容
        UDP_server_conn.sendto(msg.encode('utf-8'),UDP_client)  #服务端像客户端发送内容（内容，和服务端创建链接的客户端地址）

IP_Port = ('IP地址',端口)  #惟一通讯地址

if __name__ == '__main__': #判断是否为主函数
    obj=socketserver.ThreadingUDPServer(IP_Port,类名) #实例化一个 UDP服务 对象（绑定地址，建立的类）
    obj.serve_forever()  #创建连接循环

实现UDP协议并发通讯模版

简单代码举例！客户端代码不变！服务端代码写成多并发形式！！！

import socketserver

class FTPserver(socketserver.BaseRequestHandler):  #通信
    def handle(self):
        print("=-====>",self)
        # print(self.request)
        while True:
            server = self.request
            data = server.recv(1024)
            print(data.decode("utf-8"))
            server.send(data.upper())

IP_port = ("127.0.0.1",8080)
if __name__ == '__main__':
    obj = socketserver.ThreadingTCPServer(IP_port,FTPserver)
    obj.serve_forever() #连接循环

TCP协议多并发-服务端-简单版

#coding:utf-8
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通讯
phone.connect(("127.0.0.1",8080))  #主动初始化TCP服务器链接 发起链接(必须是元组形式，前边是地址，后边是接口)

while True:     #通讯循环
    inp = input(">>>:").strip()
    if not inp:continue
    phone.send(inp.encode("utf-8")) #字节数据 向服务端传值

    data = phone.recv(1024)   #接收服务端返回的数据
    print(data.decode("utf-8"))

phone.close()

TCP协议多并发-客户端1-简单版

#coding:utf-8
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于TCP/IP协议通讯
phone.connect(("127.0.0.1",8080))  #主动初始化TCP服务器链接 发起链接(必须是元组形式，前边是地址，后边是接口)

while True:     #通讯循环
    inp = input(">>>:").strip()
    if not inp:continue
    phone.send(inp.encode("utf-8")) #字节数据 向服务端传值

    data = phone.recv(1024)   #接收服务端返回的数据
    print(data.decode("utf-8"))

phone.close()

TCP协议多并发-客户端2-简单版

代码分析：

　如下述代码为例，分析socketserver源码：

　　ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
　　ftpserver.serve_forever()

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

实例化获得ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
找ftpserver下的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即客户端地址

PS：UDP协议多并发：（同理也是更改服务端的代码，客户端代码不变！）

import socketserver  #导入socketserver模块

class UDPServer(socketserver.BaseRequestHandler): #创建通信  class建立一个类名继承 socketserver.BaseRequestHandler 父类
    def handle(self): #注意此处没有__init__而是直接继承引用handle(self):函数，实例化对象直接调用此方法
#        print("=-====>",self)
        data = self.request[0]       #从客户端收到的数据
        print(data.decode("utf-8"))  #打印
        UDP_server_conn = self.request[1] #创建通信链接，获得一个客户端与服务端链接创建的套接字对象！
        UDP_client = self.client_address  #获取服务端的地址
        msg = input(">>>:").strip()   #回复内容
        UDP_server_conn.sendto(msg.encode('utf-8'),UDP_client)  #服务端像客户端发送内容（内容，和服务端创建链接的客户端地址）

IP_Port = ('127.0.0.1',8080)  #惟一通讯地址

if __name__ == '__main__': #判断是否为主函数
    obj=socketserver.ThreadingUDPServer(IP_Port,UDPServer) #实例化一个 UDP服务 对象（绑定地址，建立的类）
    obj.serve_forever()  #创建连接循环

基于UDP协议多并发-服务端

import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先建立基于这种通讯协议的对象
client_IP_port = ("127.0.0.1",8080)     #通讯IP地址和端口

while True:      #通讯循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端创建通讯，发送消息，格式:（data,服务器通讯地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印

基于UDP协议多并发-客户端1

import socket

UDP_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)  #先建立基于这种通讯协议的对象
client_IP_port = ("127.0.0.1",8080)     #通讯IP地址和端口

while True:      #通讯循环
    inp = input(">>>:").strip()  #交互
    UDP_client.sendto(inp.encode("utf-8"),client_IP_port) #与服务端创建通讯，发送消息，格式:（data,服务器通讯地址）
    data,server_addr = UDP_client.recvfrom(1024)   #收到返回的消息
    print(data.decode("utf-8"))  #打印

基于UDP协议多并发-客户端2

Py修行路 python基础 （二十四）socket编程

Py修行路 python基础（二十四）socket编程