【3.0】Socket层
【一】Scoket层在哪
- 还是用图来说话，一目了然。
【二】什么是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是同一台机器上不同进程或者线程的标识
【三】套接字发展史及分类
- 套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。
- 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。
- 一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。
- 这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是
- 基于文件型的
- 基于网络型的。
【1】基于文件类型的套接字家族
- 套接字家族的名字：
- AF_UNIX
- unix一切皆文件
- 基于文件的套接字调用的就是底层的文件系统来取数据
- 两个套接字进程运行在同一机器
- 可以通过访问同一个文件系统间接完成通信
【2】基于网络类型的套接字家族
- 套接字家族的名字：
- AF_INET
- (还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现
- 所有地址家族中，AF_INET是使用最广泛的一个
- python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
【三】套接字工作流程
- 一个生活中的场景。
- 你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。
- 等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。
【0】服务端流程
- 先从服务器端说起。
- 服务器端先初始化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
【1】服务端套接字函数
- s.bind() 绑定(主机,端口号)到套接字
- s.listen() 开始TCP监听
- s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
【2】客户端套接字函数
- s.connect() 主动初始化TCP服务器连接
- s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
【3】公共用途的套接字函数
- 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() 关闭套接字
【4】面向锁的套接字方法
- s.setblocking() 设置套接字的阻塞与非阻塞模式
- s.settimeout() 设置阻塞套接字操作的超时时间
- s.gettimeout() 得到阻塞套接字操作的超时时间
【5】面向文件的套接字的函数
- s.fileno() 套接字的文件描述符
- s.makefile() 创建一个与该套接字相关的文件
【四】基于TCP的套接字
【1】方法简介
- tcp是基于链接的
- 必须先启动服务端
- 然后再启动客户端去链接服务端
- tcp服务端
server = socket() #创建服务器套接字
server.bind() #把地址绑定到套接字
server.listen() #监听链接
inf_loop: #服务器无限循环
conn = server.accept() #接受客户端链接
comm_loop: #通讯循环
conn.recv()/conn.send() #对话(接收与发送)
conn.close() #关闭客户端套接字
server.close() #关闭服务器套接字(可选)
- tcp客户端
client = socket() # 创建客户套接字
client.connect() # 尝试连接服务器
comm_loop: # 通讯循环
client.send()/client.recv() # 对话(发送/接收)
client.close() # 关闭客户套接字
【2】打电话模型
- socket通信流程与打电话流程类似
- 我们就以打电话为例来实现一个low版的套接字通信
（1）服务端
import socket
ip_port = ('127.0.0.1', 9000) # 电话卡
BUFSIZE = 1024 # 收发消息的尺寸
servser = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 买手机
servser.bind(ip_port) # 手机插卡
servser.listen(5) # 手机待机
conn, addr = servser.accept() # 手机接电话
# print(conn)
# print(addr)
print('接到来自%s的电话' % addr[0])
msg = conn.recv(BUFSIZE) # 听消息,听话
print(msg, type(msg))
conn.send(msg.upper()) # 发消息,说话
conn.close() # 挂电话
servser.close() # 手机关机
（2）客户端
import socket
ip_port = ('127.0.0.1', 9000)
BUFSIZE = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect_ex(ip_port) # 拨电话
client.send('dream is handsome'.encode('utf-8')) # 发消息,说话(只能发送字节类型)
feedback = client.recv(BUFSIZE) # 收消息,听话
print(feedback.decode('utf-8'))
client.close() # 挂电话
【3】打电话模型升级版
- 加上链接循环与通信循环
（1）服务端改进版
import socket
# 电话卡
ip_port = ('127.0.0.1', 8081)
BUFSIZE = 1024
# 买手机
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 手机插卡
server.bind(ip_port)
# 手机待机
server.listen(5)
# 新增接收链接循环,可以不停的接电话
while True:
# 手机接电话
conn, addr = s.accept()
# print(conn)
# print(addr)
print('接到来自%s的电话' % addr[0])
# 新增通信循环,可以不断的通信,收发消息
while True:
# 听消息,听话
msg = conn.recv(BUFSIZE)
# 如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生
# if len(msg) == 0:break
print(msg, type(msg))
# 发消息,说话
conn.send(msg.upper())
# 挂电话
conn.close()
# 手机关机
server.close()
- 客户端改进版
import socket
ip_port = ('127.0.0.1', 8081)
BUFSIZE = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 拨电话
client.connect_ex(ip_port)
# 新增通信循环,客户端可以不断发收消息
while True:
msg = input('>>: ').strip()
if len(msg) == 0: continue
# 发消息,说话(只能发送字节类型)
client.send(msg.encode('utf-8'))
# 收消息,听话
feedback = client.recv(BUFSIZE)
print(feedback.decode('utf-8'))
# 挂电话
client.close()
【五】基于UDP的套接字
- udp是无链接的，先启动哪一端都不会报错
【1】方法简介
（1）UDP服务端
server = socket() #创建一个服务器的套接字
server.bind() #绑定服务器套接字
inf_loop: #服务器无限循环
conn = server.recvfrom()/conn.sendto() # 对话(接收与发送)
server.close() # 关闭服务器套接字
（2）UDP客户端
client = socket() # 创建客户套接字
comm_loop: # 通讯循环
client.sendto()/client.recvfrom() # 对话(发送/接收)
client.close() # 关闭客户套接字
【2】示例模版
（1）UDP服务端
import socket
ip_port = ('127.0.0.1', 9000)
BUFSIZE = 1024
udp_server_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server_client.bind(ip_port)
while True:
msg, addr = udp_server_client.recvfrom(BUFSIZE)
print(msg, addr)
udp_server_client.sendto(msg.upper(), addr)
（2）UDP客户端
import socket
ip_port = ('127.0.0.1', 9000)
BUFSIZE = 1024
udp_client_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
msg = input('>>: ').strip()
if not msg: continue
udp_client_server.sendto(msg.encode('utf-8'), ip_port)
back_msg, addr = udp_client_server.recvfrom(BUFSIZE)
print(back_msg.decode('utf-8'), addr)
【3】QQ聊天模拟
- qq聊天(由于udp无连接，所以可以同时多个客户端去跟服务端通信)
（1）UDP服务端
import socket
ip_port = ('127.0.0.1', 8081)
udp_server_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 买手机
udp_server_sock.bind(ip_port)
while True:
qq_msg, addr = udp_server_sock.recvfrom(1024)
print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' % (addr[0], addr[1], qq_msg.decode('utf-8')))
back_msg = input('回复消息: ').strip()
udp_server_sock.sendto(back_msg.encode('utf-8'), addr)
（2）UDP客户端
[1]客户端一
import socket
BUFSIZE = 1024
udp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
qq_name_dic = {
'狗哥alex': ('127.0.0.1', 8081),
'瞎驴': ('127.0.0.1', 8081),
'一棵树': ('127.0.0.1', 8081),
'武大郎': ('127.0.0.1', 8081),
}
while True:
qq_name = input('请选择聊天对象: ').strip()
while True:
msg = input('请输入消息,回车发送: ').strip()
if msg == 'quit': break
if not msg or not qq_name or qq_name not in qq_name_dic: continue
udp_client_socket.sendto(msg.encode('utf-8'), qq_name_dic[qq_name])
back_msg, addr = udp_client_socket.recvfrom(BUFSIZE)
print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' % (addr[0], addr[1], back_msg.decode('utf-8')))
udp_client_socket.close()
[2]客户端二
import socket
BUFSIZE = 1024
udp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
qq_name_dic = {
'狗哥alex': ('127.0.0.1', 8081),
'瞎驴': ('127.0.0.1', 8081),
'一棵树': ('127.0.0.1', 8081),
'武大郎': ('127.0.0.1', 8081),
}
while True:
qq_name = input('请选择聊天对象: ').strip()
while True:
msg = input('请输入消息,回车发送: ').strip()
if msg == 'quit': break
if not msg or not qq_name or qq_name not in qq_name_dic: continue
udp_client_socket.sendto(msg.encode('utf-8'), qq_name_dic[qq_name])
back_msg, addr = udp_client_socket.recvfrom(BUFSIZE)
print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' % (addr[0], addr[1], back_msg.decode('utf-8')))
udp_client_socket.close()
【六】基于TCP协议的简单套接字(打电话模型)
【1】初代(一次信息)
（1）服务端
import socket
# 【1】.买手机
# socket.SOCK_STREAM ：流式协议 ----> TCP协议 ----> 所有数据是一个整体
# socket.SOCK_DGRAM : 报协议 ----> 每一次数据都是单独一部分
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.绑定手机卡 ---> 192.168.1.50(本机IP地址)
# 0.0.0.0(任意IP地址) ---> 关联公网IP才会起作用 ----> 服务器用
# 127.0.0.1(本机固定IP地址) ---> 只有本机才能访问这个地址（测试用）
# 端口号：0-65535, 1024以前的都被系统保留使用
# phone.bind(('ip', port))
phone.bind(('127.0.0.1', 8080))
# 【3】.开机 -- 监听状态
# 5 ：指的是半连接池的大小
phone.listen(5)
print(f'服务器启动,开始监听ip:>>>{"127.0.0.1"},port:>>>{8080}')
# （1）服务器启动,开始监听ip:>>>127.0.0.1,port:>>>8080
# 【4】.等待电话链接请求:拿到电话链接 conn
# 返回的是双向通路 --- 操作系统维持链接
# conn ： 双向通路的链接
# client_addr ： 客户端的iP和端口
conn, client_addr = phone.accept()
print('这是服务端的conn:>>>', conn)
# （3）这是服务端的conn:>>> <socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 5249)>
print('这是服务端的client_addr:>>>', client_addr)
# （4）这是服务端的client_addr:>>> ('127.0.0.1', 5249)
# 【5】.接收消息
# 1024 ：最大接受的数据量为1024 bytes类型，收到的是bytes类型
data = conn.recv(1024)
# 对接受的二进制数据进行解码
print('从客户端接受的数据:>>>>', data.decode('utf-8'))
# （5）从客户端接受的数据:>>>> is running for 发送信息
# 发消息 返回消息状态等信息
conn.send(data.upper())
# 【6】.关闭连接(必选的回收资源操作) conn
# 完成后断开连接
conn.close()
# 【7】.关机(可选操作)
phone.close()
（2）客户端
import socket
# 【1】.买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.拨通服务端电话
# connect(('服务端ip', 服务端端口))
phone.connect(('127.0.0.1', 8080))
# （2）
# 【3】.通信
# send(二进制数据类型)
phone.send('is running for 发送信息'.encode('utf8'))
# 接受服务端返回的数据
data = phone.recv(1024)
# 打印返回的消息 解码
print(data.decode('utf8'))
# （6）IS RUNNING FOR 发送信息
# 【4】.关闭连接(必选的回收资源操作)
phone.close()
（3）问题
- 信息只能传输一次，无法做到持续发送信息
【2】二代(多次信息-循环结束条件)
（1）服务端
import socket
# 【1】.买手机
# socket.SOCK_STREAM ：流式协议 ----> TCP协议 ----> 所有数据是一个整体
# socket.SOCK_DGRAM : 报协议 ----> 每一次数据都是单独一部分
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.绑定手机卡 ---> 192.168.1.50(本机IP地址)
# 0.0.0.0(任意IP地址) ---> 关联公网IP才会起作用 ----> 服务器用
# 127.0.0.1(本机固定IP地址) ---> 只有本机才能访问这个地址（测试用）
# 端口号：0-65535, 1024以前的都被系统保留使用
# phone.bind(('ip', port))
phone.bind(('127.0.0.1', 8080))
# 【3】.开机 -- 监听状态
# 5 ：指的是半连接池的大小
phone.listen(5)
print(f'服务器启动,开始监听ip:>>>{"127.0.0.1"},port:>>>{8080}')
# （1）服务器启动,开始监听ip:>>>127.0.0.1,port:>>>8080
# 【4】.等待电话链接请求:拿到电话链接 conn
# 返回的是双向通路 --- 操作系统维持链接
# conn ： 双向通路的链接
# client_addr ： 客户端的iP和端口
conn, client_addr = phone.accept()
print('这是服务端的conn:>>>', conn)
# （3）这是服务端的conn:>>> <socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 5249)>
print('这是服务端的client_addr:>>>', client_addr)
# （4）这是服务端的client_addr:>>> ('127.0.0.1', 5249)
while True:
# 【5】.接收消息
# 1024 ：最大接受的数据量为1024 bytes类型，收到的是bytes类型
data = conn.recv(1024)
if data.decode('utf-8') == 'q':
break
# 对接受的二进制数据进行解码
print('从客户端接受的数据:>>>>', data.decode('utf-8'))
# （5）从客户端接受的数据:>>>> is running for 发送信息
# 发消息 返回消息状态等信息
conn.send(data.upper())
# 【6】.关闭连接(必选的回收资源操作) conn
# 完成后断开连接
conn.close()
# 【7】.关机(可选操作)
phone.close()
（2）客户端
import socket
# 【1】.买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.拨通服务端电话
# connect(('服务端ip', 服务端端口))
phone.connect(('127.0.0.1', 8080))
# （2）
while True:
# 【3】.通信
# send(二进制数据类型)
msg = input('请输入需要发送的消息:>>>>').strip()
phone.send(f'{msg}'.encode('utf8'))
# 加入结束条件强制结束通信
if msg == 'q':
break
# 接受服务端返回的数据
data = phone.recv(1024)
# 打印返回的消息 解码
print(data.decode('utf8'))
# （6）IS RUNNING FOR 发送信息
# 【4】.关闭连接(必选的回收资源操作)
phone.close()
【3】三代(多次信息-信息为空)
（1）服务端
import socket
# 【1】.买手机
# socket.SOCK_STREAM ：流式协议 ----> TCP协议 ----> 所有数据是一个整体
# socket.SOCK_DGRAM : 报协议 ----> 每一次数据都是单独一部分
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.绑定手机卡 ---> 192.168.1.50(本机IP地址)
# 0.0.0.0(任意IP地址) ---> 关联公网IP才会起作用 ----> 服务器用
# 127.0.0.1(本机固定IP地址) ---> 只有本机才能访问这个地址（测试用）
# 端口号：0-65535, 1024以前的都被系统保留使用
# phone.bind(('ip', port))
phone.bind(('127.0.0.1', 8080))
# 【3】.开机 -- 监听状态
# 5 ：指的是半连接池的大小
phone.listen(5)
print(f'服务器启动,开始监听ip:>>>{"127.0.0.1"},port:>>>{8080}')
# （1）服务器启动,开始监听ip:>>>127.0.0.1,port:>>>8080
# 【4】.等待电话链接请求:拿到电话链接 conn
# 返回的是双向通路 --- 操作系统维持链接
# conn ： 双向通路的链接
# client_addr ： 客户端的iP和端口
conn, client_addr = phone.accept()
print('这是服务端的conn:>>>', conn)
# （3）这是服务端的conn:>>> <socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 5249)>
print('这是服务端的client_addr:>>>', client_addr)
# （4）这是服务端的client_addr:>>> ('127.0.0.1', 5249)
while True:
# 【5】.接收消息
# 1024 ：最大接受的数据量为1024 bytes类型，收到的是bytes类型
data = conn.recv(1024)
if data.decode('utf-8') == 'q':
break
# 对接受的二进制数据进行解码
print('从客户端接受的数据:>>>>', data.decode('utf-8'))
# （5）从客户端接受的数据:>>>> is running for 发送信息
# 发消息 返回消息状态等信息
conn.send(data.upper())
# 【6】.关闭连接(必选的回收资源操作) conn
# 完成后断开连接
conn.close()
# 【7】.关机(可选操作)
phone.close()
（2）客户端
import socket
# 【1】.买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.拨通服务端电话
# connect(('服务端ip', 服务端端口))
phone.connect(('127.0.0.1', 8080))
# （2）
while True:
# 【3】.通信
# send(二进制数据类型)
msg = input('请输入需要发送的消息:>>>>').strip()
phone.send(f'{msg}'.encode('utf8'))
if len(msg) == 0: continue
# 加入结束条件强制结束通信
if msg == 'q':
break
# 接受服务端返回的数据
data = phone.recv(1024)
# 打印返回的消息 解码
print(data.decode('utf8'))
# （6）IS RUNNING FOR 发送信息
# 【4】.关闭连接(必选的回收资源操作)
phone.close()
（3）问题
- 客户端强制终止程序时，服务端会产生一系列问题
【4】四代(检测用户信息为空)
（1）服务端
import socket
# 【1】.买手机
# socket.SOCK_STREAM ：流式协议 ----> TCP协议 ----> 所有数据是一个整体
# socket.SOCK_DGRAM : 报协议 ----> 每一次数据都是单独一部分
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.绑定手机卡 ---> 192.168.1.50(本机IP地址)
# 0.0.0.0(任意IP地址) ---> 关联公网IP才会起作用 ----> 服务器用
# 127.0.0.1(本机固定IP地址) ---> 只有本机才能访问这个地址（测试用）
# 端口号：0-65535, 1024以前的都被系统保留使用
# phone.bind(('ip', port))
phone.bind(('127.0.0.1', 8080))
# 【3】.开机 -- 监听状态
# 5 ：指的是半连接池的大小
phone.listen(5)
print(f'服务器启动,开始监听ip:>>>{"127.0.0.1"},port:>>>{8080}')
# （1）服务器启动,开始监听ip:>>>127.0.0.1,port:>>>8080
# 【4】.等待电话链接请求:拿到电话链接 conn
# 返回的是双向通路 --- 操作系统维持链接
# conn ： 双向通路的链接
# client_addr ： 客户端的iP和端口
conn, client_addr = phone.accept()
print('这是服务端的conn:>>>', conn)
# （3）这是服务端的conn:>>> <socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 5249)>
print('这是服务端的client_addr:>>>', client_addr)
# （4）这是服务端的client_addr:>>> ('127.0.0.1', 5249)
while True:
# 【5】.接收消息
# 1024 ：最大接受的数据量为1024 bytes类型，收到的是bytes类型
try:
data = conn.recv(1024)
if len(data) == 0:
# 在 unix 系统里，一旦data收到的内容为空
# 就意味着一种异常行为：客户端非法断开了链接
break
if data.decode('utf-8') == 'q':
break
# 对接受的二进制数据进行解码
print('从客户端接受的数据:>>>>', data.decode('utf-8'))
# （5）从客户端接受的数据:>>>> is running for 发送信息
# 发消息 返回消息状态等信息
conn.send(data.upper())
except Exception as e:
break
# 【6】.关闭连接(必选的回收资源操作) conn
# 完成后断开连接
conn.close()
# 【7】.关机(可选操作)
phone.close()
（2）客户端
import socket
# 【1】.买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.拨通服务端电话
# connect(('服务端ip', 服务端端口))
phone.connect(('127.0.0.1', 8080))
# （2）
while True:
# 【3】.通信
# send(二进制数据类型)
msg = input('请输入需要发送的消息:>>>>').strip()
phone.send(f'{msg}'.encode('utf8'))
if len(msg) == 0: continue
# 加入结束条件强制结束通信
if msg == 'q':
break
# 接受服务端返回的数据
data = phone.recv(1024)
# 打印返回的消息 解码
print(data.decode('utf8'))
# （6）IS RUNNING FOR 发送信息
# 【4】.关闭连接(必选的回收资源操作)
phone.close()
【5】五代(完善版)
（1）说明
- 服务端应该满足的特点
- 服务端一直提供服务
- 在建立连接与结束链接之间再加上一层 循环
- 服务端并发提供服务
- 服务端一直提供服务
（2）服务端
import socket
# 【1】.买手机
# socket.SOCK_STREAM ：流式协议 ----> TCP协议 ----> 所有数据是一个整体
# socket.SOCK_DGRAM : 报协议 ----> 每一次数据都是单独一部分
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.绑定手机卡 ---> 192.168.1.50(本机IP地址)
# 0.0.0.0(任意IP地址) ---> 关联公网IP才会起作用 ----> 服务器用
# 127.0.0.1(本机固定IP地址) ---> 只有本机才能访问这个地址（测试用）
# 端口号：0-65535, 1024以前的都被系统保留使用
# phone.bind(('ip', port))
phone.bind(('127.0.0.1', 8080))
# 【3】.开机 -- 监听状态
# 5 ：指的是半连接池的大小
phone.listen(5)
print(f'服务器启动,开始监听ip:>>>{"127.0.0.1"},port:>>>{8080}')
# （1）服务器启动,开始监听ip:>>>127.0.0.1,port:>>>8080
# 【4】.等待电话链接请求:拿到电话链接 conn
# ---- 加上链接循环 ----> 循环建链接
while True:
# 返回的是双向通路 --- 操作系统维持链接
# conn ： 双向通路的链接
# client_addr ： 客户端的iP和端口
conn, client_addr = phone.accept()
# （3）这是服务端的conn:>>> <socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 5249)>
print('这是服务端的client_addr:>>>', client_addr)
# （4）这是服务端的client_addr:>>> ('127.0.0.1', 5249)
while True:
# 【5】.接收消息
# 1024 ：最大接受的数据量为1024 bytes类型，收到的是bytes类型
try:
data = conn.recv(1024)
if len(data) == 0:
# 在 unix 系统里，一旦data收到的内容为空
# 就意味着一种异常行为：客户端非法断开了链接
break
if data.decode('utf-8') == 'q':
break
# 对接受的二进制数据进行解码
print('从客户端接受的数据:>>>>', data.decode('utf-8'))
# （5）从客户端接受的数据:>>>> is running for 发送信息
# 发消息 返回消息状态等信息
conn.send(data.upper())
except Exception as e:
break
# 【6】.关闭连接(必选的回收资源操作) conn
# 完成后断开连接
conn.close()
# 【7】.关机(可选操作)
phone.close()
（3）客户端
import socket
# 【1】.买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 【2】.拨通服务端电话
# connect(('服务端ip', 服务端端口))
phone.connect(('127.0.0.1', 8080))
# （2）
while True:
# 【3】.通信
# send(二进制数据类型)
msg = input('请输入需要发送的消息:>>>>').strip()
phone.send(f'{msg}'.encode('utf8'))
if len(msg) == 0: continue
# 加入结束条件强制结束通信
if msg == 'q':
break
# 接受服务端返回的数据
data = phone.recv(1024)
# 打印返回的消息 解码
print(data.decode('utf8'))
# （6）IS RUNNING FOR 发送信息
# 【4】.关闭连接(必选的回收资源操作)
phone.close()
【七】基于UDP协议的简单套接字
【1】UDP协议
- UDP协议 -----> 数据报协议
【2】空数据的处理
- TCP协议是水流式协议：传入的数据不能为空，因为水是一直流的，在传输过程中不会对数据进行操作
- UDP协议是数据报协议：传入的数据可为空，在传输过程中UDP会对数据进行内部的拼接和处理
【3】断开链接的影响
- TCP协议是水流式协议：在建立链接过程中，服务端和客户端的链接是一直存在的，断开一方都会对另一方造成影响
- UDP协议是数据报协议：在建立链接过程中，是通过解析对方数据中的ip和端口，再向另一方返回数据的，所以一方发生问题并不会影响到另一方
【4】模版
（1）服务端
import socket
# 数据报协议 ------> UDP 协议
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 建立链接 ip + 端口
server.bind(('127.0.0.1', 8082))
# 接收到服务端传进来的消息
# 接受收到的 ip 和 端口 对于UDP 来说是非常重要的 因为UDP协议没有建立链接操作
# 返回信息就需要用到拿到的ip和端口
msg_data, clint_addr = server.recvfrom(1024)
msg_data = msg_data.decode("utf8")
IP = clint_addr[0]
PORT = clint_addr[1]
print(f'客户端提供的拿到的消息:>>>>{msg_data}')
print(f'客户端提供的拿到的IP:>>>>{IP}')
print(f'客户端提供的拿到的端口:>>>>{PORT}')
while True:
# 建立链接，返回消息内容
return_msg = msg_data.upper().encode('utf-8')
server.sendto(return_msg, clint_addr)
# 关闭服务
server.close()
（2）客户端
import socket
# 建立socket对象
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
# 向服务端发送消息
msg = input('msg:>>>>').strip()
server.sendto(f'{msg}'.encode('utf8'), ('127.0.0.1', 8082))
# 接受服务器返回的消息
data_msg, server_addr = server.recvfrom(1024)
msg_data = data_msg.decode("utf8")
IP = server_addr[0]
PORT = server_addr[1]
print(f'服务端返回拿到的消息:>>>>{data_msg}')
print(f'服务端返回拿到的IP:>>>>{IP}')
print(f'服务端返回拿到的端口:>>>>{PORT}')
# 关闭链接
server.close()
【5】应用(聊天室)
- 客户端输入消息
- 将数据上传到服务器
- 服务器解析收到的数据，根据接收到的数据进行返回数据
【补充】端口冲突问题
【1】问题引入
- 有的同学在重启服务端时可能会遇到
- 这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址
【2】解决方法
（1）方法一
#加入一条socket配置，重用ip和端口
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))
（2）方法二
- 发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决
vi /etc/sysctl.conf
- 编辑文件，加入以下内容
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
-
参数说明
net.ipv4.tcp_syncookies = 1 # 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭； net.ipv4.tcp_tw_reuse = 1 # 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭； net.ipv4.tcp_tw_recycle = 1 # 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。 net.ipv4.tcp_fin_timeout # 修改系統默认的 TIMEOUT 时间 -
然后执行 /sbin/sysctl -p 让参数生效。
/sbin/sysctl -p
本文来自博客园，作者：Chimengmeng，转载请注明原文链接：https://www.cnblogs.com/dream-ze/p/17968020
