socket套接字

首先在讲socket套接字前，先来看看网络协议

　　　　　　　　　　　　　　　　　　　　图1

在上图中，我们并没有看到socket的影子，那么socket是在哪里呢？

　　　

　　　　　　　　　　　　　　　　　　　　　　图2 

图2中可以看到socket的位置，它是介于运输层以及应用层中间

• 一、socket套接字是什么？

首先我们可以看到在图1看到，我们应用层想要将数据发送出去，那么就必须将包封好发给运输层，那么你要想运输层识别应用层的数据包，那么应用层就必须要遵循tcp/udp协议，而tcp/udp协议是一套很复杂的算法，我们不可能将整套算法都学会，那么在应用层和运输层就要有一个接口专门来做这个事情，也就是socket套接字，也就是说，你只要用socket这个接口来编程，那么你的数据就符合tcp/udp协议了。

总结：socket 是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，socket其实就是一个门面模式，它把复杂的TCP/IP协议隐藏在socket接口后面，对用户来说，一组简单的接口就是全部，让socket去组织数据，以符合指定的协议。
所以，我们无需深入了解TCP/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出来的程序就职遵循tcp/udp标准的。 

•  二、套接字的工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。

下面是套接字的工作流程图：

  

 

先从服务器端说起。服务器端先初始化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)

获取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是基于链接的，必须先启动服务端，再启动客户端连接服务端。

服务端

## socket tcp_server 端简单版
import socket

#   第一步：买手机
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)       ##  解释括号内容：（AF_INET基于网络协议（地址家族），SOCK_STREAM基于tcp协议）---->  代表基于网络的tcp协议

#   第二步：绑定一个手机号
phone.bind(('192.168.43.182',8080))     ##  括号内容： （IP地址，端口号）元祖的形式传过去，监听自己的IP地址

##  第三步，开机
phone.listen(5)         ##  括号内容： 允许有5台设备接入，这里调的是backlog（半连接池）的值

##  第四步，等电话，拿到有个（电话链接，对方的号码）
conn,addr = phone.accept()      ##  链接，地址（IP地址）

##  第五步，收消息
date_recv = conn.recv(1024)        ##  括号里的数字是最大接收的字节\
print(date_recv.decode('utf8'))         ##  输出结果：你好啊,客户端

##  第六步，发消息
conn.send('你好啊,客户端'.encode('utf8'))     ##  注意发过去的内容应该要转换成二进制形式

##  第七步，断开电话链接
conn.close()        ##  关闭三次握手，触发四次挥手

##  第八步，关机
phone.close()       ##  关闭socket

客户端

##  ftp_client 简单版
import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    ##  ( 网络协议，ftp协议 )

##  第一步，拨打电话
phone.connect(('192.168.43.182',8080))

##  第二步，发消息
phone.send('你好啊，服务端'.encode('utf8'))

##  第三步，收消息
date = phone.recv(1024)
print(date.decode('utf8'))      ##  输出结果：你好啊,客户端

##  第四步，关机
phone.close()

 

（二）补充：

　　1、socket底层工作原理：ftp的三次握手四次挥手

为什么是三次握手四次挥手，而不是三次挥手呢？

我们来看一下过程：

　　　　　　　　建立连接：client端第一次发起SYN请求连接（第1次握手），server端收到请求后回复ACK同意连接，并且向client端发起SYS请求连接，这两个信号实际上就并在一起发到client端了（第2次握手），随后client端收到信号后向server端发起ACK响应（第3次握手），至此三次握手结束，建立起双向链接。

　　　　　　　　断开链接：这里假设server端主动请求断开链接。server首先传输完数据，向client端发起FIN请求断开链接请求（第1次挥手），这个时候server端处于FIN_WAIT_1（主动断开连接）状态，client端收到请求后回复ACK同意server端断开链接（第2次挥手），此时server端处于FIN_WAIT_2（被动断开连接）状态，client端数据传输结束后发起FIN断开请求（第3次挥手），此时server端处于TIME_WAIT（即将断开链接）状态，server端收到请求后发起ACK同意断开链接（第4次挥手），至此四次挥手结束。由于第2次挥手后client端传输到server端的数据还没传完，所以这个时候client到server端的连接还不能断，所以第2次挥手和第3次挥手不能并成一步。

2、ftp的SYN洪水攻击

黑客会向服务器发起大量的SYN和服务端建立连接，但是又不发ACK回应，占用了服务端的backlog（半连接池），导致服务端资源被大量占用，如果这时有正常的用户想访问服务端就访问不进来了。

