python的网络编程（socket）

一、Socket介绍

Socket套接字，python中提供socket.py标准库，非常底层的接口库
Socket是一种通用的网络编程接口，和网络层次没有一一对应的关系

1、Socket类型

SOCK_STREAM :面向连接的流套接字，默认值，TCP协议
SOCK_DGRAM : 五连接的数据报文套接字，UDP协议

二、TCP编程

Socket编程，需要两端，一般来说需要一个服务端，一个客户端，服务端称为Sever，客户端称为lient

1、TCP服务端

服务器端编程步骤：

创建Socket对象
绑定IP地址Address和端口Port，bind()方法，IPv4地址为一个二元组('ip地址字符串',Port)
开始监听，将在指定的IP的端口上监听,listen()方法
获取用于传送数据的Socket对象：socket.accept() ->(socket object, address info)
accept方法阻塞等待客户端建立连接，返回一个新的Socket对象和客户端地址的二元组
地址是远程客户端的地址，IPv4中它是一个二元组(clientaddr,port)

s = socket.socket()  #创建socket对象
    s.bind(('127.0.0.1',8888))  # 一个二元组
    s.listen()  #开始监听

    #开启一个连接
    s1, info = s.accept()  #阻塞直到客户端成功建立连接，返回一个socket对象和客户端地址

    #使用缓冲区获取数据
    data = s1.recv(1024)
    print(data, info)
    s1.send(b'magedu.com ack')

2、写一个群聊程序

聊天工具是CS程序，C是每一个客户端，S是服务器端，服务器端应该具有的功能：

启动服务，包括绑定地址和端口，监听
建立连接，能和多个客户端建立连接，接收不同用户的信息
分发，将接收的某个用户的信息转发到已连接的所有客户端
停止服务，记录连接的客户端，服务器端应该对应一个类

举例
    import logging
    import socket
    import threading
    import datetime

    FORAMT = '%(asctime)s %(thread)d %(message)s' logging.basicConfig(level=logging.INFO, format=FORAMT) class ChatSever: def __init__(self, ip='127.0.0.1', port=8888): # 启动服务 self.sock = socket.socket() self.addr = (ip, port) self.clients = {} #客户端 self.event = threading.Event() def start(self): #启动监听  self.sock.bind(self.addr) self.sock.listen() # 监听 #accept会阻塞主线程，所以要开一个新线程 print('------------') threading.Thread(target=self.accept).start() def accept(self): # 多人连接 sock, client = self.sock.accept() # 阻塞 print(111,sock, client) self.clients[client] = sock # 添加到客户端字典 #准备接收数据，recv是阻塞的，开启新的线程 threading.Thread(target=self.recv, args=(sock, client)).start() def recv(self, sock:socket, client): # 接收客户端数据 while not self.event.is_set(): data = sock.recv(1024) #阻塞到数据到来 msg = "{:%Y/%m/%d %H:%M:%S} {} : {}\n{}\n".format(datetime.datetime.now(), *client, data.decode()) print('msg') logging.info(msg) for s in self.clients.values(): s.send(msg.encode()) def stop(self): #停止服务 for s in self.clients.values(): s.close() self.sock.close() self.event.set() cs = ChatSever() cs.start() e = threading.Event() while not e.wait(1): cmd = input('>>>').strip() if cmd == "quit": cs.stop() e.wait(3) break 客户端主动断开带来的问题 服务端知道自己何时断开，如果客户端断开，服务器不知道 所以，好的做法是，客户端开发出特殊消息通知服务器端断开连接 但是，如果客户端主动断开，服务端主动发送一个空消息，超时返回异常，捕获异常并清理连接 即使为客户端提供了断开命令，也不能保证客户端会使用它断开连接，但是还是要增加这个退出功能

