python在通信中的应用_python_socket应用

生活中的C/S架构：

饭店是S端，所有的食客是C端

互联网中处处是C/S架构(黄色网站是服务端，你的浏览器是客户端；腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看狗日的视频)

C/S架构与socket的关系：

我们学习socket就是为了完成C/S架构的开发

二、socket层

下面的这个图很好的说明了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是同一台机器上不同进程或者线程的标识

三、套接字的工作流程

下面的这个流程图很好的解释了套接字的工作运行：

先从服务器端说：

初始化Socket,与端口绑定(bind)对端口进行监听(listen)调用accpt阻塞，等待客户端连接。

在这时如果有个客户端初始化一个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。

#AF_UNIX：是 Unix 系统本地通信。

#AF_INET:基于网络类型的套接字,又是ipv4的网络通信，而且比AF_INET6，加载的跟快现在我们还是使用的ipv4所以先使用AF_INET

#AF_INET6：基于网络类型的套接字，是ipv6的挖买回来通信，

#SOCK_STREAM:是tcp/ip网络通信

#SOCK_DGRAM：获取udp/ip套接字

获取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() 创建一个与该套接字相关的文件

四、基于tcp的套接字

tcp服务端：

importsocket#AF_INET:基于网络类型的套接字,又是ipv4的网络通信，而且比AF_INET6，加载的跟快现在我们还是使用的ipv4所以先使用AF_INET#AF_INET6：基于网络类型的套接字，是ipv6的挖买回来通信，#AF_UNIX：是 Unix 系统本地通信。#SOCK_DGRAM：获取udp/ip套接字#SOCK_STREAM：获取tcp/ip套接字

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机。#重复的使用ip地址和端口号，不然就只能使用一个，另外一个也在使用就会报错，

phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.8',8080)) #绑定ip和端口号 ip/port是基础网络连接两端的通信的

phone.listen(5) #开机 接收客户端的数量，对客户端进行监听

print('starting....')while True: #是为了让服务器一直在运行，等待其他的客户端进行通信

conn,addr = phone.accept() #等待接收客户端的连接

print('电话线路是:',conn) # print('客户端的手机号是：',addr) #ip/端口

while True: #可以重复的进行通信，而不是进行一次通信就结束

try:#try....except...这个适用于win系统

#1024最大的接收范围。8192

data = conn.recv(1024) #接收客户端发来的消息

if not data:break #适用于linux系统

print('客户端发来的消息是',data.decode('utf-8'))

conn.send(data.upper())#将收到的消息以大写的形式去返回给对方

exceptException:breakconn.close()#关闭与当前连接的客户端的通信

phone.close() #关闭服务端程序

'''与tcp的三次握手：

当都是来了很多的网页，那么会有一个地方把这些网页全缓存起来，一个一个的访问，'''

tcp客户端:

importsocket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.8',8080))#客户端连接服务端的ip地址和端口号

whileTrue:

msg= input('>>:')if not msg:continuephone.send(msg.encode('utf-8'))#发送消息给服务端必须是要进行'编码'

data= phone.recv(1024)#接收服务端发来的消息

print(data.decode('utf-8')) #打印接收服务端的信息

phone.close()#当结束的交互的时候，进行客户端的程序的关闭

六、沾包的现象

让我们基于tcp先制作一个远程执行命令的程序(1：执行错误命令 2：执行ls 3：执行ifconfig)

注意注意注意：

res=subprocess.Popen(cmd.decode('utf-8'),

shell=True,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码

且只能从管道里读一次结果

from socket import *

importsubprocess

ip_port=('127.0.0.1',8080)

BUFSIZE=1024tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)whileTrue:

conn,addr=tcp_socket_server.accept()print('客户端',addr)whileTrue:

cmd=conn.recv(BUFSIZE)if len(cmd) == 0:breakact_res=subprocess.Popen(cmd.decode('utf-8'),shell=True,

stdout=subprocess.PIPE,

stdin=subprocess.PIPE,

stderr=subprocess.PIPE)

