网络编程(二)-socket套接字

1.socket(套接字)

　　socket是应用层和传输层中的tcp/udp协议族通信的中间抽象层,它是一组接口.在设计模式中,socket其实就是一个门面模式,它把复杂的协议隐藏在socket接口好眠,对用户来说,一组简单的接口就是全部,让socket去组织数据,以符合指定的协议.如下图:

套接字在TCP和UDP协议中的使用流程

在python中使用socket只需要导入socket模块即可

一个简单的socket版本

import socket

client = socket.socket()  # 生成一个套接字
client.connect(('127.0.0.1',8080))  # 绑定服务器的地址

client.send(b'hello')  # 发消息
res = client.recv(1024)  # 接收消息
print(res)  # 打印服务端接受数据

client.close()  # 关闭套接字

import socket

client = socket.socket()  # 创建套接字
client.connect(('127.0.0.1',8080))  # 连接服务器

while True:
    msg = input('>>>:')
    client.send(msg.encode('utf-8'))  # 发送信息到服务端
    if msg == 'exit':
        break
    res = client.recv(1024).decode('utf-8')  # 从服务端接受信息
    if res == 'exit':break
    print(res)  # 打印接受到的信息


client.close()  # 关闭套接字

socket使用注意:

　　127.0.0.1是本机回环地址,只能自己识别自己,其他人无法访问,可以用来测试代码

　　客户端和服务端的send和recv要对应出现,不能出现两边都是相同的情况

　　socket是基于网络传输协议工作的,所以传输和接收的都只能是二进制数据,所以数据一定要转换为二进制

 

2.通信循环以及代码健壮性补充

　　通信循环就是可以让客户端和服务端进行多次通信,并设置一个条件,触发这个条件就退出连接

在交互的过程中会存在各种问题,比如发空信息会导致

import socket

client = socket.socket()  # 生成一个套接字
client.connect(('127.0.0.1',8080))  # 绑定服务器的地址

while True:
    msg = input('>>>:')
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf-8'))  # 发消息
    if msg == 'exit':
        print('退出程序')
        break
    res = client.recv(1024).decode('utf-8')  # 接收消息
    if res == 'exit':
        print('退出程序')
        break
    print(res)  # 打印服务端接受数据

client.close()  # 关闭套接字

import socket

server = socket.socket()  # 生成一个套接字(买手机)

server.bind(('127.0.0.1',8080))  # 绑定ip地址和端口号(插电话卡)
server.listen()  # 监听客户请求  半连接池(开机)

conn, addr = server.accept()  # 等待客户连接(等待接听电话)

while True:
    # 异常捕获,在客户端强制退出之后,服务端会报错
    try:
        res = conn.recv(1024).decode('utf-8')  # 接收客户的发送(听对方说话)
        if len(res) == 0:break  # 在mac和linux系统中,客户端强制退出不会报错,只会发空,所以如果为空,直接退出
        if res == 'exit':
            print('退出程序')
            break
        print(res)  # 打印客户发送
        msg = input('>>>:')
        if len(msg) == 0:
            continue
        conn.send(msg.encode('utf-8'))  # 给客户发消息(说话),只能发送二进制数据
        if msg == 'exit':
            print('退出程序')
            break
    except ConnectionResetError as e:  # 报错信息:[WinError 10054] 远程主机强迫关闭了一个现有的连接。
        print(e)  # 打印报错信息并退出
        break

conn.close()  # 关闭通信连接
server.close()  # 关闭套接字

3.连接循环以及半连接池的概念

　　连接循环就是可以跟多个客户端交互,但一次只能和一个客户端交互,只有在这个客户端交互完成之后才能跟下一个客户端交互.在等待客户连接的代码块前加上一个while True循环就能实现

半连接池规定了交互以及等待交互的客户端的数量,等待交互的客户端不能大于半连接池,否则会直接报错

如下图,半连接池的数值是5,但是等待交互的客户端超过了5个,直接报错

4.TCP粘包问题

　　TCP协议会将数据量较小的并且间隔时间较短的数据一次性打包发给对方,这就会发生粘包问题.

　　粘包问题是由于TCP协议本身造成的,TCP为了提高传输效率,往往都需要收集到足够的数据之后才会发送出去,当多次发送的数据一次性的发送出去后,接收方不知道这些数据从哪里开始,从哪里结束,这些数据就是粘包数据.

粘包问题

import socket

client = socket.socket()
client.connect(('127.0.0.1',8080))

client.send(b'hello')  # 客户端连续发送了三条数据
client.send(b'world')
client.send(b'happy')

client.close()

import socket

server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)

conn,addr = server.accept()

res = conn.recv(1024)  # 只会在第一条数据收到
print(res)  # 打印了三个发送信息 b'helloworldhappy'
res = conn.recv(1024)  # 收到的是空
print(res)  # b''
res = conn.recv(1024)
print(res)  # b''

conn.close()
server.close()

 

struct模块

　　解决粘包问题需要引入一个struct模块,他能帮助我们存储数据的长度,并打包成一个4位或者8位的数据,解包之后就能获得原数据长度

import struct

t = 'asdasfasfasf43243421321safsafase23fsaasfsafas'
print(len(t))

res1 = struct.pack('i',len(t))  # 打包数据
print(len(res1))  # 在i模式下,打包的数据始终都只有4位

res2 = struct.unpack('i',res1)[0]  # 解包数据
print(res2)  # 解包之后能得到原始数据的长度

　　当传输的数据过大时,struct模块并不能帮我们有效的存储数据,这时候我们可以声明一个字典,把数据存储在字典中,再把字典的数据传输进去,这样原数据就算非常大,在字典中也只是一个数字,并不会占用很大的空间