解决措施：1、增大backlog的容量。2、减少ACK回复次数。

3、ftp是可靠传输：收到消息都会回一个确认消息（ACK），如果对方没有收到ACK就会重新发消息 

4、一般情况下，服务器都是主动断开链接的一端，因为这样可以节省资源

 

（三）为ftp加入循环体：

from socket import *
port = ('192.168.43.182',8080)
back_log = 5
buffer_size = 1024

##  买手机
ftp_server = socket(AF_INET,SOCK_STREAM)

##  绑定手机号
ftp_server.bind(port)

##  开机
ftp_server.listen(back_log)
print('服务端已开启')

##  等电话
conn,addr = ftp_server.accept()

##  循环收发消息
while True:
    ##  收消息
    data = conn.recv(buffer_size)
    print('收到客户端发来的消息：',data.decode('utf8'))
    conn.send(data.upper())

##  挂电话
conn.close()

##  关机
ftp_server.close()

from socket import *
port = ('192.168.43.182',8080)
buffer_size = 1024

##  买手机
ftp_client = socket(AF_INET,SOCK_STREAM)

##  打电话
ftp_client.connect(port)

##  循环发收消息
while True:
    send_data = input('>>>:')
    ftp_client.send(send_data.encode('utf8'))       ##  发消息
    recv_data = ftp_client.recv(buffer_size)       ##  收消息
    print('收到服务端发来的消息：',recv_data.decode('utf8'))

##  关机
ftp_client.close()

 

（四）我们来看一下当客户端发送一个空消息会发生什么样的效果：

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　客户端

 

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　服务端

 为什么这里服务端都客户端都处于等待状态，不应该是客户端发送了消息，服务端收到回复客户端吗？

　　下面对socket收发消息的原理进行剖析：
内存分为 内核态 和 用户态，内核态存放操作系统，用户态存放应用软件缓存，也就是说，我们平时所用的软件都是通过操作系统才能操作硬件的。下面是关系图

 

从上图我们可以看得出，无论收消息还是发消息，都不是直接从网卡那里取的，而是通过操作系统来接收发送消息的，也就是说客户端发了一个空消息，并没有直接通过网卡发给服务端，而是先交给操作系统，但是由于操作系统接到的是空，所以就没有传给网卡了（这里的空不是空格而是回车，空格还是会发过去的），那么服务端在自己的操作系统读不到消息自然处于等待状态，客户端没有收到服务端发来的消息也处于等待状态。

 

（五）为服务端连接新设备加入循环体，允许同时和多台客户端连接

from socket import *
port = ('192.168.43.182',8080)
back_log = 5
buffer_size = 1024

ftp_server = socket(AF_INET,SOCK_STREAM)
ftp_server.bind(port)
ftp_server.listen(back_log)
while True:     ##  连接处加入循环体
    print('服务端开始运行')
    conn,addr = ftp_server.accept()
    try:        ##  捕捉异常，避免程序崩溃
        while True:
            data = conn.recv(buffer_size)
            print('收到客户端发来的消息：',data.decode('utf8'))
            conn.send(data.upper())

    except Exception:
        continue       ##  重新循环
    conn.close()
ftp_server.close()

from socket import *
port = ('192.168.43.182',8080)
buffer_size = 1024

##  买手机
ftp_client = socket(AF_INET,SOCK_STREAM)

##  打电话
ftp_client.connect(port)

##  循环发收消息
while True:
    send_data = input('>>>:')
    if not send_data:
        continue
    ftp_client.send(send_data.encode('utf8'))       ##  发消息
    print('客户端向服务端发送了消息')
    recv_data = ftp_client.recv(buffer_size)       ##  收消息
    print('收到服务端发来的消息：',recv_data.decode('utf8'))

##  关机
ftp_client.close()

 

（六）基于ftp实现远程操作命令行

###     ftp server 执行远程命令
from socket import *
import subprocess
ip_port = ('192.168.43.182',8080)
back_log = 5
buffer_size = 1024

ftp_server = socket(AF_INET,SOCK_STREAM)
ftp_server.bind(ip_port)
ftp_server.listen(back_log)

while True:     ##  连接循环
    print('服务端开始启动')
    conn,addr = ftp_server.accept()
    while True:     ##  通信循环
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:
                break
            print('收到客户端发来的命令：',cmd.decode('utf8'))
            res = subprocess.Popen(cmd.decode('utf8'),shell='True',
                             stderr = subprocess.PIPE,
                             stdout = subprocess.PIPE,
                             stdin = subprocess.PIPE
                             )
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
    conn.close()
ftp_server.close()