act_err=act_res.stderr.read()ifact_err:

ret=act_errelse:

ret=act_res.stdout.read()

conn.sendall(ret)

server

importsocket

BUFSIZE=1024ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)whileTrue:

msg=input('>>:').strip()if len(msg) == 0:continue

if msg == 'quit':breaks.send(msg.encode('utf-8'))

act_res=s.recv(BUFSIZE)print(act_res.decode('utf-8'),end='')

client

上述程序是基于tcp的socket，在运行时会发生粘包

让我们再基于udp制作一个远程执行命令的程序

#_*_coding:utf-8_*_

from socket import *

importsubprocess

ip_port=('127.0.0.1',9003)

bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)whileTrue:#收消息

cmd,addr=udp_server.recvfrom(bufsize)print('用户命令----->',cmd)#逻辑处理

res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)

err=res.stderr.read()print('错误====>',err)iferr:

back_msg=errelse:

back_msg=res.stdout.read()print('返回结果',back_msg)#发消息

udp_server.sendto(back_msg,addr)

udp_server.close()

server

from socket import *ip_port=('127.0.0.1',9003)

bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)whileTrue:

msg=input('>>:').strip()

udp_client.sendto(msg.encode('utf-8'),ip_port)

data,addr=udp_client.recvfrom(bufsize)print(data.decode('utf-8'),end='')

client

上述程序是基于udp的socket，在运行时永远不会发生粘包

七、什么是沾包

须知：只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来

首先需要掌握一个socket收发消息的原理

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

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

TCP(transport control protocol，传输控制协议)是面向连接的，面向流的，提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法(Nagle算法)，将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

UDP(user datagram protocol，用户数据报协议)是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头(消息来源地址，端口等信息)，这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容(直接回车)，那也不是空消息，udp协议会帮你封装上消息头，实验略

两种情况下会发生粘包。

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

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

1 #!/usr/bin/python

2 #-*- coding: UTF-8 -*-

3

4 importsocket5 importsubprocess6

7 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建tcp套接字

8

9 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)10 phone.bind(('127.0.0.8',8080)) #绑定ip和端口号

11 phone.listen(5) #开机 接收客户端的数量，对客户端进行监听

12 print('starting....')13

14 conn,addr = phone.accept() #等待接收客户端的连接

15 #print('双向连接:',conn) #

16 #print('客户端的手机号是：',addr) #ip/端口

17 data1 = conn.recv(1)18 data2 = conn.recv(1204)19 data3 = conn.recv(1204)20 print('第一个包',data1)21 print('第二个包',data2)22 print('第三个包',data3)23 conn.close() #关闭与当前连接的客户端的通信

24 phone.close() #关闭服务端程序

25

26 #在发包之前先发包的长度，通过包的长度收数据

27 '''

28 沾包是因为什么导致：29 tcp是面向流的向服务端传输，所以在传送多个包时，会一次性的全都给到第一个包，因为不会断开发送30 (前提是你发送的多个包的字节不超过你接收的最大字节数)。31 如果不想出现沾包的现象，可以给他做一个断点操作(time.sleep())32 客户端：33 s.send('hello')34 s.send('wolrd')35 服务端：36 data1 = conn.recv(1024)37 data2 = conn.recv(1024)38 print('第一个包',data1)39 print('第二个包',data2)40

41 结果：42 b‘hellowolrd’43 b''44 '''

45

46 '''

47 由于服务端的第一个接收包的字节数限制，无法接收到客户端的第二个包：48 这个问题是，在客户端发送的时候做一个断点的操作，当第一个包给到自己的缓存中，49 从客户端缓存-->服务端的缓存-->服务端输出结果。在服务端设定的两个接收的包，第一个接收的最大字节数是(1)50 这时收到客户端发来的包，只能收到一个字节，其余的都给到第二个服务端接收的数据包，第二个包的最大字节数是(1024)51 可以收完客户端传来的第一个包内容。第一个包结束了。52 客户端的第二个包还在断点中，断点过后：客户端-->客户端缓存-->服务端缓存-->服务端，53 这是已经没有多余的接收包的recv。所以就不会传输。54 如果要想接收客户端断点后的包，需要服务端多加一条recv接收55 服务端：56 data1 = conn.recv(1)57 data2 = conn.recv(1204)58 print('第一个包',data1)59 print('第一个包',data2)60 客户端：61 phone.send('helloword'.encode('utf-8'))62 time.sleep(2)63 phone.send('SB'.encode('utf-8'))64

65 结果：66 第一个包 b'h'67 第一个包 b'elloword'68 '''