为下面代码增加功能
    增加客户端退出命令
    增加多客户端支持


    import logging
    import socket
    import threading
    import datetime

    FORAMT = '%(asctime)s %(thread)d %(message)s' logging.basicConfig(level=logging.INFO, format=FORAMT) class ChatSever: def __init__(self, ip='127.0.0.1', port=8888): # 启动服务 self.sock = socket.socket() self.addr = (ip, port) self.clients = {} #客户端 self.event = threading.Event() def start(self): #启动监听  self.sock.bind(self.addr) self.sock.listen() # 监听 #accept会阻塞主线程，所以要开一个新线程 print('------------') threading.Thread(target=self.accept).start() def accept(self): # 多人连接 sock, client = self.sock.accept() # 阻塞 print(111,sock, client) self.clients[client] = sock # 添加到客户端字典 #准备接收数据，recv是阻塞的，开启新的线程 threading.Thread(target=self.recv, args=(sock, client)).start() def recv(self, sock:socket, client): # 接收客户端数据 while not self.event.is_set(): data = sock.recv(1024) #阻塞到数据到来 msg = data.decode().strip() #客户端退出命令 if msg == "quit": self.clients.pop(client) sock.close() logging.info("{} quits".format(client)) break msg = "{:%Y/%m/%d %H:%M:%S} {} : {}\n{}\n".format(datetime.datetime.now(), *client, data.decode()) print('msg') logging.info(msg) for s in self.clients.values(): s.send(msg.encode()) def stop(self): #停止服务 for s in self.clients.values(): s.close() self.sock.close() self.event.set() cs = ChatSever() cs.start() e = threading.Event() while not e.wait(1): cmd = input('>>>').strip() if cmd == "quit": cs.stop() e.wait(3) break

3、其他方法

socket.recv() : 获取数据，默认是阻塞的方式
socket.recvfrom() : 获取数据，返回一个二元组
socket.recv_info() : 获取到nbytes的数据后，存储到buffer中

创建一个与该套接字相关连的文件对象
使用makefile改写群聊类


import logging
import socket
import threading
import datetime

FORAMT = '%(asctime)s %(thread)d %(message)s' logging.basicConfig(level=logging.INFO, format=FORAMT) class ChatSever: def __init__(self, ip='127.0.0.1', port=8888): # 启动服务 self.sock = socket.socket() self.addr = (ip, port) self.clients = {} #客户端 self.event = threading.Event() def start(self): #启动监听  self.sock.bind(self.addr) self.sock.listen() # 监听 #accept会阻塞主线程，所以要开一个新线程 print('------------') threading.Thread(target=self.accept).start() def accept(self): # 多人连接 while not self.event.is_set(): sock, client = self.sock.accept() # 阻塞 print(111,sock, client) f = sock.makefile(mode='rw') self.clients[client] = f # 添加到客户端字典 #准备接收数据，recv是阻塞的，开启新的线程 threading.Thread(target=self.recv, args=(f, client), name='recv').start() def recv(self, f, client): # 接收客户端数据 while not self.event.is_set(): try: data = f.readline() # 阻塞到换行符 except Exception as e: logging.error(e) #有任何异常保证退出 data = 'quit' msg = data.strip() #客户端退出命令 if msg == "quit": self.clients.pop(client) f.close() logging.info("{} quits".format(client)) break msg = "{:%Y/%m/%d %H:%M:%S} {} : {}\n{}\n".format(datetime.datetime.now(), *client, data) print('msg') logging.info(msg) for s in self.clients.values(): s.wtitelines(msg) s.flush() def stop(self): #停止服务 for s in self.clients.values(): s.close() self.sock.close() self.event.wait(3) self.event.set() def show_thread(e:threading.Event): while not e.wait(3): logging.info(threading.enumerate()) def main(): e = threading.Event() cs = ChatSever() cs.start() threading.Thread(target=show_thread, args=(e,), name='showthread').start() while not e.wait(1): cmd = input('>>>').strip() if cmd == "quit": cs.stop() e.wait(3) break if __name__ == "__main__": main() Socket太底层了，实际开发中很少使用这么底层的接口

三、TCP客户端

客户端编程步骤
创建Socket对象
连接到远程服务端的ip和port，connect()
传输数据：使用send，recv方法，接收数据
关闭连接，释放资源

import logging
import socket
import threading
import datetime

