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

socket编程

一、客户端/服务端架构

　　客户端/服务端架构 即C/S架构，包括：1、硬件C/S架构，2、软件C/S架构。

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

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

二、OSI七层

　　1、一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了。

　　如果要跟别人一起玩，那就需要上网了。互联网的核心就是由一堆协议组成，协议就是标准，全世界人通信的标准是英语，如果把计算机比作人，互联网协议就是计算机界的英语。所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。人们按照分工不同把互联网协议从逻辑上划分了层级，详见网络通信原理：http://www.cnblogs.com/linhaifeng/articles/5937962.html

　　2、学socket前学互联网协议的意义：

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

三、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是同一台机器上不同进程或者线程的标识

四、套接字

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

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

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

名字：AF_UNIX

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

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

名字：AF_INET

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

五、套接字工作流程：

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

六、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()           关闭套接字

七、基于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()

客户端

八、基于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协议通信-简单版-客户端

九、须知：

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

  2、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掉通讯循环）

3、UDP协议通信，是基于数据报的连接通信

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

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

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

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

　　注意：基于TCP协议的通信，必须先建立链接才能进行数据传输，并且是必须先启动服务端，再启动客户端，否则报错！

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

十、粘包

　1、产生原因

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

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

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

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

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

　总结以下会产生粘包的两种情况：

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

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

  2、解决粘包的方法：

　　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
#首先明确一点：
#1、不管是发数据或是接收数据，都是先发送到缓存中，或是从缓存中读取！
#2、TCP协议为了传输数据，有自己的处理方法：为了避免网络延迟导致的数据传输问题，对很小的多段数据，会和到一起处理成一个大的数据包，然后再发送
#或者是一次性发送的数据过大，大于自定义的最大接收数据的值，数据就会先被接收一部分，剩余的还存在缓存之中不会丢失。
#这样再发送新数据的话，就会和上次剩余的数据在缓存中拼接在一起。这两种情况都会导致 粘包
#3、基于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()

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

十一、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

1. 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
2. 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
3. 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
4. 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
5. 上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....

源码分析总结：

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

1. 　　self.server即套接字对象
2. 　　self.request即一个链接
3. 　　self.client_address即客户端地址

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

1. 　　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)>)
2. 　　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