69 '''

70 socket是在应用层去开发的，71 osi都有自己的head,72 socket写的都是软件，都是自己去开发的，所以我的软件连接到对方，所以需要定义自己的head,为应用数据模仿以太网定义自己的数据73

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

77 '''

server

importsocket,time

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.8',8080))#客户端连接服务端的ip地址和端口号

#msg = input('>>:')#if not msg:continue

phone.send('helloword'.encode('utf-8'))#发送消息给服务端必须是要进行'编码'

time.sleep(2)

phone.send('SB'.encode('utf-8'))#发送消息给服务端必须是要进行'编码'

phone.close()#当结束的交互的时候，进行客户端的程序的关闭

client

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一：为何tcp是可靠传输，udp是不可靠传输

基于tcp的数据传输请参考我的另一篇文章http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，因此不可靠

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失

八、沾包的解决方法

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack('i',1111111111111)

。。。。。。。。。

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

出现沾包的现象：

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

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

下面是两个解决的方法(最好使用第二种方式)：

importsocketimportsubprocessimportstruct

phone= socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建tcp套接字

phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.8',8080)) #绑定ip和端口号

phone.listen(5) #开机 接收客户端的数量，对客户端进行监听

print('starting....')whileTrue:

conn,addr= phone.accept() #等待接收客户端的连接

print('双向连接:',conn) # print('客户端的手机号是：',addr) #ip/端口

whileTrue:try:#try....except...这个适用于win系统

#1024字节最大的接收范围。8192

data = conn.recv(1024) #接收客户端发来的消息

cmd = subprocess.Popen(data.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

err_res=cmd.stderr.read()

out_res=cmd.stdout.read()

data_size= len(out_res) +len(err_res)

conn.send(struct.pack('i',data_size))#发送报头

conn.send(err_res)

conn.send(out_res)#发送数据部分

exceptException:breakconn.close()#关闭与当前连接的客户端的通信

phone.close() #关闭服务端程序

'''解决沾包的问题，使用struct模块

获取数据的长度，即：len(out_res) + len(err_res)

然后将获取的长度进行struct.pack进行装包，将数据发给客户端'''

使用struct模块的服务端

importsocket,timeimportstruct

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('192.168.238.130',8080))#客户端连接服务端的ip地址和端口号

whileTrue:#发送消息

msg = input('>>:')if not msg:continuephone.send(bytes(msg,encoding= 'utf-8'))#发送消息给服务端必须是要进行'编码'

#收报头

baotou = phone.recv(4) #获取的是一个bytes字节

print(len(baotou)) #得到的是bytes字节的长度是4

#因为获取的是一个元祖，而且只有一个值所以要通过索引提取出来，

data_size = struct.unpack('i',baotou)[0]print('报头的长度：',data_size)#收部分数据信息

recv_size =0

recv_data= b"" #需要做一个字符串的拼接

while recv_size

data= phone.recv(1024) #获取剩余的包里面的数据，拿到剩余的数据信息，给到data

recv_size += len(data) #将真实的数据长度给到recv_size

recv_data += data #将data中的数据给到recv_data

print(recv_data.decode('utf-8')) #打印接收服务端的信息

phone.close()#当结束的交互的时候，进行客户端的程序的关闭

