Python_01_IP代理池_实现代理池的爬虫模块的执行方法

    目标:根据配置问价内心戏,加载爬虫,抓取代理ip,进行校验,如果可用写入到数据库中

    思路:

      1.在run_spider.py中,创建RunSpider类

      2.提供一个运行爬虫的run方法,作为运行爬虫的入口,实现核心的处理逻辑

        根据配置文件信息,获取爬虫对象列表

        遍历爬虫对象列表,获取爬虫对象,遍历爬虫对象的get_proxies方法,获取代理ip

        检测代理ip

        如果可用则写入数据库

        处理异常,防止一个爬虫内部出错,影响其他爬虫的使用

      3.使用异步来执行每一个爬虫任务,以提高抓取代理ip的效率

        在init方法中创建协程池对象

        把处理一个代理爬虫的代码放到一个方法中

        使用异步执行这个方法

        调用协程的join方法,让当前线程等待队列任务的完成

      4.使用schedule模块,实现每隔一定时间,执行当前对象的run方法

        定义一个start的类方法

        创建当前类的对象,调用run方法

        使用schedule模块,每隔一定时间,执行当前对象的run方法

        

代码:

# 打猴子补丁
from gevent import monkey
monkey.patch_all()
# 导入协程池
from gevent.pool import Pool
import importlib
import schedule
import time

from settings import PROXIES_SPIDERS
from core.proxy_validate.httpbin_validator import check_proxy
from core.db.mongo_pool import MongoPool
from utils.log import logger
from settings import RUN_SPIDERS_INTERVAL

"""
8.5 实现运行爬虫模块
目标: 根据配置文件信息, 加载爬虫, 抓取代理IP, 进行校验, 如果可用, 写入到数据库中
思路:

1. 在run_spider.py中, 创建RunSpider类
2. 提供一个运行爬虫的run方法, 作为运行爬虫的入口, 实现核心的处理逻辑
    2.1 根据配置文件信息, 获取爬虫对象列表.
    2.2 遍历爬虫对象列表, 获取爬虫对象, 遍历爬虫对象的get_proxies方法, 获取代理IP
    2.3 检测代理IP(代理IP检测模块)
    2.4 如果可用,写入数据库(数据库模块)
    2.5 处理异常, 防止一个爬虫内部出错了, 影响其他的爬虫.
3. 使用异步来执行每一个爬虫任务, 以提高抓取代理IP效率
    3.1 在init方法中创建协程池对象
    3.2 把处理一个代理爬虫的代码抽到一个方法
    3.3 使用异步执行这个方法
    3.4 调用协程的join方法, 让当前线程等待 协程 任务的完成.
4. 使用schedule模块, 实现每隔一定的时间, 执行一次爬取任务
    4.1 定义一个start的类方法
    4.2 创建当前类的对象, 调用run方法
    4.3 使用schedule模块, 每隔一定的时间, 执行当前对象的run方法
"""

class RunSpider(object):

    def __init__(self):
        # 创建MongoPool对象
        self.mongo_pool = MongoPool()
        # 3.1 在init方法中创建协程池对象
        self.coroutine_pool = Pool()

    def get_spider_from_settings(self):
        """根据配置文件信息, 获取爬虫对象列表."""
        # 遍历配置文件中爬虫信息, 获取每个爬虫全类名
        for full_class_name in PROXIES_SPIDERS:
            # core.proxy_spider.proxy_spiders.Ip66Spider
            # 获取模块名 和 类名
            module_name, class_name = full_class_name.rsplit(‘.‘, maxsplit=1)
            # 根据模块名, 导入模块
            module = importlib.import_module(module_name)
            # 根据类名, 从模块中, 获取类
            cls = getattr(module, class_name)
            # 创建爬虫对象
            spider = cls()
            # print(spider)
            yield spider

    def run(self):
        # 2.1 根据配置文件信息, 获取爬虫对象列表.
        spiders = self.get_spider_from_settings()
        # 2.2 遍历爬虫对象列表, 获取爬虫对象, 遍历爬虫对象的get_proxies方法, 获取代理IP
        for spider in spiders:
            #  2.5 处理异常, 防止一个爬虫内部出错了, 影响其他的爬虫.
            # 3.3 使用异步执行这个方法
            # self.__execute_one_spider_task(spider)
            self.coroutine_pool.apply_async(self.__execute_one_spider_task,args=(spider, ))

        # 3.4 调用协程的join方法, 让当前线程等待 协程 任务的完成.
        self.coroutine_pool.join()

    def __execute_one_spider_task(self, spider):
        # 3.2 把处理一个代理爬虫的代码抽到一个方法
        # 用于处理一个爬虫任务的.
        try:
            # 遍历爬虫对象的get_proxies方法, 获取代理I
            for proxy in spider.get_proxies():
                # print(proxy)
                # 2.3 检测代理IP(代理IP检测模块)
                proxy = check_proxy(proxy)
                # 2.4 如果可用,写入数据库(数据库模块)
                # 如果speed不为-1, 就说明可用
                if proxy.speed != -1:
                    # 写入数据库(数据库模块)
                    self.mongo_pool.insert_one(proxy)
        except Exception as ex:
            logger.exception(ex)

    @classmethod
    def start(cls):
        # 4. 使用schedule模块, 实现每隔一定的时间, 执行一次爬取任务
        # 4.1 定义一个start的类方法
        # 4.2 创建当前类的对象, 调用run方法
        rs = RunSpider()
        rs.run()
        # 4.3 使用schedule模块, 每隔一定的时间, 执行当前对象的run方法
        # 4.3.1 修改配置文件, 增加爬虫运行时间间隔的配置, 单位为小时
        schedule.every(RUN_SPIDERS_INTERVAL).hours.do(rs.run)
        while True:
            schedule.run_pending()
            time.sleep(1)

