爬虫基础--IO多路复用单线程异步非阻塞

最近一直的学习爬虫  ，进行基础的学习

性能相关 参考

https://www.cnblogs.com/wupeiqi/p/6229292.html

# 目标：单线程实现并发HTTP请求
#
# socket
# IO多路复用
# HTTP协议
#
# 流程
# http://www.163.com/new/
# 1. sk连接  IP 禾端口进行连接
# 2.请求信息
# 请求头
# k=v

# k=v

# k=v

# 


# 请求体

import select
import socket
import time


class AsyncTimeoutException(TimeoutError):
    """
    请求超时异常类
    """

    def __init__(self, msg):
        self.msg = msg
        super(AsyncTimeoutException, self).__init__(msg)


class HttpContext(object):
    """封装请求和相应的基本数据"""

    def __init__(self, sock, host, port, method, url, data, callback, timeout=5):
        """
        sock: 请求的客户端socket对象
        host: 请求的主机名
        port: 请求的端口
        method: 请求方式
        url: 请求的URL
        data: 请求时请求体中的数据
        callback: 请求完成后的回调函数
        timeout: 请求的超时时间
        """
        self.sock = sock   #sock: 请求的客户端socket对象
        self.callback = callback  #callback: 请求完成后的回调函数
        self.host = host   #host: 请求的主机名
        self.port = port  # port: 请求的端口
        self.method = method #method: 请求方式
        self.url = url  #url: 请求的URL
        self.data = data  #data: 请求时请求体中的数据

        self.timeout = timeout   #timeout: 请求的超时时间

        self.__start_time = time.time()  #当前时间
        self.__buffer = []  #在buffer中写入响应内容

    def is_timeout(self):
        """当前请求是否已经超时"""
        current_time = time.time()
        if (self.__start_time + self.timeout) < current_time:
            return True

    def fileno(self):
        """请求sockect对象的文件描述符，用于select监听"""
        return self.sock.fileno()

    def write(self, data):
        """在buffer中写入响应内容"""
        self.__buffer.append(data)

    def finish(self, exc=None):
        """在buffer中写入响应内容完成，执行请求的回调函数"""
        if not exc:
            response = b''.join(self.__buffer)
            self.callback(self, response, exc)
        else:
            self.callback(self, None, exc)

    def send_request_data(self):  #发送请求 伪造请求头 请求体
        content = """%s %s HTTP/1.0
Host: %s

%s""" % (
            # 请求方式          请求的URL  请求的主机名  请求时请求体中的数据
            self.method.upper(), self.url, self.host, self.data,)

        return content.encode(encoding='utf8')

class AsyncRequest(object):
    def __init__(self):
        self.fds = []  #用于存放  连接有返回值的请求
        self.connections = []#用于存放需要连接的请求

    def add_request(self, host, port, method, url, data, callback, timeout):
        """创建一个要请求"""
        client = socket.socket()
        client.setblocking(False)
        try:
            client.connect((host, port))
        except BlockingIOError as e:
            pass
            # print('已经向远程发送连接的请求')
        req = HttpContext(client, host, port, method, url, data, callback, timeout)
        self.connections.append(req)
        self.fds.append(req)

    def check_conn_timeout(self):
        """检查所有的请求，是否有已经连接超时，如果有则终止"""
        timeout_list = [] #超时列表
        for context in self.connections:
            if context.is_timeout(): #进行超时检测 如果是超时
                timeout_list.append(context) #加入超时列表
        for context in timeout_list: #进行超时处理
            context.finish(AsyncTimeoutException('请求超时'))
            self.fds.remove(context) #进行移除 请求 待返回列表
            self.connections.remove(context) #进行移除 请求 待发送列表

    def running(self):
        """事件循环，用于检测请求的socket是否已经就绪，从而执行相关操作"""
        while True:
            if not self.fds: #如果没有请求 直接返回
                return
            r, w, e = select.select(self.fds, self.connections, self.fds, 0.05)  #监测socket对象的变化

            for context in r:
                sock = context.sock #接收请求 连接
                while True:
                    try:
                        data = sock.recv(8096)# 取返回值
                        if not data:#如果没有返回值
                            self.fds.remove(context)  #移除等待返回值 的请求
                            context.finish()#完成请求
                            break
                        else:
                            context.write(data)
                    except BlockingIOError as e:
                        break
                    except TimeoutError as e: #如果超时,,移除 发送的请求和接收的请求 取消请求
                        self.fds.remove(context)
                        self.connections.remove(context)
                        context.finish(e)
                        break

            for context in w:
                # 已经连接成功远程服务器，开始向远程发送请求数据
                if context in self.fds:
                    data = context.send_request_data()#请求头 请求体
                    context.sock.sendall(data)#进行连接
                    self.connections.remove(context) #移除已经连接成功的请求

            self.check_conn_timeout()  #检测  是否超时


if __name__ == '__main__':
    def callback_func(context, response, ex):
        """
        :param context: HttpContext对象，内部封装了请求相关信息
        :param response: 请求响应内容
        :param ex: 是否出现异常（如果有异常则值为异常对象；否则值为None）
        :return:
        """
        print(context, response, ex)

    obj = AsyncRequest()
    url_list = [
        {'host': 'www.google.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5,
         'callback': callback_func},
        {'host': 'www.baidu.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5,
         'callback': callback_func},
        {'host': 'www.bing.com', 'port': 80, 'method': 'GET', 'url': '/', 'data': '', 'timeout': 5,
         'callback': callback_func},
    ]
    for item in url_list:
        print(item)
        obj.add_request(**item)

    obj.running()