class ProxyAPI(object): def __init__(self): self.app = Flask(__name__) self.mongo_pool = MongoPool() @self.app.route('/random') def random_proxy(): protocol = request.args.get('protocol') domain = request.args.get('domain') proxies = self.mongo_pool.find_all() p_index = random.randint(1, 100) pr = proxies[p_index] pr = pr.__dict__ return pr @self.app.route('/proxies') def proxies_list(): proxies = self.mongo_pool.find_all() dict_list = [proxy.__dict__ for proxy in proxies] return json.dumps(dict_list) def run(self): self.app.run('0.0.0.0', port=9999, debug=True) @classmethod def start(cls): pa = cls() pa.run()
class ProxyTester(object): def __init__(self): # 创建操作数据库的mongoPool对象 self.mongo_pool = MongoPool() self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self,temp): self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback) def run(self): # 提供一个run方法,用于处理检测代理IP核心逻辑 # 2.1 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() for proxy in proxies: # self.__check_one_proxy(proxy) # 把代理IP添加到队列中 self.queue.put(proxy) # 3.5 开启多个一个异步任务,来处理代理IP的检测,可以通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): # 3.4 通过异步回调,使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback) # 让当前线程,等待队列任务完成 self.queue.join() def __check_one_proxy(self): # 3.3 把检查一个代理可用性的代码,抽取到一个方法中, # 从队列中获取代理IP,进行检查,检查完毕 proxy = self.queue.get() # 2.3 检查代理可用性 proxy = check_proxy(proxy) # 如果代理不可用,让代理分数-1 if proxy.speed == -1: proxy.score -= 1 # 如果代理分数等于0,就从数据库中删除该代理 if proxy.score <= 45: self.mongo_pool.delete_one(proxy) else: # 更新代理IP self.mongo_pool.update_one(proxy) else: # 2.5 如果代理可用,就恢复该代理分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的task_done方法 self.queue.task_done() @classmethod def start(cls): proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): self.mongo_pool = MongoPool() self.queue = Queue() self.coroutine_pool = Pool() def _check_callback(self, temp): self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._check_callback) def run(self): # 检测所有ip可用性 # 获取数据库的ip proxies = self.mongo_pool.find_all() # 遍历代理ip列表 for proxy in proxies: # 把代理ip添加到队列中 self.queue.put(proxy) # 开启异步检测 for i in range(TEST_PROXIES_ASYNC_COUNT): # 通过异步回调 使用循环不停的执行 self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._check_callback) # 让当前线程,等待队列完成 self.queue.join() def _check_one_proxy(self): # print(proxy) # 检测ip可用性 # 从队列里面获取队列 proxy = self.queue.get() proxy = check_proxy(proxy) # 如果可用 代理分数减掉1 if proxy.speed == -1: proxy.score -= 1 # 判断分数是否为零 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 更新代理ip self.mongo_pool.update_one(proxy) else: # 如果代理可用, 就恢复代理的分数, 更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) self.queue.task_done() @classmethod def start(cls): # 创建对象 proxy_tester = cls() proxy_tester.run() # 每隔一定的时间执行一次 schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): self.mongo_pool = MongoPool() self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 提供一个 run 方法,用于处理检测代理IP核心逻辑 # 2.1 从数据库中获取所以代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理IP列表 for proxy in proxies: # self.__check_one_proxy(proxy) # 把代理ip添加到队列中 self.queue.put(proxy) for i in range(TEST_PROXIES_ASYNC_COUNT): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) self.queue.join() def __check_one_proxy(self): ''' 检查一个代理IP的可用性 ''' proxy = self.queue.get() # 2.3 检测代理可用性 print(proxy) proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 否则更新该代理ip self.mongo_pool.update_one(proxy) else: # 2.5 如果代理可用,就恢复该代理的分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) self.queue.task_done() @classmethod def start(cls): # 4.2.1 创建本类对象 proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): self.mongo_pool = MongoPool() self.coroutine_pool = Pool() self.queue = Queue() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 获取所有代理ip proxies = self.mongo_pool.find_all() for proxy in proxies: # 把要检测的代理放到队列中 self.queue.put(proxy) for i in range(TEST_PROXY_ASYNC_COUNT): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) # 当前线程等待队列的完成 self.queue.join() def __check_one_proxy(self): # 检查代理的可用性 proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) self.queue.task_done() @classmethod def start(cls): proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXY_INTERVAL).minutes.do(proxy_tester.run) while True: schedule.run_pending()
class ProxyCheck(object): def __init__(self): self.mongo_pool = MongoPool() self.queue = Queue() self.coroutine_pool = Pool() def run(self): proxies = self.mongo_pool.find_all() for proxy in proxies: self.queue.put(proxy) # 异步回调函数 for i in range(CHECK_PROXY_ASYNC): self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._callback_check) # 让当前线程等待队列任务完成 self.queue.join() def _callback_check(self, tmp): self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._callback_check) def _check_one_proxy(self): proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score -= 1 print(proxy.score) if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) self.queue.task_done() @classmethod def start(cls): pc = ProxyCheck() pc.run() schedule.every(CHECK_PROXY_INTERVAL).do(pc.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTest(object): def __init__(self): self.mongo_pool = MongoPool() self.queue = Queue() self.coroutine_pool = Pool() #回调函数 def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) #队列实现 def run(self): proxies = self.mongo_pool.find_all() for proxy in proxies: self.queue.put(proxy) for i in range(ASYNC_NUM): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) self.queue.task_done() def __check_one_proxy(self): proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.delay == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score == MAX_SCROE self.mongo_pool.update_one(proxy) self.queue.task_done() #调用接口,定时任务 @classmethod def start(cls): rs = ProxyTest() rs.run() schedule.every().hours.do(rs.run) while True: schedule.run_pending() time.sleep(30)
class ProxyTester(object): def __init__(self): self.mongo_pool = MongoPool() self.q = Queue() self.coroutine_pool = Pool() def run(self): proxies = self.mongo_pool.find_all() for proxy in proxies: self.q.put(proxy) for i in range(TEST_PROXIES_ASCYNC_COUNT): self.coroutine_pool.apply_async(self.__task, callback=self.__check_callback) self.q.join() def __check_callback(self, tmp): self.coroutine_pool.apply_async(self.__task, callback=self.__check_callback) def __task(self): proxy = check_proxy(self.q.get()) if proxy.idle == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) self.q.task_done() @classmethod def start(cls): proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXIES_INTERVAL).minutes.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(60)
class ProxyTester(): def __init__(self): #创建操作数据库的MonggoPool对象 self.mongo_pool = MongoPool() # 在init方法中创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() #提供一个run方法,用于处理检测代理IP核心逻辑 def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # 遍历IP列表 for proxy in proxies: #把要检测的代理IP,放到队列中 self.queue.put(proxy) # 开启多个一个异步任务,来处理代理IP的检测;可以通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): #通过异步回调,使用死循环不断执行这个方法, self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) #让当前线程,等待队列任务完成 self.queue.join() def __check_one_proxy(self): #检查一个代理IP的可用性 #把检查一个代理可用性的代码,抽取到一个方法中; # 从队列中获取代理IP,进行检查;检查完毕 proxy = self.queue.get() # 检查代理IP可用性 proxy = check_proxy(proxy) # 如果代理不可用,让代理分数减一,如果代理分数等于0则从数据库中删除该代理 if proxy.speed == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) # 否则更新该ip else: proxy.score = MAX_SCORE # 如果代理可用,就恢复该代理的分数,更新到数据库中 self.mongo_pool.update_one(proxy) #调度队列的task_done方法 self.queue.task_done() @classmethod def start(cls): # 1,定义一个start的类方法 # 2,创建当前类的对象,调用run方法 rs = ProxyTester() rs.run() # 3,使用schedule模块,每隔一定时间,执行当前对象的run方法 # 修改配置文件,增加爬虫运行时间间隔的配置,单位为小时 schedule.every(TEST_PROXIES_INTERVAL).hours.do(rs.run) while True: schedule.run_pending() time.sleep(2)
class ProxyTest(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy) def run(self): # 提供一个run 方法,用于处理检测代理命核心逻辑 # - 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # - 遍历代理IP列表 for proxy in proxies: # 把代理IP添加到队列中 self.queue.put(proxy) # .开启多个异步任务,来处理代理IP的检测;可以通过配置文件指定异步数量 for i in range(TES_PROXIES_ASYNC_COUNT): # 通过异步回调,使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) # 让当前线程等待队列的完成 self.queue.join() def __check_one_proxy(self): # 从队列中获取代理IP,进行检查 proxy = self.queue.get() # 检查代理可用性 proxy = check_proxt(proxy) # 如果代理不可用,让代理分数 - 1,如果代理分数等于0就从数据库中删除该代理 if proxy.speed == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 否则更新该代理IP self.mongo_pool.update_one(proxy) else: # 如果代理可用,就恢复该代理的分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 检查完毕,调度队列的task_done方法 self.queue.task_done() @classmethod def start(cls): # 创建本类对象 proxy_tester = cls() # 调用run方法 proxy_tester.run() # 每间隔一定时间,执行一下,run方法 schedule.every(TEST_SPIDERS_INTERVAL).hours.do(proxy_tester.run()) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 3.1 在`init`方法, 创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 提供一个 run 方法, 用于处理检测代理IP核心逻辑 # 2.1 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理IP列表 for proxy in proxies: # 3.2 把要检测的代理IP, 放到队列中 self.queue.put(proxy) # 3.5 开启多个一个异步任务, 来处理代理IP的检测; 可以通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): # 3.4 通过异步回调, 使用死循环不断执行这个方法, self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) # 让当前线程, 等待队列任务完成 self.queue.join() def __check_one_proxy(self): # 检查一个代理IP的可用性 # 3.3 把检查一个代理可用性的代码, 抽取到一个方法中; # 从队列中获取代理IP, 进行检查; 检查完毕 proxy = self.queue.get() # 2.3 检查代理可用性 proxy = check_proxy(proxy) # 2.4 如果代理不可用, 让代理分数-1, if proxy.speed == -1: proxy.score -= 1 # 如果代理分数等于0就从数据库中删除该代理 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 否则更新该代理IP self.mongo_pool.update_one(proxy) else: # 2.5 如果代理可用, 就恢复该代理的分数, 更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的task_done方法 self.queue.task_done() @classmethod def start(cls): # 4.2.1 创建本类对象 proxy_tester = cls() # 4.2.2 调用run方法 proxy_tester.run() # 4.2.3 每间隔一定时间, 执行一下, run方法 schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __chech_callbake(self, temp): self.coroutine_pool.apply_async(self.__chech_one_proxy, callback=self.__chech_callbake) def run(self): # 提供一个run方法,用于处理检测代理IP的核心逻辑 # 1. 从数据库里面获取所有IP proxies = self.mongo_pool.find_all() # 2. 遍历代理IP列表 for proxy in proxies: # 把代理IP添加到队列里去 self.queue.put(proxy) for i in range(TEST_PROXIES_ASYNC_COUNT): # 通过异步回调,使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__chech_one_proxy, callback=self.__chech_callbake) # 守护线程 self.queue.join() def __chech_one_proxy(self): # 从队列中获取代理IP,进行检查 proxy = self.queue.get() # 3. 检测代理可用性 proxy = check_proxy(proxy) # 4. 如果代理不可用,让代理分数-1 if proxy.speed == -1: proxy.score -= 1 # 5. 如果代理分数等于0,就从数据库中删除该IP if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 6. 否则更新该IP self.mongo_pool.update_one(proxy) else: # 如果代理可用,就恢复该代理分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的tesk_done方法 self.queue.task_done() @classmethod def start(cls): # 创建本类对象 proxy_tester = cls() # 调用run方法 proxy_tester.run() # 每隔一段时间执行一次run方法 schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 3.1 在`init`的方法中,创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 提供一个run方法,用于处理检测代理IP核心逻辑 # 2.1 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理IP for proxy in proxies: # 把代理IP添加到队列中 self.queue.put(proxy) # 3.5 开启多个一个异步任务,来处理代理IP的检测;可以通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): self.coroutine_pool.apply_async(self.__check_one_proxy(), callback=self.__check_callback) # 让当前线程等待队列的完成 self.queue.join() def __check_one_proxy(self): """ 检查一个代理IP的可读性 :param proxy: :return: """ # 3.3 把检查一个代理可用性的代码,抽取到一个方法中;从队列中获取代理IP,进行检查;检查完毕,调度队列的task_done方法 proxy = self.queue.get() # 2.3 检查代理IP的可用性 proxy = check_proxy(proxy) # 2.4 如果代理不可用,让代理分数-1 if proxy.speed == -1: proxy.score -= 1 # 如果代理分数等于0就从数据库中删除该代理IP if proxy.score == 0: self.mongo_pool.delete_one(proxy) # 否则更新代理IP else: self.mongo_pool.update_one(proxy) else: # 2.5 如果代理可用,就恢复该代理的分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的task_done方法 self.queue.task_done() @classmethod def start(cls): proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): #创建操作数据库的MongoDB兑现 self.mongo_pool = MongoPool() #在init方法中创建队列和协程池 self.queue =Queue() self.coroutine_pool = Pool() def __check_callback(self,temp): self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback) def run(self): # 提供一个run方法,用于处理检测代理IP核心逻辑 # 2.1 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理IP列表 for proxy in proxies: #把代理IP添加到队列中 self.queue.put(proxy) for i in range(TEST_PROXIES_ASYNC_COUNT): # 通过异步回调,使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback) # 让当前线程,等待队里了任务完成 self.queue.join() def __check_one_proxy(self): # 调度队列的task_done方法 proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score -= 1 # 如果代理分数等于0就从数据库中删除 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调用队列的task_done方法 self.queue.task_done() @classmethod def start(cls): """ 在start方法中创建本类对象 用run方法每隔一段时间,执行一次,run方法 :return: """ proxy_tester = cls() proxy_tester.run() schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTester(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 3.1 在init方法中创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() # 回调函数 def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): """提供run方法,用于处理检测代理IP可用性的核心逻辑""" # 2.1 从数据库中获取所有的代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理IP列表 for proxy in proxies: # 3.2 把要检测的代理IP,放到队列中 self.queue.put(proxy) # 3.5 开启多个异步任务,来处理代理IP的检测,可以通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): # 3.4 通过异步回调,使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) # 让当前线程,等待队列任务的完成 self.queue.join() def __check_one_proxy(self): """检测一个代理IP的可用性""" # 3.3 把要检测一个代理IP的可用性代码抽取到一个方法中;从队列中获取代理IP,进行检测,检测完毕;调度队列的task_done方法 proxy = self.queue.get() # 2.3 检查代理IP可用性 proxy = check_proxy(proxy) # 2.4 如果代理IP不可用, 就让代理IP分值减一, 如果代理IP分值等于0就从数据库中删除该代理IP, 否则就更新该代理IP if proxy.protocol == -1: proxy.score -= 1 # 代理IP减一 if proxy.score == 0: # 如果代理IP分值等于0 # 从数据库中删除该代理IP self.mongo_pool.delete_one(proxy) else: # 否则就更新该代理IP self.mongo_pool.update_one(proxy) else: # 2.5 如果代理IP可用, 就让代理IP分值恢复, 并且更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的task_done方法 self.queue.task_done() # 4.1 定义类方法start(),用于启动检测代理IP @classmethod def start(cls): # 4.2 创建当前类的对象,调用run方法 pt = cls() pt.run() # 4.3 使用schedule模块,每个一定时间间隔,执行一下run方法 # 修改配置文件,配置检测代理IP的时间间隔,单位为小时 schedule.every(TEST_SPIDRS_INTERVAL).hours.do(pt.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTest(object): def __init__(self): # 创建mongopool对象 self.mongo_pool = MongoPool() # 3.1 在init方法,创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): # 死循环 self.coroutine_pool.apply_async(self._check_one_proxy, callback=self.__check_callback) def run(self): # 2)提供一个run方法,用于处理检测代理IP的核心逻辑 # - 2.1)从数据库中获取代理IP proxies = self.mongo_pool.find_all() # 2.2)遍历代理IP列表 for proxy in proxies: print(proxy) self.queue.put(proxy) # 3.4)开启多个异步任务,来处理代理IP的检测,通过配置文件指定异步数量 for i in range(TEST_PROXIES_ASYNC_COUNT): # 3.3)通过异步回调,使用死循环不断执行此方法 self.coroutine_pool.apply_async(self._check_one_proxy, callback=self.__check_callback) # 让当前线程等待任务完成 self.queue.join() def _check_one_proxy(self): # 3.2)把检查一个代理可用性的代码抽取到一个方法中, # 从队列中获取IP,进行检查,检查完毕 proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.speed == -1: # 如果不可用,该代理 - 1, proxy.score -= 1 # 若分数变为0,就从数据库中删除该ip, if proxy.score == 0: self.mongo_pool.delete_one(proxy) # 否则更新该代理ip else: self.mongo_pool.update_one(proxy) print(proxy.score) else: # 如果可用,则回复该代理ip的分数,更新到数据库中 proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调取队列中的task_done方法 self.queue.task_done() # 4)使用schedule模块,每个一段时间,执行一次检测任务 @classmethod def start(cls): # - 4.1)定义一个start的类方法 # - 4.2)创建当前类的对象,调用run方法 pt = cls() pt.run() # - 4.3)使用schedule模块,每个一定时间,执行当前对象的run方法 schedule.every(TEST_PROXIES_INTERVAL).hours.do(pt.run) while True: schedule.run_pending() time.sleep(1)
class ProxyTest(object): def __init__(self): self.mongo_pool = MongoPool() # 创建Queue和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __modify_one_proxy(self, proxy): proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score -= 1 if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: self.mongo_pool.update_one(proxy) else: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) return proxy def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__execute_queued_task, callback=self.__check_callback) def __execute_queued_task(self): # 从Queue中获取一个代理IP proxy = self.queue.get() proxy = self.__modify_one_proxy(proxy) # 调用Queue的task done方法表示检测完毕一个代理IP self.queue.task_done() def __get_all_proxies_from_mongodb(self): return self.mongo_pool.find_all() def run(self): proxies = self.__get_all_proxies_from_mongodb() for proxy in proxies: # 把代理IP添加到Queue中 self.queue.put(proxy) # self.__modify_one_proxy(proxy) # 开启多个异步任务,开始数量有settings设置 for i in range(PROXY_TEST_ASYNC_TASK_AMOUNT): # 开始协程池进行单线程异步任务 self.coroutine_pool.apply_async(self.__execute_queued_task, callback=self.__check_callback) # 让当前线程等待队列任务的完成 self.queue.join() @classmethod def start(cls): pt = cls() pt.run() logger.info('*****************本次检测完毕,等待下次检测*****************') schedule.every(PROXY_TEST_INTERVAL).minutes.do(pt.run) while True: # print("等待下次更新") schedule.run_pending() # time.sleep(PROXY_TEST_INTERVAL * 60 /2 + 1) time.sleep(1)
class ProxyTester(object): def __init__(self): # 创建操作数据库的MongoPool对象 self.mongo_pool = MongoPool() # 3.1 在'init' 方法中创建队列和协程池 self.queue = Queue() self.coroutine_pool = Pool() def __check_callback(self, temp): self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) def run(self): # 提供一个 run 方法, 用于处理检测代理IP的核心逻辑 # 2.1 从数据库中获取所有代理IP proxies = self.mongo_pool.find_all() # 2.2 遍历代理Ip列表 for proxy in proxies: # 3.2 把要检测的代理IP, 放入队列 self.queue.put(proxy) # 3.5 开启多个异步任务, 来处理代理IP的检测, 可以通过配置文件控制异步任务数量 for i in range(TEST_PROXIES_ASYNC_COUNT): # 3.4 通过异步回调, 使用死循环不断执行这个方法 self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback) # 让当前线程 等待队列中所有任务完成 self.queue.join() def __check_one_proxy(self): # 检查一个代理IP的可用性 # 3.3从队列中获取代理IP, 进行检查 proxy = self.queue.get() # 2.3 检查代理可用性 proxy = check_proxy(proxy) # 2.4 如果代理不可用, 让代理分数-1 if proxy.speed == -1: proxy.score -= 1 # 如果代理分数等于0就从数据库中删除该代理IP if proxy.score == 0: self.mongo_pool.delete_one(proxy) else: # 否则更新该代理IP分数 self.mongo_pool.update_one(proxy) else: # 如果代理IP可用, 并且此时分数不为满分时, 就恢复该代理的分数,并更新 if proxy.score != MAX_SCORE: proxy.score = MAX_SCORE self.mongo_pool.update_one(proxy) # 调度队列的task_done方法, 通知队列当前单位任务已完成 self.queue.task_done() @classmethod def start(cls): # 4.2.1 调用run方法 cls().run() # 4.2.2 每间隔一定时间, 执行一下, run方法 schedule.every(TEST_PROXIES_INTERVAL).hours.do(cls().run) while True: schedule.run_pending() time.sleep(1)