'''解决沾包的问题，使用struct模块去解决，

1.收取报头的字节数，

2.收取数据信息

服务端：struct.pack获取的是一个元祖类型的，

所以客户端通过收取到的包，进行struct.unpack进行解包[0]，获取报头信息，

然后进行数据信息的提取，即上面的while循环'''

使用struct模块的客户端

#!/usr/bin/python#-*- coding: UTF-8 -*-

importsocket,timeimportstructimportjson

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('192.168.238.130',8080))#客户端连接服务端的ip地址和端口号

whileTrue:#发送消息

msg = input('>>:')if not msg:continuephone.send(bytes(msg,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)print('----->',head_dic)

data_size= head_dic['data_size']print('报头的长度：',data_size)#part3:收部分数据信息

recv_size =0

recv_data= b"" #需要做一个字符串的拼接

while recv_size

data= phone.recv(1024) #获取剩余的包里面的数据，拿到剩余的数据信息，给到data

recv_size += len(data) #将真实的数据长度给到recv_size

recv_data += data #将data中的数据给到recv_data

print(recv_data.decode('utf-8')) #打印接收服务端的信息

phone.close()#当结束的交互的时候，进行客户端的程序的关闭

'''解决沾包的问题，使用struct模块去解决，加上json模块

服务端：

收到客户端发来的命令。

1.发送报头长度

2.发送报头

3.发送数据信息

客户端：

1.收取报头长度

2.收取报头

3.收取数据信息'''

使用struct模块+json模块的服务端

#!/usr/bin/python#-*- coding: UTF-8 -*-

importsocketimportsubprocessimportstructimportjson

phone= socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建tcp套接字

phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.8',8080)) #绑定ip和端口号

phone.listen(5) #开机 接收客户端的数量，对客户端进行监听

print('starting....')whileTrue:

conn,addr= phone.accept() #等待接收客户端的连接

print('双向连接:',conn) # print('客户端的手机号是：',addr) #ip/端口

whileTrue:try:#try....except...这个适用于win系统

#1024字节最大的接收范围。8192

data = conn.recv(1024) #接收客户端发来的消息

#定制subprocess模块的使用

cmd = subprocess.Popen(data.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)#赋值：正确的内容，和错误的内容

err_res =cmd.stderr.read()

out_res=cmd.stdout.read()#获取数据信息的长度，

data_size = len(out_res) +len(err_res)#设置一个字典，定制报头，可以设置任意属性，比如：数据的名称，数据的长度，数据的目录,hashlib等等

head_dic = {'data_size':data_size}#将上面的字典转换成json格式的字符串

head_json =json.dumps(head_dic)#将json格式的字符串转换成bytes字节型

head_bytes = head_json.encode('utf-8')#part1:发送报头的长度

head_len =len(head_bytes)

conn.send(struct.pack('i',head_bytes))#part2:发送报头

conn.send(head_bytes)#part3:发送数据部分

conn.send(err_res)

conn.send(out_res)exceptException:breakconn.close()#关闭与当前连接的客户端的通信

phone.close() #关闭服务端程序

'''解决沾包的问题，使用struct模块

获取数据的长度，即：len(out_res) + len(err_res)

然后将获取的长度进行struct.pack进行装包，将数据发给客户端'''

使用struct模块+json模块的客户端

九、socketserver实现并发

socketserver里面有封装好的socket

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('192.168.16.35',8888))#客户端连接服务端的ip地址和端口号whileTrue:

msg= input('>>:')if not msg:continuephone.send(msg.encode('utf-8'))#发送消息给服务端必须是要进行'编码'data= phone.recv(1024)#接收服务端发来的消息

print(data) #打印接收服务端的信息

phone.close() #当结束的交互的时候，进行客户端的程序的关闭

socket_client

importsocketserverclass FtpServer(socketserver.BaseRequestHandler):#通信循环

def handle(self): #固定的函数名

print(self)print('sdffsaf')print(self.request)#accpet

whileTrue:

data= self.request.recv(1024)print(data.decode('utf-8'))

msg= input('>>：').strip()

self.request.send(msg.encode('utf-8'))if __name__ == '__main__':