if __name__ == ‘__main__‘:
    # rs = RunSpider()
    # rs.run()
    RunSpider.start()

    # 测试schedule
    # def task():
    #     print(‘呵呵‘)
    #
    # schedule.every(10).seconds.do(task)
    # while True:
    #     schedule.run_pending()
    #     time.sleep(1)

原文地址:https://www.cnblogs.com/tkg1314/p/12623685.html

时间: 2024-10-08 05:51:30

Python_01_IP代理池_实现代理池的爬虫模块的执行方法的相关文章

代理模式_静态代理

一.代理模式_静态代理 来到北京.首先第一件事就是租房子.然而北京租房子80%的都要通过中介,中介获得房屋出租的权限,出租房屋给房客.我们以这个很现实很亲近我们生活的例子来认识代理模式中的静态代理. 二.代理模式中的角色划分 2.1抽象角色:把真实角色和代理角色所共有的行为抽成一个接口或者抽象类. 2.2真实角色:被代理角色所代理的角色. 2.3代理角色:代理真实角色做某些工作. 三.静态代理示例 3.1抽象角色(把真实角色房东和代理角色中介所共有的行为出租房屋抽象成一个接口) package

Python_01_IP代理池_实现代理池的检测模块

目的:检测代理ip的可用性,保证代理池中代理ip基本可用 思路: 1.在proxy_test.py中,创建ProxyTester类 2.提供一个run方法,用于处理检测代理ip的核心逻辑 1)从数据库中获取所有代理ip 2)遍历代理ip列表 3)检查代理ip可用性 如果不可用,代理分数-1,如果代理分数=0则删除该代理,否则更新代理ip 如果可用,恢复代理ip的分数,更新到数据库中 3.为了提高检查的速度,使用异步来执行检测任务 1)把要检测的代理ip放到队列中 2)把检查一个代理可用性的代码抽

Python_01_IP代理池_实现代理池的校验模块

目标:检验代理ip速度,匿名程度以及支持的协议类型 步骤: 1.检查代理ip速度和匿名程度: a.代理IP速度就是从发送请求到获取相应的时间间隔 b.匿名程度检查 对http://httpbin.org/get或https://httpbin.org/get发送请求如果相应的origin中有'.'分割的两个ip就是透明代理ip,如果相应的headers包含proxy-connection说明是匿名代理ip,否则就是高匿代理ip c.检查代理ip的协议类型 如果http://httpbin.org

java利用线程池(ExecutorService)配合Callable和Future实现执行方法超时的阻断

今天在项目开发中需要用到对执行方法加上时间控制,如果方法执行过长则跳出执行,废话不说,直接上代码,用的是线程池配合Callable和Future方式对执行方法的超时阻断.希望各位牛人指正 //启用线程池 final ExecutorService exec = Executors.newFixedThreadPool(1); Callable<Map<String, String>> call = new Callable<Map<String, String>&

Python_01_IP代理池_实现代理池的爬虫模块的及具体爬虫

目标:通过继承通用爬虫,实现多个具体爬虫,分别从各个免费代理ip网站上抓取代理ip 步骤 1.实现西刺代理,ip3366代理和快代理还有proxylistplus代理 定义一个类,继承通用爬虫类 提供urls,group_xpath和detail_xpath 2.实现66ip爬虫 定义一个类,继承通用爬虫类 提供urls,group_xpath和detail_xpath 由于ip66网页进行js+cookie反爬,需要重写父类的get_page_from_url()方法 代码: import t

设计模式_代理模式_动态代理

转自:https://www.ibm.com/developerworks/cn/java/j-lo-proxy-pattern/index.html 动态代理是指在运行时动态生成代理类.即,代理类的字节码将在运行时生成并载入当前代理的 ClassLoader.与静态处理类相比,动态类有诸多好处.首先,不需要为真实主题写一个形式上完全一样的封装类,假如主题接口中的方法很多,为每一个接口写一个代理方法也很麻烦.如果接口有变动,则真实主题和代理类都要修改,不利于系统维护:其次,使用一些动态代理的生成

总结代理模式 并根据数据库连接池原理来模拟实现自己的数据库连接池工具类

代理模式 需求:对系统中已有的某个类的功能,进行扩展(增强) 要求:在不修改源码的情况下,对已有的功能进行增强 静态代理 抽象接口:保证包含增强功能的对象和原有功能的对象,对外提供相同的方法 目标对象:封装了原有功能 代理对象:封装了增强功能和原有功能(通过持有一个目标对象的引用实现) 问题:代码不够灵活,产生大量冗余工作 动态代理 动态代理的实现API: Proxy : 帮助程员产生代理对象,提供产生代理类和代理对象的静态方法 InvocationHandler : 句柄接口,拦截到,所有代理

Spring之AOP原理_动态代理

面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming).声明式编程是和命令式编程(Imperative Programming)相对的概念.我们平时使用的编程语言,比如C++.Java.Ruby.Python等,都属命令式编程.命令式编程的意思是,程序员需要一步步写清楚程序需要如何做什么(How to do What).声明式编程的意思是,程序员不需要一步步告诉程序如何做,只需要告诉程序在哪些地方做什么

Apache2.4+Tomcat集群_反向代理配置

Apache2.4+Tomcat集群_反向代理配置 测试环境:Apache反代做为前端反向代理,后端任意,此处我用做windwos,其实linux与windwos配置原理都一样,只是根据公司需求来做. 需求:        要求基于ssl访问, 301域名跳转, session sticky方式来接收请求, 有故障隔离的作用,以至于在其中一台上线时可以把用户请求转发到另一台. 1.资源下载: Apache(windows安装包)下载路径 http://www.apachelounge.com/d