Python socket & socket server

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

socket

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket（套接字）。

建立网络通信连接至少要一对socket。socket是对TCP/IP的封装

使用方法

步骤：

服务器端：

实例化类
bind 绑定端口
listen 监听端口
accept 等待连接（阻塞）

sock, addr = server.accept() sock 是为客户端实例化的socket类， addr 是客户端的地址
与客户端交互：recv 接收（阻塞）、send 发送数据
close 断开连接

客户端：

实例化类
connect 连接端口
与服务器端交互：recv 接收（阻塞）、send 发送数据
close 断开连接

只传输一条数据

server:

import socket

server = socket.socket()

server.bind(('localhost', 8001))

server.listen(3)

conn, addr = server.accept()

data = conn.recv(1024)

conn.send(b'Got')

print('recv:', data)

server.close()

client:

import socket

client = socket.socket()

client.connect(('localhost', 8001))

client.send(b'Hello')

data = client.recv(1024)

print('recv:', data)

client.close()

循环发送数据：

server:

import socket

server = socket.socket()

server.bind(('localhost', 8001))

server.listen(3)

while 1:

    conn, addr = server.accept()

    print('new connection:', addr)

    while 1:

        data = conn.recv(1024)

        conn.send(b'Got')

        if not data:

            break

        else:

            print('recv:', data)

client:

import socket

client = socket.socket()

client.connect(('localhost', 8001))

while 1:

    data = input('>>>').strip()

    if len(data) == 0:

        # 注意不能发送内容为空，否则客户端会卡住

        continue

    if data == 'e':

        break

    else:

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

        data = client.recv(1024)

        print('recv:', data.decode())

client.close()

模拟SSH

server:

import socket

import os

server = socket.socket()

server.bind(('localhost', 8001))

server.listen(3)

while 1:

    try:

        conn, addr = server.accept()

        print('new connection:', addr)

        while 1:

            data = conn.recv(1024)

            if not data:

                break

            else:

                res = os.popen(data.decode()).read()

                conn.send(res.encode())

    except ConnectionResetError:

        continue

client:

import socket

client = socket.socket()

client.connect(('localhost', 8001))

while 1:

    data = input('>>>').strip()

    if len(data) == 0:

        # 注意不能发送内容为空，否则客户端会卡住

        continue

    if data == 'e':

        break

    else:

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

        data = client.recv(1024)

        print(data.decode())

client.close()

socket 粘包

当 send 被调用时，数据其实并没有立刻被发送给客户端，而是放到了系统的 socket 发送缓冲区里，等缓冲区满了、或者数据等待超时了，数据才会被 send 到客户端，这样就把好几次的小数据拼成一个大数据，统一发送到客户端了，这么做的目地是为了提高IO利用效率，一次性发送总比连发好几次效率高嘛。但也带来一个问题，就是“粘包”，即2次或多次的数据粘在了一起统一发送了。

解决方法：

让数据等待超时，发送一次数据之后 sleep(0.5) （直接忽略）
不要连续 send ，可以用 recv 将多次 send 隔开，只需要数据接收端接收到一次数据后，send 回复发送端
如果之前知道传输数据的大小，直接接收那么多的数据

传输大文件

server:

import socket

import os

import hashlib

server = socket.socket()

server.bind(('localhost', 8001))

server.listen(3)

while 1:

    try:

        conn, addr = server.accept()

        print('new connection:', addr)

        while 1:

            cmd = conn.recv(1024).decode()

            if not cmd:

                print('lost client')

                break

            else:

                file_name = cmd.split()[1]

                if not os.path.isfile(file_name):

                    res = 'no such file'

                else:   # 存在可以传输的文件

                    m = hashlib.md5()

                    file_size = os.stat(file_name).st_size

                    print(file_size)

                    conn.send(str(file_size).encode())

                    conn.recv(1024)

                    with open(file_name, 'rb')as f:

                        for line in f:

                            conn.send(line)

                            m.update(line)

                    print('file md5:', m.hexdigest())

                    conn.send(m.hexdigest().encode())

    except ConnectionResetError:

        print('lost client')

        continue

client:

import socket

import hashlib

client = socket.socket()

client.connect(('localhost', 8001))

while 1:

    cmd = input('get filename: >>>').strip()

    if len(cmd) == 0:

        # 注意不能发送内容为空，否则客户端会卡住

        continue

    else:

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

        file_name = cmd.split()[1]

        received_size = 0

        m = hashlib.md5()

        total_size = client.recv(1024)

        client.send(b'Get size')

        f = open(file_name + '.new', 'wb')

        while received_size < int(total_size.decode()):

            size = int(total_size.decode()) - received_size

            if size < 1024:

                receive_size = size

            else:

                receive_size = 1024

            data = client.recv(receive_size)

            received_size += len(data)

            f.write(data)

            m.update(data)

        else:

            f.close()

            print(m.hexdigest())

            server_md5 = client.recv(1024).decode()

            if m.hexdigest() == server_md5:

                print('file checked')

client.close()

有时结束连接之后再连接会显示端口占用，可以通过重用端口省去等待的时间： server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) (bind 端口之前进行设置)

socket server

创建socketserver的基本步骤：

创建一个请求处理类，继承 BaseRequestHandler 并且重写父类中的 handle()
实例化 TCPServer ，将 server IP 和请求处理类传给 TCPServer
调用 server.handle_request() #只处理一个请求 server.serve_forever() #处理多个一个请求，永远执行
server_close()

继承关系

class BaseServer:

class TCPServer(BaseServer):

class UDPServer(TCPServer):

class UnixStreamServer(TCPServer):

class UnixDatagramServer(UDPServer):

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

使用方法

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):

    def handle(self):

        # 处理和客户端所有的交互

        pass

if __name__ == '__main__':

    HOST, PORT = 'localhost', 8001

    server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)

    server.serve_forever()

如果要设置允许地址重用：

allow_reuse_address 是 TCPServer 和 UDPServer 的类变量，之后又被实例化的类继承了，由于实例化的类继承父类的同时已经开始 bind，所以只能在他继承父类之前修改父类的类变量

HOST, PORT = 'localhost', 8001

socketserver.TCPServer.allow_reuse_address = True

server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)  # 实例化 bind listen

server.serve_forever()

socket server 多并发

多线程： ThreadingTCPServer

多进程： ForkingTCPServer -only in Linux

使用时只需在实例化类时继承其中一个：

HOST, PORT = 'localhost', 8001

socketserver.TCPServer.allow_reuse_address = True

server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)  # 实例化 bind listen

server.serve_forever()