码迷,mamicode.com
首页 > 其他好文 > 详细

套接字中的TCP协议

时间:2019-08-08 23:28:39      阅读:64      评论:0      收藏:0      [点我收藏+]

标签:color   定义   item   问题   decode   类型   except   连接池   打包   

socket(套接字)

本地回环地址

127.0.0.1

我们先来写一个简单地服务器和客户端

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import socket
?
server = socket.socket()  # 就比如买了一个手机
server.bind(("127.0.0.1",8080))  # bind中绑定的是IP地址和端口号,注意是一个元组,就比如,将手机卡,插入了手机
server.listen(5# 半连接池,最大等待连接数为5个,就比如开机
conn,address = server.accept()  # 接听电话等着别人给你打电话
?
date = conn.recv(1024# 听别人说话,接收1023个字节数
print(date)
conn.send(b"hello"# 给别人回话
?
?
conn.close()  # 挂断电话
server.close()  # 关机

客户端

1
2
3
4
5
6
7
8
9
10
11
import socket
?
client = socket.socket()  #拿电话
client.connect(("127.0.0.1",8080))  #绑定的是IP地址和端口号,也是一个元组 拨号
?
client.send(b"hello"# 对别人发消息
?
date = client.recv(1024#接收别人说话,没次接收1024个字节
print(date)
?
client.close()  # 挂电话

注意,在我们写服务器与客户端的时候

send与recv必须要一一对应

不能出现两边都相同的

recv是跟内存要数据,至于数据的来源你无需考虑

粘包

我们来看下面的的代码

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import socket
?
server = socket.socket()  # 就比如买了一个手机
server.bind(("127.0.0.1",8088))  # bind中绑定的是IP地址和端口号,注意是一个元组,就比如,将手机卡,插入了手机
server.listen(5# 半连接池,最大等待连接数为5个,就比如开机
conn,address = server.accept()  # 接听电话等着别人给你打电话
?
date = conn.recv(1024# 听别人说话,接收1023个字节数
print(date)
date = conn.recv(1024# 听别人说话,接收1023个字节数
print(date)
?
?
conn.close()  # 挂断电话
server.close()  # 关机

客户端

1
2
3
4
5
6
7
8
9
10
import socket
?
client = socket.socket()  #拿电话
client.connect(("127.0.0.1",8088))  #绑定的是IP地址和端口号,也是一个元组 拨号
?
client.send(b"hello"# 对别人发消息
client.send(b"hello"# 对别人发消息
?
?
client.close()  # 挂电话

服务端打印结果

1
b‘hellohello‘

这是应为;

tcp协议会将时间间隔短的,和文件大小小的会一次打包发个对方

如果我们将代码改一下,将服务端收到的字节数1024改为我们知道的字节数,看看是否还会粘包

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import socket
?
server = socket.socket()  # 就比如买了一个手机
server.bind(("127.0.0.1",8088))  # bind中绑定的是IP地址和端口号,注意是一个元组,就比如,将手机卡,插入了手机
server.listen(5# 半连接池,最大等待连接数为5个,就比如开机
conn,address = server.accept()  # 接听电话等着别人给你打电话
?
date = conn.recv(5# 听别人说话,接收1023个字节数
print(date)
date = conn.recv(5# 听别人说话,接收1023个字节数
print(date)
?
?
conn.close()  # 挂断电话
server.close()  # 关机

客户端

1
2
3
4
5
6
7
8
9
10
import socket
?
client = socket.socket()  #拿电话
client.connect(("127.0.0.1",8088))  #绑定的是IP地址和端口号,也是一个元组 拨号
?
client.send(b"hello"# 对别人发消息
client.send(b"hello"# 对别人发消息
?
?
client.close()  # 挂电话

打印结果

1
2
b‘hello‘
b‘hello‘

在我们知道了,我么传输的文件大小是多大的时候,规定给接收数据的recv就会避免粘包

解决粘包问题

struct模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import struct
?
?
print("--------------------------1--------------------------")
msg = "asdasdasdasdasd"
print("原字符串的长度")
print(len(msg))
?
handler = struct.pack("i",len(msg))
print("创建报头的长度")
print(len(handler))
?
?
res = struct.unpack("i",handler)[0]
print("解报头过后的长度")
print(res)
?
?
?
?
?
print("--------------------------2--------------------------")
?
msg1 = "asdasdasdasdasdasdasdasd"
print("原字符串的长度")
print(len(msg1))
?
handler1 = struct.pack("i",len(msg1))
print("创建报头的长度")
print(len(handler1))
?
?
res1 = struct.unpack("i",handler1)[0]
print("解报头过后的长度")
print(res1)
?
"""
--------------------------1--------------------------
原字符串的长度
15
创建报头的长度
4
解报头过后的长度
15
--------------------------2--------------------------
原字符串的长度
24
创建报头的长度
4
解报头过后的长度
24
"""

经过观察这个模块会将自己的长度固定为4,8几个等级,我们一般选i就够用了

我们就可以将这个发过去,解报头,就可以知道原来的数据的字节大小

如果这个字节大小比我们接收的大

我们就然他一直接收,直达接收完为止

代码如下

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import socket
import subprocess
import json
import struct
?
# 创建套接字
server = socket.socket()
# 绑定端口号,及IP地址
server.bind(("127.0.0.1", 8181))
# 进入半连接池状态
server.listen(5)
while True:
    conn, address = server.accept()  # 等待客户端连接
    while True:
        # 判断是否会出错
        try:
            date = conn.recv(1024).decode("utf-8"# 接收客户端发来的数据
            if len(date) == 0: break  # 判断客户端发来的数据是否为空,为空就退出循环,关闭这个通道
            # 创建一个subprocess的对象
            obj = subprocess.Popen(date, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            # 将对象拿到的类容做个合并
            res = obj.stdout.read() + obj.stderr.read()
            # 创建一个字典,将拿到的数据的字符数,装入字典中
            dic = {"file_size": len(res)}
            # 将字典数据类型,转换为json的字符串数据类型
            json_dic = json.dumps(dic)
            # 将json字符串数据类型,创建为报头
            handler = struct.pack("i", len(json_dic))
?
            # 发送报头
            conn.send(handler)
            # 发送json字符串的字典
            conn.send(json_dic.encode("utf-8"))
            # 发送原始数据
            conn.send(res)
        # 捕捉异常
        except ConnectionResetError:
            break
    # 关闭通道
    conn.close()

客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import socket
import struct
import json
?
# 创键套接字
client = socket.socket()
# 绑定端口和IP地址
client.connect(("127.0.0.1", 8181))
?
while True:
    # 用户输入发送内容,并装换成2进制
    msg = input("cmd>>>").strip().encode("utf-8")
    # 判断用户输入是否为空,为空跳过本次循环
    if len(msg) == 0: continue
    # 发送数据
    client.send(msg)
    # 接收报头
    handler = client.recv(4)
    # 解析报头,注意必须加索引,拿到json过后的字典的字节数
    json_dic_size = struct.unpack("i", handler)[0]
    # 接收json字典的字节数的json字典
    json_dic = client.recv(json_dic_size)
    # 将json数据的字典,反序列化
    dic = json.loads(json_dic)
    # 定义一个字节数为0 的变量
    msg_size = 0
    # 定义一个空的2进制字符
    msg_date = b‘‘
    # 判断,如果定义的字节数小于我们字典中的字节数就读取文件,如果等于和大于就退出循环,打印文件类容
    while msg_size < dic.get("file_size"):
        date = client.recv(1024)
        # 文件类容累加
        msg_date += date
        # 字节数累加
        msg_size += len(date)
?
    print(msg_date.decode("gbk"))

  


?

 

套接字中的TCP协议

标签:color   定义   item   问题   decode   类型   except   连接池   打包   

原文地址:https://www.cnblogs.com/le-le666/p/11324291.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!