##  客户端发送命令
from socket import *
ip_port = ('192.168.43.182',8080)
buffer_size = 1024
ftp_client = socket(AF_INET,SOCK_STREAM)
ftp_client.connect(ip_port)

while True:     ##  通信循环
    cmd = input('>>>:')
    if not cmd:continue
    ftp_client.send(cmd.encode('utf8'))
    cmd_res = ftp_client.recv(buffer_size)
    print('执行的结果是：',cmd_res.decode('gbk'))
ftp_client.close()

 

• 四、基于UDP的套接字

udp是无链接的，先启动哪一端都不会报错

udp服务端

1 ss = socket()   #创建一个服务器的套接字
2 ss.bind()       #绑定服务器套接字
3 inf_loop:       #服务器无限循环
4     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
5 ss.close()                         # 关闭服务器套接字

udp客户端

cs = socket()   # 创建客户套接字
comm_loop:      # 通讯循环
    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)
cs.close()                      # 关闭客户套接字

udp套接字简单示例

from socket import *
ip_port = ('192.168.43.182',8080)
buffer_size = 1024

server = socket(AF_INET,SOCK_DGRAM)     ##  SOCK_DGRAM  ##  数据报，UDP协议

server.bind(ip_port)

while True:     ##  通信循环
    data,addr = server.recvfrom(buffer_size)    ##  收消息
    print(data.decode('utf8'))
    server.sendto(data.upper(),addr)        ##  发消息

server.close()

from socket import *
ip_port = ('192.168.43.182',8080)
buffer_size = 1024

client = socket(AF_INET,SOCK_DGRAM)

while True:     ##  通信循环
    data = input('>>>:')
    if not data:continue
    client.sendto(data.encode('utf8'),ip_port)      ##  发消息
    data,addr = client.recvfrom(buffer_size)        ##  收消息
    print(data.decode('utf8'))

client.close()

 

• 五、粘包现象

1、粘包现象？

我们先来看一下ftp中当recv（）接收的容量小于send（）的长度会有什么现象

通过上面的运行结果我们可以看出：服务端由于一次只能接收一个字节，虽然服务端接收了三次，但是接收到的内容都是客户端第一次发送的内容，也就是说，当发送的文件大于接收的最大容量时，那么一次接收仍然会将上一次未接收完的数据继续接收。

我们再来看一下基于udp协议的socket套接字会不会出现粘包现象

可以看的出来，UDP并不会出现粘包现象。

 

 2、什么是粘包？

须知：只有FTP才有粘包现象，UDP是没有粘包现象的

FTP发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。UDP是基于数据报的，每次发送消息都会给数据头封装内容和地址等信息，而收消息的时候，超过recvfrom的规定容量，则将超过的部分丢弃，所以就不会有粘包现象。

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

此外，发送方引起的粘包是由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协议会帮你封装上消息头，实验略

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

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

两种情况下会发生粘包。

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

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

 

3、解决粘包的处理方法

（1）比较low的方法

from socket import *
import subprocess
ip_port = ('192.168.43.182',8080)
back_log = 5
buffer_size = 1024
server = socket(AF_INET,SOCK_STREAM)
server.bind(ip_port)
server.listen(back_log)

while True:
    print('服务端开始启动')
    conn,addr = server.accept()
    while True:
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:break
            res = subprocess.Popen(cmd.decode('utf8'), shell='True',
                                         stderr = subprocess.PIPE,
                                         stdout = subprocess.PIPE,
                                         stdin = subprocess.PIPE
                                         )
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()

            if not cmd_res:     ##  返回结果有可能为空
                cmd_res = '执行成功'.encode('gbk')
            length = len(cmd_res.decode('gbk'))     ##  读取发送内容的长度
            conn.send(str(length).encode('gbk'))    ##  发送正文的长度，通知客户端
            data_return = conn.recv(buffer_size)

            conn.send(cmd_res)      ##  正文发送

        except Exception as e:
            print(e)
            break

from socket import *
ip_port = ('192.168.43.182',8080)
buffer_size = 1024
ftp_client = socket(AF_INET,SOCK_STREAM)
ftp_client.connect(ip_port)

while True:     ##  通信循环
    cmd = input('>>>:')
    if not cmd:continue
    if cmd == 'quit':break
    ftp_client.send(cmd.encode('utf8'))
    length = ftp_client.recv(buffer_size)       ##  接收正文的长度

    ftp_client.send('ready'.encode('utf8'))
    
    cmd_length = 0
    cmd_res = b''
    while cmd_length < int(length.decode('gbk')):       ##  开始处理粘包，循环读取，直到收完数据
        print('开始接收')
        cmd_res += ftp_client.recv(buffer_size)
        cmd_length = len(cmd_res.decode('gbk'))

    print('执行的结果是：',cmd_res.decode('gbk'))
