一、CS架构
server端要求：
1、力求一直提供服务
2、一个server端socket绑定到一个唯一的IP+端口地址，多个客户端发起connect各带一个conn套接字通道 去连接服务端。
二、socket
socket就是为了完成C/S架构软件的开发，但是如果是C/S架构的软件就一定需要解决双方通信问题。
若基于网络通信就需要了解复杂的网络协议 TCP/IP协议，于是socket出现了；
1、什么是sock？
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的
2、socket分类
（1）基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信（Linux操作系统）
（2）基于网络类型的套接字家族 AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)（ssh,nginx,mysql）
3、soket套接字的工作流程
服务端：得到Socket对象，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。
客户端：客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。
C/S交换阶段：客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
4、基于TCP协议的套接字
(1)实现一个简单的套接字
import socket phon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建一个基于网络的（socket.AF_INET）tcp协议传输的sock（socket.SOCK_STREAM） phon.bind(("127.0.0.1",8090)) #把创建好的套接字，绑定在 唯一的IP和端口上。 phon.listen(80) #开始监听 conn,addr=phon.accept() #等待客户端通过TCP三次握手发起 连接 (把某个连接，和连接的对象分解赋值给 conn，和addr) data=conn.recv(1024) #接收 连接进来的某一个客户端，发送过来的消息 print("接受到来自客户端发来的消息",data) conn.send(data.upper()) #发送接受的消息 给某一个客户端
执行结果
服务端：
客户端：
（2）循环通信的套接字
虽然上述已经实现了一个简单的套接字，但服务端的 socket 只能接受 1个客户端的连接，1次通信后就结束了。
所以可以利用while..Ture构建一个通信循环，实现1个客户端可以和服务端一直通信（循环通信）
服务端：
import socket phon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建一个基于网络的（socket.AF_INET）tcp协议传输的sock（socket.SOCK_STREAM） phon.bind(("127.0.0.1",8090)) #把创建好的套接字，绑定在 唯一的IP和端口上。 phon.listen(80) #开始监听 conn,addr=phon.accept() #等待客户端通过TCP三次握手发起 连接 (把某个连接，和连接的对象分解赋值给 conn，和addr) while True: #循环通信-----------------------------------------------------------------------> data=conn.recv(1024) #接收 连接进来的某一个客户端，发送过来的消息 print("接受到来自客户端发来的消息",data) conn.send(data.upper()) #发送接受的消息 给某一个客户端 conn.close() phon.close()
客户端：
import socket phon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phon.connect(('127.0.0.1',8090)) #客户端的phon.connect正好对于服务端的phon1.accept() while True: #循环通信----------------------------------------------------------------------------------->> mes=input('---->: '.strip()) if not mes: continue res=phon.send(mes.encode('utf-8')) #发消息 data=phon.recv(1024) #收消息 print(data.decode('gbk')) phon.close()
3、循环连接的套接字
由于1客户端连接到服务端就会建立一个连接通道（电话线），但是如果客户端关闭了这个通道，服务端的conn.recv(1024）方法无法接收到客户端的数据。
在Windows平：台sock服务端就会报错，抛出异常；
在Linux平台：服务端循环收空数据，陷入死循环；
解决方法：建连接循环，捕捉到客户端关闭了连接通道，服务端继续accept()等待下一次连接；
tcp服务端
import socket import subprocess iphon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #（建立一个socket对象） iphon.bind(('127.0.0.1',8080)) #绑定到 IP+端口上 成为唯一的socket iphon.listen(5) #设置连接池的个数 print('starting........') while True: #连接循环------------------------------------------------------------------> conn,addr=iphon.accept() #等待电话连接 print('电话线路是',conn) print('客户手机号:',addr) while True: #通信循环 发送和接收 try: data=conn.recv(1024) #接受消息 最大从内存里接受1024MB数据 print('客户端发来的消息是%s'%data) data=data.decode('utf-8') #从客户端发来的数据是经过编码的字节数据 所以需要解码 成Unicode res=subprocess.Popen( data, shell=True, stdout=subprocess.PIPE) #解码后传进subprocess.Popen去cmd执行 data1 = res.stdout.read().decode('gbk') #cmd是gbk编码所以需要gbk解码 print(data1) #打印解码后的结果 data1=data1.encode('gbk') #编码 conn.send(data1) #发送消息 #编码后再传输给客户端 except Exception: break conn.close() iphon.close() #
TCP客户端
import socket phon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phon.connect(('127.0.0.1',8080)) #客户端的phon.connect正好对于服务端的phon1.accept() while True: #循环通信 mes=input('---->: '.strip()) if not mes: continue res=phon.send(mes.encode('utf-8')) #发消息 data=phon.recv(1024) #收消息 print(data.decode('gbk')) phon.close()
4、由于客户端连接服务端断开后，仍然存在四次挥手的time_wait状态在占用地址（所以 服务器高并发情况下会有大量的time_wait状态的需要优化）
import socket phon=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建一个基于网络的（socket.AF_INET）tcp协议传输的sock（socket.SOCK_STREAM） phon.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #处理客户端连接断开，后的time_out-------------------------> phon.bind(("127.0.0.1",8090)) #把创建好的套接字，绑定在 唯一的IP和端口上。 phon.listen(80) #开始监听 conn,addr=phon.accept() #等待客户端通过TCP三次握手发起 连接 (把某个连接，和连接的对象分解赋值给 conn，和addr) while True: #循环通信 data=conn.recv(1024) #接收 连接进来的某一个客户端，发送过来的消息 print("接受到来自客户端发来的消息",data) conn.send(data.upper()) #发送接受的消息 给某一个客户端 conn.close() phon.close()
5、1个服务端套接字 和 多个客户端 套接字通信（socketserver模块实现并发 ）
循环通信：解决了客户端和服务端可以持续发消息。
连接循环：解决了客户端 突然断开和服务端建立的通道，服务端无法继续和这个关闭了这个通道通信，抛异常退出的问题；
但此时的服务端套接字 还只能和1客户端建立通信管道，无法同时接收 多个客户端套接字的连接，实现并发；
socketserve模块执行流程：
#1、接收多个连接：一个客户端连接建立之后，服务端开一个socketserver.ThreadingTCPServe线程 实例化出一个FTP类的对象。
#2、自动执行Ftp对象handle方法
#3、自动执行对象 handle方法，进入通信循环，self.request就是这个连接客户端的套接字对象。
import socketserver #socketserver()模块基于 线程实现并发 class FTP(socketserver.BaseRequestHandler):#继承socketserver.BaseRequestHandler类 def handle(self): #2、自动执行对象 handle方法，进入通信循环， #3 self.request就是这个连接客户端的套接字对象 print('==========>') while True: #4、进入循环通信 data=self.request.recv(1024) #接收数据方法：self.request.recv(1024) print(data) self.request.send(data) #发送数据方法：self.request.send(data) if __name__ == '__main__': obj=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FTP)#1、接受多个连接：一个客户端连接建立之后，服务端开一个socketserver.ThreadingTCPServe线程 实 例化出一个FTP对象 obj.serve_forever() obj.serve_forever() #等于accpet()永远接收连接