obj= socketserver.ThreadingTCPServer(('192.168.16.35',8888),FtpServer)

obj.serve_forever()#连接循环

socketserver_server

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类(解决链接问题)和request类(解决通信问题)

server类：

request类：

继承关系:

以下述代码为例，分析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', )

self.client_address即客户端地址

基于socketserver实现的ftp上传功能

1 importsocket2 importstruct3 importjson4 importos5

6 classMYTCPClient:7 address_family = socket.AF_INET #基于网络通信地址

8

9 socket_type = socket.SOCK_STREAM #基于tcp协议

10

11 allow_reuse_address = False #12

13 max_packet_size = 8192 #收取最大字节数

14

15 coding='utf-8' #编码

16

17 def __init__(self, server_address, connect=True):18 self.server_address=server_address19 self.socket =socket.socket(self.address_family,20 self.socket_type)21 ifconnect:22 try:23 self.client_connect()24 except:25 self.client_close()26 raise

27

28 defclient_connect(self):29 self.socket.connect(self.server_address)30

31 defclient_close(self):32 self.socket.close()33

34 defrun(self):35 whileTrue:36 inp=input(">>:").strip()37 if not inp:continue

38 l=inp.split()39 cmd=l[0]40 ifhasattr(self,cmd):41 func=getattr(self,cmd)42 func(l)43

44

45 defput(self,args):46 cmd=args[0]47 filename=args[1]48 if notos.path.isfile(filename):49 print('file:%s is not exists' %filename)50 return

51 else:52 filesize=os.path.getsize(filename)53

54 head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}55 print(head_dic)56 head_json=json.dumps(head_dic)57 head_json_bytes=bytes(head_json,encoding=self.coding)58

59 head_struct=struct.pack('i',len(head_json_bytes))60 self.socket.send(head_struct)61 self.socket.send(head_json_bytes)62 send_size=063 with open(filename,'rb') as f:64 for line inf:65 self.socket.send(line)66 send_size+=len(line)67 print(send_size)68 else:69 print('upload successful')70

71

72

73

74 client=MYTCPClient(('127.0.0.45',8080))75

76 client.run()

ftp_socketserver_client

importsocketimportsocketserverimportstructimportjsonimportosclass FtpServer(socketserver.BaseRequestHandler): #通信循环

coding='utf-8'server_dir='F:\\file_upload'max_packet_size=1024BASE_DIR=os.path.dirname(os.path.abspath(__file__)) #获取父级路径

def handle(self): #固定的写法

print(self.request) #即accept :封装好了的

while True:#通信循环

data=self.request.recv(4) #获取报头

data_len=struct.unpack('i',data)[0] #报头长度

head_json=self.request.recv(data_len).decode(self.coding)#获取报头的长度

head_dic=json.loads(head_json) #传过来的是一个json格式的字符串，所以要通过json去解析

#print(head_dic)

cmd=head_dic['cmd']#拿到的字典，获取我的命令

if hasattr(self,cmd): #判断对象中，是否有我输入的命令

func=getattr(self,cmd) #获取命令

func(head_dic) #调用函数put

defput(self,args):

file_path=os.path.normpath(os.path.join(

self.BASE_DIR,#当前的父级目录

self.server_dir, #我设置文件夹的目录

args['filename'] #上传的文件

))

filesize= args['filesize'] #获取文件大小

recv_size =0print('----->', file_path)

with open(file_path,'wb') as f:while recv_size

recv_data= self.request.recv(self.max_packet_size)#以最大的字节数接收数据

f.write(recv_data) #将收到的数据写到f文件，即上面的文件句柄

recv_size += len(recv_data) #转成整数型

print('recvsize:%s filesize:%s' % (recv_size, filesize))#打印出我接收的数据大小和我上传的文件大小

#ThreadingTCPServer：基于tcp协议，

ftpserver=socketserver.ThreadingTCPServer(('192.168.16.35',8080),FtpServer)

ftpserver.serve_forever()#连接循环

ftp_socketserver_server