python_socket应用

一客户端/服务端架构

即C/S架构，包括

1.硬件C/S架构(打印机)

2.软件C/S架构(web服务)

美好的愿望：

最常用的软件服务器是 Web 服务器。一台机器里放一些网页或 Web 应用程序,然后启动 服务。这样的服务器的任务就是接受客户的请求,把网页发给客户(如用户计算机上的浏览器),然 后等待下一个客户请求。这些服务启动后的目标就是“永远运行下去”。虽然它们不可能实现这样的 目标,但只要没有关机或硬件出错等外力干扰,它们就能运行非常长的一段时间。 

 

生活中的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服务端：

 

import  socket
#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()) #将收到的消息以大写的形式去返回给对方
        except Exception:
            break
    conn.close() #关闭与当前连接的客户端的通信
phone.close() #关闭服务端程序
'''
与tcp的三次握手：
当都是来了很多的网页，那么会有一个地方把这些网页全缓存起来，一个一个的访问，
'''

 

 tcp客户端:

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

while True:
    msg = input('>>:')
    if not msg:continue
    phone.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 *
import subprocess

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

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

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

    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break

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

        act_err=act_res.stderr.read()
        if act_err:
            ret=act_err
        else:
            ret=act_res.stdout.read()

        conn.sendall(ret)

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

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    act_res=s.recv(BUFSIZE)

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

 

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

 

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

#_*_coding:utf-8_*_
from socket import *
import subprocess

ip_port=('127.0.0.1',9003)
bufsize=1024

udp_server=socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    #收消息
    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)
    if err:
        back_msg=err
    else:
        back_msg=res.stdout.read()
    print('返回结果',back_msg)

    #发消息
    udp_server.sendto(back_msg,addr)
udp_server.close()

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

udp_client=socket(AF_INET,SOCK_DGRAM)


while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

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

 

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

 

七、什么是沾包

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

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

 

 

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

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

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

 

两种情况下会发生粘包。

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

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

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

import  socket
import subprocess

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....')

conn,addr = phone.accept() #等待接收客户端的连接
# print('双向连接:',conn) #
# print('客户端的手机号是：',addr) #ip/端口
data1 = conn.recv(1)
data2 = conn.recv(1204)
data3 = conn.recv(1204)
print('第一个包',data1)
print('第二个包',data2)
print('第三个包',data3)
conn.close() #关闭与当前连接的客户端的通信
phone.close() #关闭服务端程序

#在发包之前先发包的长度，通过包的长度收数据
'''
沾包是因为什么导致：
tcp是面向流的向服务端传输，所以在传送多个包时，会一次性的全都给到第一个包，因为不会断开发送
（前提是你发送的多个包的字节不超过你接收的最大字节数）。
如果不想出现沾包的现象，可以给他做一个断点操作（time.sleep()）
客户端：
s.send('hello')
s.send('wolrd')
服务端：
data1 = conn.recv(1024)
data2 = conn.recv(1024)
print('第一个包',data1)
print('第二个包',data2)

结果：
b‘hellowolrd’
b''
'''

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

结果：
第一个包 b'h'
第一个包 b'elloword'
'''
'''
socket是在应用层去开发的，
osi都有自己的head,
socket写的都是软件，都是自己去开发的，所以我的软件连接到对方，所以需要定义自己的head,为应用数据模仿以太网定义自己的数据

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

'''

import socket,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() #当结束的交互的时候，进行客户端的程序的关闭

 

拆包的发生情况

当发送端缓冲区的长度大于网卡的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.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包） 

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

import  socket
import subprocess
import struct
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....')
while True:
    conn,addr = phone.accept() #等待接收客户端的连接
    print('双向连接:',conn) #
    print('客户端的手机号是：',addr) #ip/端口
    while True:
        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)
            #发送数据部分
        except Exception:
            break
    conn.close() #关闭与当前连接的客户端的通信
phone.close() #关闭服务端程序
'''
解决沾包的问题，使用struct模块
获取数据的长度，即：len(out_res) + len(err_res)
然后将获取的长度进行struct.pack进行装包，将数据发给客户端
'''

import socket,time
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('192.168.238.130',8080))#客户端连接服务端的ip地址和端口号

while True:
    #发送消息
    msg = input('>>:')
    if not msg:continue
    phone.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_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循环
'''

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import socket,time
import struct
import json
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('192.168.238.130',8080))#客户端连接服务端的ip地址和端口号

while True:
    #发送消息
    msg = input('>>:')
    if not msg:continue
    phone.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_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.收取数据信息
'''

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

import  socket
import subprocess
import struct
import json
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....')
while True:
    conn,addr = phone.accept() #等待接收客户端的连接
    print('双向连接:',conn) #
    print('客户端的手机号是：',addr) #ip/端口
    while True:
        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)
        except Exception:
            break
    conn.close() #关闭与当前连接的客户端的通信
phone.close() #关闭服务端程序
'''
解决沾包的问题，使用struct模块
获取数据的长度，即：len(out_res) + len(err_res)
然后将获取的长度进行struct.pack进行装包，将数据发给客户端
'''

 

 九、socketserver实现并发

 socketserver里面有封装好的socket

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('192.168.16.35',8888))#客户端连接服务端的ip地址和端口号

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

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

import socketserver

class FtpServer(socketserver.BaseRequestHandler):#通信循环
    def handle(self): #固定的函数名
        print(self)
        print('sdffsaf')
        print(self.request)#accpet
        while True:
            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() #连接循环

 

 

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

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

server类：

request类：

继承关系:

 

 

 

以下述代码为例，分析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即客户端地址

 

基于socketserver实现的ftp上传功能

import socket
import struct
import json
import os

class MYTCPClient:
    address_family = socket.AF_INET #基于网络通信地址

    socket_type = socket.SOCK_STREAM #基于tcp协议

    allow_reuse_address = False #

    max_packet_size = 8192 #收取最大字节数

    coding='utf-8' #编码

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

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

        head_struct=struct.pack('i',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print('upload successful')




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

client.run()

import socket
import socketserver
import struct
import json
import os
class FtpServer(socketserver.BaseRequestHandler): #通信循环
    coding='utf-8'
    server_dir='F:\\file_upload'
    max_packet_size=1024
    BASE_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
    def put(self,args):
        file_path = os.path.normpath(os.path.join(
            self.BASE_DIR,   #当前的父级目录
            self.server_dir,  #我设置文件夹的目录
            args['filename']  #上传的文件
        ))
        filesize = args['filesize'] #获取文件大小
        recv_size = 0
        print('----->', file_path)
        with open(file_path, 'wb') as f:
            while recv_size < filesize:
                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()#连接循环

 

 

 

三次握手及四次挥手