socket编程
什么是socket
- 定义
socket通常也称作套接字
，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过套接字
向网络发出请求或者应答网络请求。
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
-
socket和file的区别：
- file模块是针对某个指定文件进行【打开】【读写】【关闭】
- socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】
-
python相关
Python 提供了两个基本的 socket 模块。py2位大写，py3全部小写
第一个是 Socket，它提供了标准的 BSD Sockets API。
第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发
socket编程实现
- 流程图：

-
说明：
-
服务端
1.服务端需要导入socket模块，并创建套接字(实例化为一个对象)
import socket s = socket.socket()
2.绑定套接字s到本地IP和端口
ip_port = ('127.0.0.1',8080) s.bind(ip_port)3.监听连接
s.listen(0) PS：0表示缓冲区可挂起的连接数量 0表示不限制，1表示 可挂起一个，那么意思就是连接一个、挂起一个，第三个再连接的话，就无法连接，会超时
4.接收客户端建立连接的请求
conn,addr = s.accept() PS：conn为一个客户端和服务器建立的连接，addr为客户端ip
5.接收客户端的消息，并做相应处理
recv_data = conn.recv(1024) send_data = recv_data.upper() ＃将客户端发送的内容转换为大写，注意。python3里面客户端发送的都是二进制数据，python2里可以发送字符串
6.给客户端回消息
conn.send(send_data)
7.关闭连接
conn.close()
-
客户端
1.创建套接字import socket s = socket.socket()
2.连接服务端
ip_port = ('127.0.0.1',8080) s.connect(ip_port)3.给服务端发送消息
send_data = input('请输入: ') s.send(send_data.encode()) ＃注意py3发送的数据需要转换为二进制，不能直接发送字符串4.接收服务端消息，并打印
recv_data = s.recv(1024) print(recv_data.decode()) ＃服务端回应的是二进制，所以需要转换为字符串
5.关闭连接
s.close()
-
以上就是一个简单的客户端和服务端socket连接，并发送消息，读消息，回消息的过程，初学者可能一下子就懵了，请看下面的类比，
-
类比
通过上面的服务端和客户端的一个简单的交互，可以将其比作打电话，小明是服务端，小红是客户端
-
小明
- 小明为了接收电话，他首先得买个手机，此步骤类同创建socket套接字
- 小明有了手机，需要办一张电话卡，此步骤类同绑定套接字搭配监听的ip和端口
- 小明有了手机和电话卡，则手机开机，处于待机状态 此步骤类同监听客户端连接
- 当小红打电话进来之后，需要接电话，此类同于接收客户端建立连接的请求
-
小红
- 小红在和小明打电话前得有个通信工具等等，所以需要找到一部手机，类同创建一个套接字
- 小红需要知道小明的电话号码，并拨打电话，此步骤就等于客户端连接服务端
-
小红和小明交互
小红：你好 此时小红是发消息，小明此时处于收消息的状态
小明：你好 小明收到小红发的你好消息，做出回应，此时小明开始给小红发消息，小红处于收消息状态
最后小红收到了小明的消息，小明此时已经挂断电话，最后此次通信已断
注意此次通信只是一个简单的交互过程，交互完成之后，则先完成方会主动关系连接。如果要持续通信，请继续往下看
-
-
实现服务端保持连接，不受客户端断开而断开，并实现客户端和服务端持续交互过程
服务端
import socket
ip_port = ('127.0.0.1',8080)
s = socket.socket()
s.bind(ip_port)
s.listen(0)
while True: ＃此次while循环用于客户端断开连接之后，重新循环建立新连接
conn,addr = s.accept()
while True: ＃此while循环用于客户端和服务器持续交互
recv_data = conn.recv(1024)
if not recv_data: break ＃判断消息是否为空，当消息为空时，跳出循环，如果不判断的话，客户端那边如果主动断开连接，将会导致服务端处于一个不停的收消息的死循环中，因为连接已断开，处于非阻塞状态
send_data = recv_data.upper() ＃将客户消息转换为大写
conn.send(send_data)
conn.close()
客户端：
import socket
s = socket.socket()
ip_port = ('127.0.0.1',8080)
s.connect(ip_port)
while True:
send_data = input('请输入: ')
if send_data == 'exit':break
elif send_data == '':continue
s.send(send_data.encode())
recv_data = s.recv(1024)
print(recv_data.decode())
s.close()
运行服务端和客户端，效果如下：
请输入: hello HELLO 请输入: Jeck JECK 请输入: 123 123 请输入: 请输入: exit Process finished with exit code 0
socket模块功能
-
socket 类型
socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
-
参数一：地址簇
socket.AF_INET IPv4（默认）
socket.AF_INET6 IPv6
socket.AF_UNIX 只能够用于单一的Unix系统进程间通信 -
参数二：类型
socket.SOCK_STREAM 流式socket , for TCP （默认）
socket.SOCK_DGRAM 数据报式socket , for UDP
socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
socket.SOCK_SEQPACKET 可靠的连续数据包服务 -
参数三：协议
-
0 （默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议
-
socket方法
- sk.bind(address)
将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
-
sk.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5,这个值不能无限大，因为要在内核中维护连接队列 -
sk.setblocking(bool)
是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
- sk.accept()
接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
接收TCP 客户的连接（阻塞式）等待连接的到来- sk.connect(address)
连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
- sk.connect_ex(address)
同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
- sk.close()
关闭套接字
- sk.recv(bufsize[,flag])
接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略
- sk.recvfrom(bufsize[.flag])
与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
- sk.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
- sk.sendall(string[,flag])
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。内部通过递归调用send，将所有内容发送出去。
- sk.sendto(string[,flag],address)
将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
- sk.settimeout(timeout)
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
- sk.getpeername()
返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
- sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
- sk.fileno()
套接字的文件描述符
-
案例：模拟ssh
- 服务端：
import socket
import subprocess
ip_port = ('127.0.0.1',8080)
s = socket.socket()
s.bind(ip_port)
s.listen(0)
while True:
conn,addr = s.accept()
while True:
try:
recv_data = conn.recv(1024)
if not recv_data: break
p = subprocess.Popen(str(recv_data,encoding='utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) ＃执行shell命令，并将标准输出和错误输出放到缓冲区
res = p.stdout.read()
if not res:
send_data = p.stderr.read()
else:
send_data = res
data_size = len(send_data)
conn.send(send_data)
except Exception:
break
conn.close()
* 客户端
import socket
ip_port = ('127.0.0.1',8080)
s = socket.socket()
s.connect(ip_port)
while True:
send_data = input('>>: ')
if send_data == 'exit':exit()
elif not send_data:continue
s.send(bytes(send_data,encoding='utf-8'))
recv_data = s.recv(1024)
print(recv_data.decode())
s.close()
执行结果：
>>: df -h Filesystem Size Used Avail Use% Mounted on /dev/disk1 112G 51G 62G 45% / >>: netstat -lnt Active Internet connections Proto Recv-Q Send-Q Local Address Foreign Address (state) tcp4 0 0 172.16.23.42.57334 23.83.227.252.8023 ESTABLISHED tcp4 0 0 127.0.0.1.1080 127.0.0.1.57333 ESTABLISHED tcp4 0 0 127.0.0.1.57333 127.0.0.1.1080 ESTABLISHED tcp4 0 0 127.0.0.1.8080 127.0.0.1.57332 ESTABLISHED tcp4 0 0 127.0.0.1.57332 127.0.0.1.8080 ESTABLISHED tcp4 0 0 172.16.23.42.57328 223.252.199.7.80 CLOSE_WAIT tcp4 0 0 172.16.23.42.57269 163.177.72.143.993 ESTABLISHED tcp4 0 0 10.255.0.10.57047 203.130.45.175.9000 ESTABLISHED tcp4 27 0 172.16.23.42.57045 163.177.90.125.993 CLOSE_WAIT tcp4 0 0 172.16.23.42.56988 114.215.186.163.443 ESTABLISHED tcp4 27 0 172.16.23.42.56632 163.177.72.143.993 CLOSE_WAIT tcp4 0 0 10.255.0.10.56374 10.2 >>: route -n 0.7.12.22 ESTABLISHED tcp4 27 0 172.16.23.42.56229 163.177.90.125.993 CLOSE_WAIT tcp4 0 0 10.255.0.10.54889 203.130.45.175.9000 ESTABLISHED tcp4 0 0 10.255.0.10.54605 203.130.45.173.6929 ESTABLISHED tcp4 0 0 10.255.0.10.53228 10.20.7.12.22 ESTABLISHED tcp4 0 0 10.255.0.10.53122 203.130.45.175.9000 ESTABLISHED tcp4 0 0 172.16.23.42.52902 42.62.89.250.1194 ESTABLISHED tcp4 0 0 127.0.0.1.1337 127.0.0.1.52901 ESTABLISHED tcp4 0 0 127.0.0.1.52901 127.0.0.1.1337 ESTABLISHED tcp4 0 0 172.16.23.42.52899 17.172.232.10.5223 ESTABLISHED tcp4 0 0 172.16.23.42.52855 17.252.236.157.5223 ESTABLISHED tcp4 0 0 172.16.23.42.52790 223.252.199.6.6003 ESTABLISHED tcp4 0 0 172.16.23.42.50124 223.167.82.210.80 ESTABLISHED tcp4 0 0 172.16.23.42.50026 1
从结果中发现，执行df -h 返回正常结果，执行netstat -lnt返回了一半的结果，继续执行命令，仍然返回的是netstat －lnt的结果，这就发生了粘包现象
-
粘包解决
所谓粘包现象就是服务端把数据发过来之后，客户端接收时会按一定大小来接收，决定此操作的是s.recv(1024)，1024是每次接收的包大小，第一次没有接收完的话，第二次会继续接收原来的数据包，这就是粘包现象，解决办法就是，服务端在发送数据时，现告诉客户端本次数据的大小，然后再发送数据，客户端收到数据大小之后，循环接收数据，知道接收完成再终止此次循环，这样就可以拿到所有的数据，解决了粘包现象
- 服务端改造：
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#pyversion:python3.5
#owner:fuzj
import socket
import subprocess
ip_port = ('127.0.0.1',8080)
s = socket.socket()
s.bind(ip_port)
s.listen(0)
while True:
conn,addr = s.accept()
while True:
try:
recv_data = conn.recv(1024)
if not recv_data: break
p = subprocess.Popen(str(recv_data,encoding='utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
res = p.stdout.read()
if not res:
send_data = p.stderr.read()
else:
send_data = res
data_size = len(send_data) ＃计算数据大小
conn.send(bytes(str(data_size),encoding='utf-8')) ＃发送数据大小
res = conn.recv(1024) ＃接收客户端状态
conn.send(send_data) ＃发送数据
except Exception:
break
conn.close()
* 客户端改造：
import socket
ip_port = ('127.0.0.1',8080)
s = socket.socket()
s.connect(ip_port)
while True:
send_data = input('>>: ')
if send_data == 'exit':exit()
elif not send_data:continue
s.send(bytes(send_data,encoding='utf-8'))
recv_size = 0
data = b''
data_size = str(s.recv(1024),encoding='utf-8') ＃接收数据大小
s.send(bytes('ok',encoding='utf-8')) ＃发送此时的状态
while recv_size < int(data_size): ＃循环接收数据，直到接收完所有数据
recv_data = s.recv(1024)
data += recv_data
recv_size += len(recv_data)
print(str(data,encoding='utf-8'))
s.close()
运行结果：发现已经解决上述问题
>>: df -h Filesystem Size Used Avail Use% Mounted on /dev/disk1 112G 51G 62G 45% / >>: netstat -lnt Active Internet connections Proto Recv-Q Send-Q Local Address Foreign Address (state) tcp4 0 0 172.16.23.42.57476 223.252.199.7.80 CLOSE_WAIT tcp4 0 0 127.0.0.1.8080 127.0.0.1.57475 ESTABLISHED tcp4 0 0 127.0.0.1.57475 127.0.0.1.8080 ESTABLISHED tcp4 0 0 172.16.23.42.57474 223.252.199.7.80 LAST_ACK tcp4 0 0 172.16.23.42.57465 23.83.227.252.8023 ESTABLISHED tcp4 0 0 127.0.0.1.1080 127.0.0.1.57464 ESTABLISHED tcp4 0 0 127.0.0.1.57464 127.0.0.1.1080 ESTABLISHED tcp4 0 0 172.16.23.42.57461 23.83.227.252.8023 ESTABLISHED tcp4 0 0 127.0.0.1.1080 127.0.0.1.57460 ESTABLISHED tcp4 0 0 127.0.0.1.57460 127.0.0.1.1080 ESTABLISHED tcp4 0 0 172.16.23.42.57455 163.177.72.143.993 CLOSE_WAIT tcp4 0 0 10.255.0.10.57047 203.130.45.175.9000 ESTABLISHED tcp4 27 0 172.16.23.42.57045 163.177.90.125.993 CLOSE_WAIT tcp4 0 0 172.16.23.42.56988 114.215.186.163.443 ESTABLISHED tcp4 27 0 172.16.23.42.56632 163.177.72.143.993 CLOSE_WAIT tcp4 0 0 10.255.0.10.56374 10.20.7.12.22 ESTABLISHED tcp4 27 0 172.16.23.42.56229 163.177.90.125.993 CLOSE_WAIT tcp4 0 0 10.255.0.10.54889 203.130.45.175.9000 ESTABLISHED tcp4 0 0 10.255.0.10.54605 203.130.45.173.6929 ESTABLISHED tcp4 0 0 10.255.0.10.53228 10.20.7.12.22 ESTABLISHED tcp4 0 0 10.255.0.10.53122 203.130.45.175.9000 ESTABLISHED tcp4 0 0 172.16.23.42.52902 42.62.89.250.1194 ESTABLISHED tcp4 0 0 127.0.0.1.1337 127.0.0.1.52901 ESTABLISHED tcp4 0 0 127.0.0.1.52901 127.0.0.1.1337 ESTABLISHED tcp4 0 0 172.16.23.42.52899 17.172.232.10.5223 ESTABLISHED tcp4 0 0 172.16.23.42.52855 17.252.236.157.5223 ESTABLISHED tcp4 0 0 172.16.23.42.52790 223.252.199.6.6003 ESTABLISHED tcp4 0 0 172.16.23.42.50124 223.167.82.210.80 ESTABLISHED tcp4 0 0 172.16.23.42.50026 123.151.10.187.14000 ESTABLISHED tcp4 0 0 172.16.23.42.49612 163.177.90.125.993 ESTABLISHED tcp4 0 0 127.0.0.1.49871 127.0.0.1.49375 ESTABLISHED tcp4 0 0 127.0.0.1.49375 127.0.0.1.49871 ESTABLISHED tcp4 0 0 127.0.0.1.49871 127.0.0.1.49370 ESTABLISHED tcp4 0 0 127.0.0.1.49370 127.0.0.1.49871 ESTABLISHED tcp4 0 0 192.168.123.164.49282 112.90.83.61.443 ESTABLISHED
socketserver 实现支持多客户端
上述ssh模拟客户端只能支持一定数量的客户端，受s.listen(0)参数限制。下面可以实现支持多客户端操作
SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求

-
ThreadingTCPServer
ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互
-
实现步骤：
- 1.创建一个类，并继承SocketServer.BaseRequestHandler 的类
- 2.在新类中需要创建一个handle的方法
- 3.启动ThreadingTCPServer
代码如下：
import socketserver
import subprocess
class MyServer(socketserver.BaseRequestHandler): ＃继承
def handle(self): ＃handle方法。注意此时send和recv时调用的self.request方法
self.request.sendall(bytes('Welcome',encoding='utf-8'))
while True:
try:
recv_data = self.request.recv(1024)
if not recv_data: break
p = subprocess.Popen(str(recv_data, encoding='utf-8'), shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
res = p.stdout.read()
if not res:
send_data = p.stderr.read()
else:
send_data = res
if not send_data:
send_data = 'no output'.encode()
data_size = len(send_data)
self.request.send(bytes(str(data_size), encoding='utf-8'))
self.request.recv(1024)
self.request.send(send_data)
except Exception:
break
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer) ＃启动server
server.serve_forever()
PS:SocketServer.BaseRequestHandler类源码：其定义了三个方法:setup(),handle()he finish()
执行顺序为：setup(0-->handle()-->finish()
```
class BaseRequestHandler:
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.setup()
try:
self.handle()
finally:
self.finish()
def setup(self):
pass
def handle(self):
pass
def finish(self):
pass
SocketServer.BaseRequestHandler
```
- ThreadingTCPServer源码剖析

- 内部调用流程
- 启动服务端程序
- 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
- 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
- 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
- 当客户端连接到达服务器
- 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
- 执行 ThreadingMixIn.process_request_thread 方法
- 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）
来源：https://www.cnblogs.com/pycode/p/socket.html