字典存储

import struct

# t = 'asdasfasfasf43243421321safsafase23fsaasfsafas'
# print(len(t))

# 当传输的数据过大时,我们就不能使用len的方法
d = {
    'name': 'sxc',
    'size': 15646545656465111111146546565
}
import json
json_d = json.dumps(d)
print(len(json_d))


res1 = struct.pack('i',len(json_d))  # 打包数据
print(len(res1))  # 在i模式下,打包的数据始终都只有4位

res2 = struct.unpack('i',res1)[0]  # 解包数据
print(res2)  # 解包之后能得到原始数据的长度

解决粘包问题的方法

　　服务端:

　　　　1.先制作一个发送给客户端的字典

　　　　2.制作字典的报头

　　　　3.发送字典的报头

　　　　4.发送字典

　　　　5.发送真实数据

　　客户端:

　　　　1.先接受字典的报头

　　　　2.解析拿到字典的数据长度

　　　　3.接受字典

　　　　4.从字典中拿到真实数据的长度

　　　　5.接受真实数据

解决粘包问题的完整版本

import json
import socket
import struct

client = socket.socket()  # 生成一个套接字
client.connect(('127.0.0.1',8080))  # 绑定服务端的ip地址和端口

while True:
    cmd = input('>>>:')
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))
    # 1.接收字典报头
    dict_header = client.recv(4)
    # 2.解包这个报头,获取字典长度
    dict_len = struct.unpack('i',dict_header)[0]
    # 3.接收字典
    d = client.recv(dict_len)
    recv_d = json.loads(d)
    # 4.获取字典中的信息
    print(recv_d)
    recv_size = 0
    recv_data = b''
    while recv_size < recv_d.get('size'):
        date = client.recv(1024)
        recv_data += date
        recv_size += len(date)
    print(recv_data.decode('gbk'))

import socket
import subprocess
import struct
import json

server = socket.socket()  # 生成一个套接字
server.bind(('127.0.0.1',8080))  # 绑定ip地址和端口
server.listen(5)  # 监听客户端

while True:
    conn, addr = server.accept()  # 生成通道
    while True:
        try:
            cmd = conn.recv(1024).decode('utf-8')  # 接受用户输入
            if cmd == b'': break
            obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            res = obj.stdout.read() + obj.stderr.read()
            d = {
                'name':'sxc',
                'size':len(res)
            }
            # 1.生成一个字典长度的报头
            json_d = json.dumps(d)
            header = struct.pack('i',len(json_d))
            # 2.发送这个报头
            conn.send(header)
            # 3.发送这个字典
            conn.send(json_d.encode('utf-8'))
            # 4.发送这个真实数据
            conn.send(res)

        except ConnectionResetError:
            break
    conn.close()

作业:写一个上传电影的功能

　　1.循环打印某一个文件夹下面的所有文件

　　2.用户选取想要上传的文件

　　3.将用户选择的文件上传到服务器

　　4.服务端保存该文件

28

import socket
import json
import os

client = socket.socket()
client.connect(('127.0.0.1',8080))


# 获取选择函数
def choose_movie(movie_list):
    for index, name in enumerate(movie_list):
        print(index+1, name)
    choice = input('请输入您想选择的电影编号>>>:').strip()
    if not choice.isdigit():
        print('请输入正确的编号')
    choice = int(choice)
    if not (choice > 0 and choice <= len(movie_list)):
        print('请输入正确的编号')
    movie_name = movie_list[choice-1]
    return movie_name


while True:
    cmd = input('是否想下载电影y/n>>>:').strip()
    if cmd == 'n':
        print('退出程序')
        break
    elif cmd == 'y':
        client.send(cmd.encode('utf-8'))
    else:
        print('请输入正确的命令')
        continue
    movie_list = client.recv(1024).decode('utf-8')  # 接收收到的电影列表

    movie_list = json.loads(movie_list)
    movie_name = choose_movie(movie_list)

    client.send(movie_name.encode('utf-8'))  # 发送选择

    movie_dict = client.recv(1024).decode('utf-8')
    movie_dict = json.loads(movie_dict)
    print(movie_dict)
    recv_size = 0

    path = os.path.dirname(__file__)
    save_path = os.path.join(path,movie_name)
    with open(save_path, 'wb') as f:
        while recv_size < movie_dict.get('size'):  # real_size = 102400
            data = client.recv(1024)
            # print(len(data))
            f.write(data)
            recv_size += len(data)
client.close()

import socket
import os
import json

server = socket.socket()  # 创建套接字
server.bind(('127.0.0.1',8080))  # 绑定ip和端口
server.listen()  # 侦听客户请求

conn, addr = server.accept()  # 接受客户连接

data = conn.recv(1024).decode('utf-8')  # 接受客户输入

if data == 'y':
    path = 'F:迅雷下载'
    movie_list = os.listdir(path)
    print(movie_list)
    movie_list = json.dumps(movie_list)

    conn.send(movie_list.encode('utf-8'))  # 输出
    movie_name = conn.recv(1024).decode('utf-8')  # 接受客户输入
    # print(movie_name)

    movie_path = os.path.join(path, movie_name)
    size = os.path.getsize(movie_path)
    movie_dict = {
        'name': movie_name,
        'size': size
    }
    movie_dict = json.dumps(movie_dict)

    conn.send(movie_dict.encode('utf-8'))  # 发送电影字典
    send_size = 0
    with open(movie_path,'rb')as f:
        while send_size < size:
            data = f.read(1024)
            conn.send(data)
            send_size += len(data)
            print(send_size)
        else:
            print('upload successful')
conn.close()