ftp_client.close()

 

（2）高端的方法

from socket import *
import subprocess
import struct
ip_port = ('192.168.43.182',8080)
back_log = 5
buffer_size = 1024
server = socket(AF_INET,SOCK_STREAM)
server.bind(ip_port)
server.listen(back_log)

while True:
    print('服务端开始启动')
    conn,addr = server.accept()
    while True:
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:break
            res = subprocess.Popen(cmd.decode('utf8'), shell='True',
                                         stderr = subprocess.PIPE,
                                         stdout = subprocess.PIPE,
                                         stdin = subprocess.PIPE
                                         )
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()

            if not cmd_res:     ##  返回结果有可能为空
                cmd_res = '执行成功'.encode('gbk')
            length = len(cmd_res.decode('gbk'))     ##  读取发送内容的长度
            length = struct.pack('i',length)        ##  发送struct打包的数据长度，和正文一起发过去，数据长度占4个字节
            conn.send(length)
            conn.send(cmd_res)      ##  正文发送

        except Exception as e:
            print(e)
            break

from socket import *
import struct
ip_port = ('192.168.43.182',8080)
buffer_size = 1024
ftp_client = socket(AF_INET,SOCK_STREAM)
ftp_client.connect(ip_port)

while True:     ##  通信循环
    cmd = input('>>>:')
    if not cmd:continue
    if cmd == 'quit':break
    ftp_client.send(cmd.encode('utf8'))
    length = ftp_client.recv(4)       ##  接收struct传过来的长度
    length = struct.unpack('i',length)[0]      ##  返回的是一个元祖的形式，取第一个元素

    cmd_length = 0
    cmd_res = b''
    while cmd_length < length:       ##  开始处理粘包，循环读取，直到收完数据
        print('开始接收')
        cmd_res += ftp_client.recv(buffer_size)
        cmd_length = len(cmd_res.decode('gbk'))

    print('执行的结果是：',cmd_res.decode('gbk'))
ftp_client.close()

 

（3）更加高端的方法

我们平时都用过上传下载，上传下载都会得到文件的文件名，如果我们基于上面是做不到的，也就是说我们同样要将文件名和内容一起传输过去，怎么解决呢？

发送端：第一步，发送端首先将文件名、文件大小写成一个字典，再通过pickle将字典序列化成字节形式，做成一个报头长度。第二步，用struct将报头长度做成一个4个字节的固定长度。第三步，将固定长度，报头，正文一起发送过去。

接收端：拆包，第一步，首先接收（recv）4个长度字节，用struct取出得到一个元祖，取第一个元素得到一个报头长度。第二步，接收（recv）报头长度的数据，用pickle反序列化得到一个字典，提取出文件名和文件长度。第三步，通过文件长度循环接收（recv）正文。

 

4、补充：

recv在自己这端缓存区为空时，阻塞

recvfrom在自己这端缓存区为空时，收一个空？？？

解释：UDP在sendto时，会给数据报封装一个消息头（包括自己的IP地址，端口等等），所以就算是回车（也就是发一个空消息），也会封装一个消息头，所以本质上发送的就不是空消息了，recvfrom也不是收到一个空。

 

• 六、socketserver实现并发

1、原理：服务端用多线程或者多进程，实现并发效果

简单实例

import socketserver
ip_port = ('192.168.43.182',8080)
buffer_size = 1024
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print('conn is:',self.request)
        print('addr is:',self.client_address)

        while True:     ##  通信循环
            try:
                data = self.request.recv(buffer_size)
                if not data:break
                print('客户端%s发来的消息是：%s'%(self.client_address,data.decode('utf8')))
                self.request.send(data.upper())
            except Exception as e:
                print(e)
                break

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(ip_port,Myserver)
    server.serve_forever()

from socket import *
ip_port = ('192.168.43.182',8080)
buffer_size = 1024
client = socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)
while True:     ##  通信循环
    data = input('>>>:')
    if not data:continue
    client.send(data.encode('utf8'))
    data = client.recv(buffer_size)
    print(data.decode('utf8'))

 

 

2、循环分类：

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

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

server类：

request类：

继承关系:

 

 

 

3、源码分析：

以下述代码为例，分析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即一个链接  ------------>　　对应conn
3. 　　self.client_address即客户端地址 ---------------->    对应addr

基于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即客户端地址