socket套接字

1、什么是socket

socket是一个模块，又称套接字，用来封装互联网协议（应用层以下的层）

2、为什么要有socket

实现应用层以下的层的工作，提高开发效率

3、怎么使用socket

先导入socket模块，先启动服务端套接字，再启动客户端套接字

# 服务端

import socket

# 买手机

server = socket.socket()

# 绑定手机号（IP，port）

# IP单机模式是127.0.0.1，局域网内使用cmd中ipconfig查询IPV4

# port设置8000以后的数据

server.bind(('127.0.0.1', 9876))

# 设置半连接池

server.listen(4)

# 可接收多个客户端数据连接，实现循环通信

while True:

    # 接收客户端连接

    conn, addr = server.accept()

    # 查看对方地址

    print(addr)

    while True:

        # 捕获异常机制

        try:

            # 接收客户端发来的数据，可一次接收1024bytes的数据

            data = conn.recv(1024)

            if len(date) == 0:

                break

            if data.decode('utf-8') == 'q':

                break

            print(data.decode('utf-8'))

            # 向客户端发送消息

            send_data = input('请输入向客户端发送的数据：')

            conn.send(send_data.encode('utf-8'))

        # 捕获异常，并打印出错误信息

        except Exception as e:

            print(e)

            break

    # 挂电话

    conn.close()

# 客户端

import socket

# 买手机

client = socket.socket()

# 建立连接（IP，port）

client.connect(('127.0.0.1',9876))

while True:

    try:

        # 向对方发送数据

        data = input('请输入向服务端发送的数据')

        client.send((data.encode('utf--8')))

        # 接收对方发来的数据可设置一次接收的bytes数，并打印

        res_data = client.recv(1024)

        if len(res_data) == 0:

            break

        if res_data.decode('utf-8') == 'q':

            break

        print(res_data.decode('utf-8'))

    # 捕获异常，并打印出异常

    except Exception as e:

        print(e)

        break

client.close()

粘包问题

问题1：

无法确认对方发送过来数据大小

问题2：

在发送数据间隔短并且数据量小的情况下，会将所有数据一次性发送

解决：需要确认对方发送的数据大小

# 客户端

# 问题1

import socket

client = socket.socket()

client.connect(('127.0.0.1', 9876))

while True:

    try:

        cmd = input('请输入向服务端发送的命令：')

        client.send(cmd.encode('utf-8'))

        # 接收服务端返回的数据

        # 由于不知道会返回多少个bytes所以有问题1

        date = client.recv(11910)

        print(len(date))

        print(date.decode('gbk'))

    except Exception as e:

        print(e)

        break

client.close()

# 客户端

# 问题2

# 时间间隔短，并数据量小的情况下，会将所有的数据一次性发送，接收时不知道具体有几个

import socket

client = socket.socket()

client.connect(('127.0.0.1', 9876))

client.send(b'hello')

client.send(b'hello')

client.send(b'hello')

client.send(b'hello')

client.send(b'hello')

# 服务端

import socket

import subprocess

server = socket.socket()

server.bind(('127.0.0.1', 9876))

server.listen(4)

while True:

    conn, addr = server.accept()

    print(addr)

    while True:

        try:

            # 接收客户端的数据，具体值不知道多大，所有有可能不能完全接收，有可能浪费资源

            cmd = conn.recv(12)

            if len(cmd) == 0:

                break

            cmd = cmd.decode('utf-8')

            if cmd == 'q':

                break

            # 调用subprocess连接终端，对终端进行操作，并获取正确和错误的结果

            obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            # 拿到结果，并打印

            result = obj.stdout.read() + obj.stderr.read()

            print(result.decode('gbk'))

            # 将结果返回给客户端

            conn.send(result)

        except Exception as e:

            print(e)

            break

    conn.close()

解决粘包问题

使用struct模块

struct 是一个python内置的模块，它可以将固定长度的数据，打包成固定格式的长度

模式：i：4，或其他模式

作用：将真实数据做成一个固定长度的报头，发送给服务端，服务端接收报头，然后进行解包，获取真实数据的长度，进行接收数据即可

import struct

data = input('请输入传的数据').strip()

data = data.encode('utf-8')

# 制作报头，需要 i 的字符串和传入数据的长度

header = struct.pack('i',len(data))

print(header)

print(len(header))

# 解包( i 的字符串和报头）获取真实长度，得到一个元组，拿到元组第一个数就是真实长度

res = struct.unpack('i', header)[0]

print(res)

# utf-8中一个中文是3个bytes，一个英文是1个bytes

客户端：

1.先制作报头，并发送

2.发送真实数据

服务端：

1.接收报头，并且解包获取真实数据长度

2.根据真实数据长度，接收真实数据

# 客户端

import socket

import struct

client = socket.socket()

client.connect(('127.0.0.1', 9876))

while True:

    try:

        cmd = input('请输入向服务端发送的命令')

        cmd_bytes = cmd.encode('utf-8')

        # 做一个报头

        header = struct.pack('i', len(cmd_bytes))

        # 发送报头

        client.send(header)

        # 发送真实数据

        client.send(cmd_bytes)

        # 接受服务端返回的报头

        reheader = client.recv(4)

        # 解包

        data_len = struct.unpack('i', reheader)[0]

        result = client.recv(data_len)

        print(result.decode('gbk'))

    except Exception as e:

        print(e)

        break

client.close()

# 服务端

import socket

import subprocess

import struct

server = socket.socket()

server.bind(('127.0.0.1', 9876))

server.listen(5)

while True:

    conn, addr = server.accept()

    while True:

        try:

            # 获取报头

            header = conn.recv(4)

            # 获取真实数据长度

            data_len = struct.unpack('i', header)[0]

            # 准备接受真实数据

            cmd = conn.recv(data_len)

            cmd = cmd.decode('utf-8')

            if cmd == 'q':

                break

            if len(cmd) == 0:

                break

            obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            result = obj.stdout.read() + obj.stderr.read()

            print(len(result))

            print(result.decode('gbk'))

            # 将结果返回给客户端

            header = struct.pack('i', len(result))

            conn.send(header)

            conn.send(result)

        except Exception as e:

            print(e)

            break

    conn.close()

# 客户端

import socket

import struct

import json

client = socket.socket()

client.connect(('127.0.0.1', 9876))

while True:

    # 伪装电影数据

    movie_name = input('请输入电影名称：')

    movie_len = 10000101

    send_dic = {

        'movie_name': movie_name,

        'movie_len': movie_len

    }

    # 序列化

    json_data = json.dumps(send_dic)

    # 制作报头

    json_bytes = json_data.encode('utf-8')

    header = struct.pack('i', len(json_bytes))

    # 发送报头

    client.send(header)

    # 发送真实数据

    client.send(json_bytes)

# 服务端

import socket

import json

import struct

server = socket.socket()

server.bind(('127.0.0.1', 9876))

server.listen(5)

while True:

    conn, addr = server.accept()

    print(addr)

    while True:

        try:

            # 接收报头

            header = conn.recv(4)

            # 解包获取真实长度

            json_len = struct.unpack('i', header)[0]

            # 接收真实长度

            json_bytes_data = conn.recv(json_len)

            json_data = json_bytes_data.decode('utf-8')

            # 反序列化得到数据

            back_dic = json.loads(json_data)

            print(back_dic)

        except Exception as e:

            print(e)

            break

    conn.close()

巴特西

socket套接字及粘包问题