FORAMT = '%(asctime)s %(thread)d %(message)s'
logging.basicConfig(level=logging.INFO, format=FORAMT) class ChatClient: def __init__(self, ip='127.0.0.1', port=8888): self.sock = socket.socket() self.addr = (ip, port) self.event = threading.Event() self.start() def start(self): #启动对远端的连接  self.sock.connect(self.addr) #准备接收数据，recv是阻塞的，开启新的线程 threading.Thread(target=self._recv, name="recv").start() def _recv(self): #接收客户端数据 while not self.event.is_set(): try: data = self.sock.recv(1024) #阻塞 except Exception as e: logging.error(e) break msg = "{:%Y/%m/%d %H:%M:%S} {} : {}\n{}\n".format(datetime.datetime.now(), *client, data) logging.info(msg) def send(self, msg:str): data = "{}\n".format(msg.strip()).encode() self.sock.send(data) def stop(self): logging.info("{} broken".format(self.addr)) self.sock.close() self.event.wait(3) self.event.set() logging.info("client stops") def show_thread(e:threading.Event): while not e.wait(3): logging.info(threading.enumerate()) def main(): e = threading.Event() cc = ChatClient() while True: msg = input('>>>') if msg.strip() == "quit": cs.stop() break cc.send(msg) if __name__ == '__main__': main()

四、Socketserver

socket编程过于底层，编程虽然有套路，但是想要写出健壮的代码还是比较困难的，所以很多语言都对socket底层API进行封装，Python的封装就是socketserver模块
网络服务编程框架，便于企业级快速开发

1、类的继承关系

SocketSever简化了网络服务器的编写
它有4个同步类：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer
2个Mixin类ForkingMixln和ThreadMixln类来支持异步

2、编程接口

socketserver.BaseServer(sever_address, RequestHandleClass)
需要提供服务器绑定的地址信息，和用于处理请求的RequestHandlerClass类，RequestHandleClass类必须是BaseRequestHandler类的子类

3、BaseRequestHandler类

和用户连接的用户请求处理类，Server实例接收用户请求后，最后会实例化这个类；它被初始化时，送入3个构造参数：request，client_address,server
以后可以在BaseRequestHandler类的实例上通过
self.request是客户端的连接的socket对象
self.server是TCPserver本身
self.client_address是客户端地址
它会一次调用3个函数，子类可以覆盖

import threading
    import socketserver

    class MyHandler(socketserver.BaseRequestHandler):
        def handle(self):
            print(self.server, self.request, self.client_address)
            print('{} handler'.format(self.__class__)) print(self.__class__) print(type(self).__dict__) print(self.__class__.__bases__[0].__dict__) print(threading.enumerate(), threading.current_thread()) addr = ('127.0.0.1', 8888) server = socketserver.ThreadingTCPServer(addr, MyHandler) server.serve_forever() 测试结果说明，handler方法和socket的accept对应，用户连接请求过来后，建立连接并生成一个 socket对象保存在self.request中，客户端地址保存在self.client_address中，

4、创建服务器需要几个步骤

必须通过BaseRequestHandler类进行子类化并覆盖其他handle()方法来创建请求处理程序类，此方法将处理传入请求
必须实例化一个服务器类，将它传递给服务器的地址和请求处理程序类
然后调用服务器对象的handle_request()或server_forever()方法
调用server_close()关闭套接字，shutdown()方法，等待停止server_forever()

5、实现EchoServer

顾名思义，Echo来什么消息回显什么消息，客户端发来什么信息，返回什么信息

import threading
import socketserver

class EchoHandler(socketserver.BaseRequestHandler):
    def finish(self):
        super().finish()
        self.event.set()  # 清理工作

    def setup(self):
        super().setup()
        self.event = threading.Event()  # 初始化工作

    def handle(self): super().handle() while not self.event.is_set(): data = self.request.recv(1024).decode() msg = "{} {}".format(self.client_address, data).encode() self.request.send(msg) print('End') addr = ('127.0.0.1', 8888) server = socketserver.ThreadingTCPServer(addr, EchoHandler) server_thread = threading.Thread(target=server.serve_forever, daemon=True) server_thread.start() try: while True: cmd = input('>>>') if cmd.strip() == 'quit': break except Exception as e: print(e) except KeyboardInterrupt: print('Exit') finally: server.shutdown() server.server_close()

python的网络编程（socket）

猜你喜欢