造轮子很高大上，其实理解一个轮子也是一件麻烦事
往往想理解一个库，打开源代码，我们就会在层层的函数/方法调用栈中迷失...
大的项目比如tornado、flask的源码乍一下手难度太高>_<，不妨从一个小项目开始
因为业务需要，公司的爬虫项目需要搭建一个代理池，确保池中的代理必须是可用状态
面向博客编程后，发现很多代理池轮子
综合评比下来，选用了这个方案：https://yukunweb.com/2018/4/build-free-asynchronous-proxy-pool/
轮子不大，但涉及到的技术概念还蛮多的，该篇博客是代理池实现详情说明文档
整套程序模块化设计，分为以下部分：
- 获取ip部分
从网上的免费代理网站抓取代理，设计成可扩展模式，如果有新的免费代理网站，可以添加新的抓取规则，在模块中添加方法即可 - 数据库封装
项目使用mongo数据库，在pymongo上又封装了一层，这样可以根据对应代理项目中的curd需求做更好的定制 - 调度部分
整个程序的核心调度设计，代理入库、定时检测代理的有效性、池子中代理的数量等等、 - api
设计对外的api，可以方便的调用代理，其他机器也可以通过网络调用池中代理
程序结构：
ProxyPool \
Api \
__init__.py
api.py
Spider \
__init__.py
get_proxy.py
Db \
__init__.py
db.py
Schedule \
__init__.py
adder.py
tester.py
schedule.py
config.py
run.py
代理获取
作者选择的免费代理：幻代理，66代理，快代理，西刺代理
然后分析这些代理网站的网页结构，设计规则抓下来并保存
抓取部分代码：
import requests
from lxml import etree
from requests.exceptions import ConnectionError
def parse_url(url):
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0'
}
try:
resp = requests.get(url, headers=headers)
if resp.status_code == 200:
return resp.text
return None
except ConnectionError:
print('Error.')
return None
def proxy_xici():
url = 'http://www.xicidaili.com/'
resp = parse_url(url)
html = etree.HTML(resp)
ips = html.xpath('//*[@id="ip_list"]/tr/td[2]/text()')
ports = html.xpath('//*[@id="ip_list"]/tr/td[3]/text()')
for ip, port in zip(ips, ports):
proxy = ip + ':' + port
yield proxy
parse_url是一个网页下载函数
proxy_xici是西刺代理的抓取规则，用xpath解析并使用yield返回组装好的ip+port格式的代理，注意此函数是一个生成器，需要用遍历的方式获取返回内容
这些抓取ip的方法用类来实现，并且做成了可扩展模式
具体就是所有的提取ip的方法统一以proxy_作方法名开头，并把这些方法保存在元类中（其实保存的是方法名的字符串格式数据），创建类的时候自动检查以proxy_开头的方法，然后做一些处理
如果有新的免费代理网站，添加新的方法按照约定的规则命名即可
具体实现：
# Spider/get_proxy.py
class ProxyMetaclass(type):
"""
元类，在ProxyGetter类中加入
__CrawlFunc__和__CrawlFuncCount__两个属性
分别表示爬虫函数和爬虫函数的数量
"""
def __new__(cls, name, bases, attrs):
count = 0
attrs['__CrawlFunc__'] = []
for k in attrs.keys():
if k.startswith('proxy_'):
attrs['__CrawlFunc__'].append(k)
count += 1
attrs['__CrawlFuncCount__'] = count
return type.__new__(cls, name, bases, attrs)
class ProxyGetter(object, metaclass=ProxyMetaclass):
def proxy_ip66(self):
pass
def proxy_xici(self):
pass
def proxy_kuai(self):
pass
def proxy_ihuan(self):
pass
上篇文章刚刚介绍了元类，如果你认真理解的话，这里的代码就不难懂了
如果你理解的更透彻，甚至可以发现这个实现中有一个元类属性是不需要添加的，那就是后话了，下篇文章我们会对这个元类稍作修改使代码更简洁
从上面的代码看，作者在attr中添加了两个属性，一个__CrawlFuncCount__是保存当前类中获取代理的方法数量
另一个__CrawlFunc__是ip代理爬虫方法名的string列表，具体实现是约定如果类中属性以proxy_开头就表明是代理爬虫方法，保存到属性中
注意new方法中使用的是type返回：
return type.__new__(cls, name, bases, attrs)
现学现卖，根据我的上篇文章，其实这样写会更好：
return super(ProxyMetaclass, cls).__new__(cls, name, bases, attrs)
同时类中还提供了一个方法，通过爬虫方法名来调用方法获取代理
class ProxyGetter(object, metaclass=ProxyMetaclass):
...
def get_raw_proxies(self, callback):
proxies = []
for proxy in eval("self.{}()".format(callback)):
print('Getting', proxy, 'from', callback)
proxies.append(proxy)
return proxies
关于eval的语法，作者也有解释：
>>> m = 5
>>> n = 3
>>> eval('m') + eval('n')
8
数据库
持久化用的是mongo数据库，封装了一套简洁api
mongo是非关系型文档类型数据库，数据在库中的体现形式非常类似于json格式
在linux中安装好mongo,终端shell中输入mongo启动客户端
使用use db命令指定库，这一点和mysql一致
但是查看库中某张表的命令是不同的：db.table.find()
> use proxy
switched to db proxy
> db.proxy.find()
{ "_id" : ObjectId("5b9f43666cb73e293b904801"), "proxy" : "112.195.206.72:4226", "num" : 1024, "http/s" : true }
{ "_id" : ObjectId("5b9f45956cb73e293b90480e"), "proxy" : "119.114.123.98:8946", "num" : 1028, "http/s" : false }
{ "_id" : ObjectId("5b9f45966cb73e293b904811"), "proxy" : "116.7.187.99:4223", "num" : 1029, "http/s" : true }
{ "_id" : ObjectId("5b9f49c76cb73e293b904820"), "proxy" : "182.113.33.83:4221", "num" : 1033, "http/s" : true }
{ "_id" : ObjectId("5b9f502c6cb73e293b904822"), "proxy" : "116.149.202.69:6436", "num" : 1034, "http/s" : false }
{ "_id" : ObjectId("5b9f502e6cb73e293b904825"), "proxy" : "182.105.201.64:4162", "num" : 1035, "http/s" : true }
{ "_id" : ObjectId("5b9f50406cb73e293b90482c"), "proxy" : "106.46.136.83:4237", "num" : 1036, "http/s" : false }
{ "_id" : ObjectId("5b9f50426cb73e293b90482f"), "proxy" : "112.83.93.63:2589", "num" : 1037, "http/s" : true }
>
表中的数据类似json格式的键值对，其中必须要有_id字段，如果插入数据的时候未指定id，则mongo会自动插入id
python中和mongo交互，使用的是pymongo库，封装了对数据库的操作
作者在此之上又封装了一层：
# db.py
from pymongo import MongoClient, ASCENDING
# 我们把配置文件放入 config.py 文件内
from config import NAME, HOST, PORT
class MongodbClient(object):
def __init__(self, table=TABLE, host=HOST, port=PORT):
self.table = table
self.client = MongoClient(host, port)
self.db = self.client.NAME
@property
def get_counts(self):
"""获取表里的数据总数"""
return self.db[self.table].count()
def change_table(self, table):
"""切换数据库表"""
self.table = table
def set_num(self):
"""给每条数据设置唯一自增num"""
nums = []
datas = self.get_all()
if datas:
for data in datas:
nums.append(data['num'])
return max(nums)
return 0
def get_new(self):
"""获取最新一条数据"""
data = self.get_all()[-1] if self.get_all() else None
return data
def get_data(self, num):
"""获取指定num的数据"""
datas = self.get_all()
if datas:
data = [i for i in datas if i['num']==num][0]
return data
return None
def get_all(self):
"""获取全部数据"""
# 判断表里是否有数据
if self.get_counts != 0:
# 先排序
self.sort()
datas = [i for i in self.db[self.table].find()]
return datas
return None
def put(self, proxy):
"""
放置代理到数据库
"""
num = self.proxy_num() + 1
if self.db[self.table].find_one({'proxy': proxy}):
self.delete(proxy)
self.db[self.table].insert({'proxy': proxy, 'num': num})
else:
self.db[self.table].insert({'proxy': proxy, 'num': num})
def delete(self, data):
"""删除数据"""
self.db[self.table].remove(data)
def clear(self):
"""清空表"""
self.client.drop_database(self.table)
def sort(self):
"""按num键排序"""
self.db[self.table].find().sort('num', ASCENDING)
在init中初始化数据库、host、端口
put方法向库中插入数据
delete方法根据数据内容删除对应的数据
值得一提的是，插入的每条数据都有一个自增的字段num
这个自己是设置的，sort方法就是根据num来排序
调度器
添加类：判断数据库中的代理数量是否达到最大阈值，进行启动爬虫和停止爬虫；
测试类：对爬取到的代理进行检测，将有效的代理放入数据库；
任务类：定时对数据库中的代理进行检测，用于启动整个调度器。
代理测试：
代理测试的网址可以选取一个页面很小网址，这样可以占用很小的流浪，响应的速度也会有略微提升
作者提出如果用百度作为测试网址，会出现不管代理是否成功，都会有响应200的情况，我测了一下，的确是
作者选择http://2017.ip138.com/ic.asp这个测试ip的站点作为检测站。是否好用未知，我用的http检测站点是：http://mini.eastday.com/assets/v1/js/search_word.js
作者用的是aiohttp这个异步请求库，是一个基于协程异步实现的库，推荐在python3.5以上环境使用
# Schedule/tester.py
import asyncio
import aiohttp
from Db.db import MongodbClient
# 将配置信息放入配置文件config.py
from config import TEST_URL
class ProxyTester(object):
test_url = TEST_URL
def __init__(self):
self._raw_proxies = None
def set_raw_proxies(self, proxies):
# 供外部添加需要测试的代理
self._raw_proxies = proxies
self._conn = MongodbClient()
async def test_single_proxy(self, proxy):
"""
测试一个代理，如果有效，将他放入usable-proxies
"""
try:
async with aiohttp.ClientSession() as session:
try:
if isinstance(proxy, bytes):
proxy = proxy.decode('utf-8')
real_proxy = 'http://' + proxy
print('Testing', proxy)
async with session.get(self.test_url, proxy=real_proxy, timeout=10) as response:
if response.status == 200:
# 请求成功，放入数据库
self._conn.put(proxy)
print('Valid proxy', proxy)
except Exception as e:
print(e)
except Exception as e:
print(e)
def test(self):
"""
异步测试所有代理
"""
print('Tester is working...')
try:
loop = asyncio.get_event_loop()
tasks = [self.test_single_proxy(proxy) for proxy in self._raw_proxies]
loop.run_until_complete(asyncio.wait(tasks))
except ValueError:
print('Async Error')
关于aiohttp的用法，大家可以参考这篇文章。也可以直接参考中文文档
使用aiohttp的好处是，当爬虫发出请求等待网路io的时候不会一直阻塞等待，而可以继续其他的任务，比如说请求一百个网页，假设每个网页io耗时90毫秒，如果使用吧requets阻塞请求的话，耗时大概是：100*90毫秒
如果使用aiohttp,总耗时大概是90毫秒多一点
可以发现任务越多的话，耗时的差距也非常大
代理测的入口是test方法：
创建事件循环，用列表生成器产生任务tasks,异步任务注册到事件循环中
test_single_proxy是测试单个代理的方法，注意方法前的async 关键字
async 、await关键字只能在python3.5以上的环境中使用，让我们可以像写同步任务一样去写异步任务，有了async 关键字以后，方法/函数就不是普通方法/函数了，需要注册到事件循环loop = asyncio.get_event_loop()里执行
添加代理
在循环中实现，先检测库中代理数量，如果低于设定的阈值，就调用获取代理类中的方法获取代理检测并入库，如果达到阈值则break循环
在获取代理类中通过遍历CrawlFunc列表拿到获取代理的方法，调用类中的get_raw_proxies拿到代理，然后通过测试类中的set_raw_proxies设置好要测试的代理，在事件循环注册测试入库
# Schedule/adder.py
from Db.db import MongodbClient
from Spider.get_proxy import ProxyGetter
from .tester import ProxyTester
class PoolAdder(object):
"""
启动爬虫，添加代理到数据库中
"""
def __init__(self, threshold):
self._threshold = threshold
self._conn = MongodbClient()
self._tester = ProxyTester()
self._crawler = ProxyGetter()
def is_over_threshold(self):
"""
判断数据库中代理数量是否达到设定阈值
"""
return True if self._conn.get_nums >= self._threshold else False
def add_to_pool(self):
"""
补充代理
"""
print('PoolAdder is working...')
proxy_count = 0
while not self.is_over_threshold():
# 迭代所有的爬虫，元类给ProxyGetter的两个方法
# __CrawlFuncCount__是爬虫数量，__CrawlFunc__是爬虫方法
for callback_label in range(self._crawler.__CrawlFuncCount__):
callback = self._crawler.__CrawlFunc__[callback_label]
# 调用ProxyGetter()方法进行抓取代理
raw_proxies = self._crawler.get_raw_proxies(callback)
# 调用方法测试爬取到的代理
self._tester.set_raw_proxies(raw_proxies)
self._tester.test()
proxy_count += len(raw_proxies)
if self.is_over_threshold():
print('Proxy is enough, waiting to be used...')
break
if proxy_count == 0:
print('The proxy source is exhausted.')
调度器定时实现
调度器中两个定时任务，用进程来实现（协程配合进程比较简单些），一个是定时取部分代理调用测试类检测，一个是定时检测数据库中的代理是否低于最低阈值，调用添加类添加。
# Schedulr/schedule.py
import time
from multiprocessing import Process
from ProxyPool.db import MongodbClient
from .tester import ProxyTester
from .adder import PoolAdder
from config import VALID_CHECK_CYCLE, POOL_LEN_CHECK_CYCLE \
POOL_LOWER_THRESHOLD, POOL_UPPER_THRESHOLD
class Schedule(object):
@staticmethod
def valid_proxy(cycle=VALID_CHECK_CYCLE):
"""
从数据库中拿到一半代理进行检查
"""
conn = MongodbClient()
tester = ProxyTester()
while True:
print('Refreshing ip...')
# 调用数据库，从左边开始拿到一半代理
count = int(0.5 * conn.get_nums)
if count == 0:
print('Waiting for adding...')
time.sleep(cycle)
continue
raw_proxies = conn.get(count)
tester.set_raw_proxies(raw_proxies)
tester.test()
time.sleep(cycle)
@staticmethod
def check_pool(lower_threshold=POOL_LOWER_THRESHOLD,
upper_threshold=POOL_UPPER_THRESHOLD,
cycle=POOL_LEN_CHECK_CYCLE):
"""
如果代理数量少于最低阈值，添加代理
"""
conn = MongodbClient()
adder = PoolAdder(upper_threshold)
while True:
if conn.get_nums < lower_threshold:
adder.add_to_pool()
time.sleep(cycle)
def run(self):
print('Ip Processing running...')
valid_process = Process(target=Schedule.valid_proxy)
check_process = Process(target=Schedule.check_pool)
valid_process.start()
check_process.start()
阈值和两个调度周期在config中：
# config.py
# Pool 的低阈值和高阈值
POOL_LOWER_THRESHOLD = 10
POOL_UPPER_THRESHOLD = 40
# 两个调度进程的周期
VALID_CHECK_CYCLE = 600
POOL_LEN_CHECK_CYCLE = 20
valid_proxy周期的从数据库中左侧（为什么是左侧，详情查看db.py源码，在db中实现了）获取一半的代理然后检测
check_pool方法周期的检测数据库中的代理数量，少于阈值则调用add_to_pool方法补充
API
接口部分用flask实现,比较简单，就不列举出来了
以下是程序入口文件：
# run.py
from Api.api import app
from Schedule.schedule import Schedule
def main():
# 任务类的两个周期进程就是整个调度器
s = Schedule()
s.run()
app.run()
if __name__ == '__main__':
main()
项目地址
作者的项目github
感兴趣的童鞋赶紧下载下来好好调试一下吧