网络编程（二）

2022-04-16 02:00:23 阅读：172 来源： 互联网

标签：socket recv 编程网络 dict print data 服务端

网络编程之sockrt套接字

socket套接字简介

socket是所有CS架构都需要使用到的一种固定模块，socket是最底层的原理，很多框架都被封装了起来，所以我们以后写软件的时候连socket的影子都见不到

socket模块

cs架构的软件无论是在编程还是运行都应该先考虑服务端

服务端

import socket          # 导入模块
server = socket.socket()     # 打开模块窗口，括号内不写参数默认就是基于网络的遵循TCP协议的套接字
server.bind(('127.0.0.1',8080))		# 括号里的是IP与端口号>>>>>绑定一个固定的地址,127.0.0.1是计算机的本地回环地址，只有当前计算机本身1可以访问
server.listen(5)	# 进入链接端口>>>>>>>>>里面的数字代表服务端可以服务的个数
sock,addr = server.accept()	# 等待服务端接收，没有回应就程序阻塞
# listen和accept对应TCP三次握手服务端的两个状态
print(addr)	# 打印客户端的地址
data = sock.recv(1024)  # 括号里的是字节数，接收客户端返回的消息
print(data.decode('utf8'))	# 解码操作
sock.send('你好'.encode('utf8'))	# 回复别人说的话
# recv和send接收和发送的都是bytes类型的数据
sock.close()   # 结束对话链接
server.close()	# 结束程序

# 客户端
import socket		# 导入模块
client = socket.socket()  # 产生一个socket对象
client.connect(('127.0.0.1', 8080))  # 根据服务端的地址链接
client.send(b'hello sweet heart!!!')  # 给服务端发送消息
data = client.recv(1024)  # 接收服务端回复的消息
print(data.decode('utf8'))	# 解码
client.close()  # 关闭客户端

# 服务端与客户端首次交互，一边是recv那么另一边必须是send,两边不能相同，否则就一直保持程序阻塞状态

通信循环

while True:
    data = sock.recv(1024)  # 听别人说话
    print(data.decode('utf8'))
    msg = input('请回复消息>>>:').strip()
    sock.send(msg.encode('utf8'))  # 回复别人说的话
 
while True:
    msg = input('请输入你需要发送的消息>>>:').strip()
    client.send(msg.encode('utf8'))  # 给服务端发送消息
    data = client.recv(1024)  # 接收服务端回复的消息
    print(data.decode('utf8'))

1.先解决消息固定的问题,利用input获取用户输入
2.再解决通信循环的问题,将双方用于数据交互的代码循环起来

代码优化及链接循环

1.发送消息不能为空,统计长度并判断即可
2.反复重启服务端可能会报错>>>:address in use
    解决方法就是在bind前加：
    from socket import SOL_SOCKET,SO_REUSEADDR
  server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
3.链接循环：
3.1. 如果是windows 客户端异常退出之后服务端会直接报错
    处理方式：异常处理
 3.2. 如果是mac或linux 服务端会接收到一个空消息
  	处理方式：len判断
   eg:
    while True:
    sock,addr = server.accept()  # 等待并接收客户端，没有客户端就会原地等待
    '''listen和accept对应TCP三次握手服务端的两个状态'''
    print(addr)  # 打印客户端地址
    while True:
        try:
            data = sock.recv(1024)  # 接受客户端的消息
            if len(data) == 0:
                break
            print(data.decode('utf8'))  # 接受客户端的消息进行解码
            flg = input('你想要发送什么信息>>>:').strip()
            if len(flg) == 0:
                continue
            sock.send(flg.encode('utf8'))  # 给客户端发送消息
        except Exception:
            break
 # 客户端如果异常断开 服务端代码应该重新回到accept等待新的客人
目前我们的服务端只能实现一次服务一个人 不能做到同事服务多个 学了并发才可以实现

半连接池

listen(5)
# py文件默认同一时间只能运行一次 如果想单独分开运行多次

# 半连接池
	设置的最大等待人数  >>>:  节省资源 提高效率

粘包问题

# 服务端
import socket
 
server = socket.socket()
server.bind(('127.0.0.1', 8888))
server.listen(5)
 
conn,addr = server.accept()
data1 = conn.recv(1024)
print(data1)
data2 = conn.recv(1024)
print(data2)
data3 = conn.recv(1024)
print(data3)
 
# 客户端
import socket
 
client = socket.socket()
client.connect(('127.0.0.1', 8888))
 
client.send(b'jason')
client.send(b'oscar')
client.send(b'kevin')
 
# 打印结果:
b'jasonoscarkevin'
b''
b''
# TCP协议的特点
会将数据量比较小并且时间间隔比较短的数据整合到一起发送,并且还会受制于recv括号内的数字大小
# 粘包产生的原因
因为recv括号内我们不知道即将要接收的数据到底多大，如果每次接收的数据我们都能够精确的知道它的大小 那么肯定不会出现黏包

解决粘包问题

# struct模块
	import struct
 data1 = 'hello world!'
  print(len(data1))  # 12
  res1 = struct.pack('i', len(data1))  # 第一个参数是格式 写i就可以了
  print(len(res1))  # 4
  ret1 = struct.unpack('i', res1)
  print(ret1)  # (12,)

  data2 = 'hello baby baby baby baby baby baby baby baby'
  print(len(data2))  # 45
  res2 = struct.pack('i', len(data2))
  print(len(res2))  # 4
  ret2 = struct.unpack('i', res2)
  print(ret2)  # (45,)
    
   # pack可以将任意长度的数字打包成固定长度
   # unpack可以将固定长度的数字解包成打包之前数据真实的长度

1.先将真实数据打包成固定长度的包
2.将固定长度的包先发给对方
3.对方接收到包之后再解包获取真实数据长度
4.接收真实数据长度

代码演示

# 服务端
import os
import socket
import json
import struct
 
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
 
conn,addr = server.accept()
 
data_dict = {'file_name': '文件.txt',
             'file_desc': 'SB',
             'file_size': os.path.getsize(r'a.py')}
 
# 1.先打包字典
dict_json_str = json.dumps(data_dict)
dict_bytes = dict_json_str.encode('utf8')
dict_package = struct.pack('i', len(dict_bytes))
# 2.发送报头
conn.send(dict_package)
#3.发送字典
conn.send(dict_bytes)
# 4.发送真实的数据
with open(r'a.py','rb') as f:
    for line in f:
        conn.send(line)
        
# 客户端
import socket
import struct
import json
 
client = socket.socket()
client.connect(('127.0.0.1', 8080))
 
# 1.先接收固定长度的字典的报头
dict_len = client.recv(4)
# 2.解析出字典的真实长度
dict_len_real = struct.unpack('i', dict_len)[0]
# 3.接收字典数据
dict_data_bytes = client.recv(dict_len_real)
dict_data = json.loads(dict_data_bytes)
print(dict_data)
# 4.循环接收文件数据，不要一次性接收
recv_size = 0
with open(dict_data.get('file_name'),'wb') as f:
    while recv_size < dict_data.get('file_size'):
        data = client.recv(1024)
        recv_size += len(data)
        f.write(data)

recv括号内的数字尽量不要写太大 1024 2048 4096足够了
字典数据很难突破上面的数值

所以针对大文件的接收应该采用循环的形式一次接受一点点

标签：socket,recv,编程,网络,dict,print,data,服务端
来源： https://www.cnblogs.com/WH101/p/16151726.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9