问题1：为什么要登陆
很多时候，在没有登录的情况下，我们可以访问一部分页面或请求一些接口，因为毕竟网站本身需要做SEO，不会对所有页面都设置登录限制。但是，不登录直接爬取会有一些弊端，弊端主要有以下两点。
- 设置了登录限制的页面无法爬取。如某论坛设置了登录才可查看资源，某博客设置了登录才可查看全文等，这些页面都需要登录账号才可以查看和爬取。
2.一些页面和接口虽然可以直接请求，但是请求一旦频繁，访问就容易被限制或者IP直接被封，但是登录之后就不会出现这样的问题，因此登录之后被反爬的可能性更低。登录账号可以降低被封禁的概率。
问题2：为什么要搭建cookies池
我们可以尝试登录之后再做爬取，被封禁的几率会小很多，但是也不能完全排除被封禁的风险。如果一直用同一个账号频繁请求，那就有可能遇到请求过于频繁而封号的问题。如果需要做大规模抓取，我们就需要拥有很多账号，每次请求随机选取一个账号，这样就降低了单个账号的访问频率，被封的概率又会大大降低。
与IP代理池不同，Cookies池具有针对性，如果你爬微博就要构建一个微博cookies池，爬知乎就需要构建一个知乎cookies池；而IP代理池是通用的，可供不同的爬虫任务共同使用。
比如，当构建微博cookies池时，我们需要一些微博账号，然后使用selenium模拟登录微博，识别验证码，登录成功后，获取该账号对应的cookies，存入redis数据库，从而维护一个微博cookies池，一个账号对应一个cookies。当构建好cookies池后，我们就可以直接通过cookies进行登录，而不需要再模拟登录，包括输入账号密码，识别验证码等操作。
本篇博客中我们将使用redis，flask搭建一个可扩展的cookies池，这里我们将分别搭建微博和知乎的cookies池，之后任意站点的cookies池都可以通过类似的操作进行搭建，可以不断扩展，维护多个cookies池。
一、本节目标
我们以新浪微博为例来实现一个Cookies池的搭建过程。Cookies池中保存了许多新浪微博账号和登录后的Cookies信息，并且Cookies池还需要定时检测每个Cookies的有效性，如果某Cookies无效，那就删除该Cookies并模拟登录生成新的Cookies。同时Cookies池还需要一个非常重要的接口，即获取随机Cookies的接口，Cookies运行后，我们只需请求该接口，即可随机获得一个Cookies并用其爬取。
由此可见，Cookies池需要有自动生成Cookies、定时检测Cookies、提供随机Cookies等几大核心功能。
二、准备工作
搭建之前肯定需要一些微博的账号。需要安装好Redis数据库并使其正常运行。需要安装Python的RedisPy、requests、Selelnium、Flask库。另外，还需要安装Chrome浏览器并配置好ChromeDriver。
三、Cookies池架构
4个核心模块:
Cookies池架构的基本模块分为4块：存储模块、生成模块、检测模块、接口模块。每个模块的功能如下。
存储模块负责存储每个账号的用户名密码以及每个账号对应的Cookies信息，同时还需要提供一些方法来实现方便的存取操作。
生成模块负责生成新的Cookies。此模块会从存储模块逐个拿取账号的用户名和密码，然后模拟登录目标页面，判断登录成功，就将Cookies返回并交给存储模块存储。
检测模块需要定时检测数据库中的Cookies。在这里我们需要设置一个检测链接，不同的站点检测链接不同，检测模块会逐个拿取账号对应的Cookies去请求链接，如果返回的状态是有效的，那么此Cookies没有失效，否则Cookies失效并移除。接下来等待生成模块重新生成即可。
接口模块需要用API来提供对外服务的接口。由于可用的Cookies可能有多个，我们可以随机返回Cookies的接口，这样保证每个Cookies都有可能被取到。Cookies越多，每个Cookies被取到的概率就会越小，从而减少被封号的风险。
还有配置文件config,py和调度模块scheduler.py
以上设计Cookies池的的基本思路和前面讲的代理池有相似之处。接下来我们设计整体的架构，然后用代码实现该Cookies池。
四、Cookies池的实现
首先分别了解各个模块的实现过程。
配置模块
存储一些各个模块中需要使用的变量和参数配置config.py
# Redis数据库地址、端口、密码
REDIS_HOST = "localhost" # 注意本地就写字符串形式的"localhost"
REDIS_PORT = 6379
REDIS_PASSWORD = None # 密码没有的话，就写None
# 产生器使用的浏览器
BROSER_TYPE = "chrome" # 注意浏览器类型，是字符串形式的
# 产生器类，如扩展其他站点，请在此配置
GENERATOR_MAP = { # 注意字典后的类名也是字符串形式的
"weibo":"WeiboCookiesGenerator",
"zhihu":"ZhihuCookiesGenerator"
}
# 测试类，如扩展其他站点，请在此配置
TESTER_MAP ={
"weibo": "WeiboValidTester",
"zhihu": "WeiboValidTester"
# 'XXX':'XXXCookiesGenerator'
}
TESTER_URL_MAP = {
'weibo': 'https://www.weibo.com',
'zhihu': 'https://www.zhihu.com'
}
# 产生器和验证器循环周期
CYCLE = 120
# API地址和端口
API_HOST = '127.0.0.1' # host是字符串
API_PORT = 5000 # port不是字符串
# 产生器开关，模拟登录添加Cookies
GENERATOR_PROCESS = True
# 验证器开关，循环检测数据库中Cookies是否可用，不可用删除
TESTER_PROCESS = True
# API接口服务
API_PROCESS = True
1. 存储模块
需要存储的内容包括账号信息与Cookies信息。
- 账号由用户名和密码两部分组成，所以可以存成用户名和密码的映射。
- Cookies可以存成JSON字符串，但是后面得需要根据账号来生成Cookies，需要知道哪些账号已经生成了Cookies，哪些没有生成，所以需要同时保存该Cookies对应的用户名信息，其实也是用户名和Cookies的映射。
这里就是两组映射，Redis的Hash有天然的优势，所以这里我们就建立两个Hash。Hash的Key就是账号，Value对应着密码或者Cookies。
注意 : 由于Cookies池需要做到可扩展，存储的账号和Cookies不一定单单只有本例中的微博，其他站点同样可以对接此Cookies池，所以这里Hash的名称可以做二级分类。例如，存账号的Hash名称可以为accounts:weibo，存Cookies的Hash名称可以为cookies:weibo。如要扩展知乎的Cookies池，我们就可以使用accounts:zhihu和cookies:zhihu，这样比较方便。
接下来我们创建一个存储模块类，用以提供一些Hash的基本操作。有两个数据库，一个负责存储每个帐号的用户名和密码，另一个存储用户名和Cookies 信息。
db.py
import random
import redis
from CookiesPool.cookiespool.config import * # 使用*的形式，就可以全部引入，不加config了
class ReidsClient:
def __ini__(self,type,website,host=REDIS_HOST,port=REDIS_PORT,password=REDIS_PASSWORD):
'''
初始化Redis链接
'''
self.db = redis.StrictRedis(host=host,port=port,password=password,decode_responses=True)
self.type = type
self.website = website
@property # 设置成类属性，这样，后面使用就不用加（）
def name(self):
'''
获取表的名字
'''
return"{}:{}".format(self.type,self.website)
def set(self,username,value):
'''
根据用户名设置键名和键值
:param username: 用户名
:param value: 密码或cookies
:return:
'''
return self.db.hset(self.name,username,value)
def get(self,username):
"""
根据键名获取键值
:param username: 用户名
:return:
"""
return self.db.hget(self.name,username)
def delete(self,username): # 注意，一定不要用del，会和内置的del冲突
"""
根据键名删除键值对
:param username: 用户名
:return: 删除结果
"""
return self.db.hdel(self.name,username)
def username(self):
"""
获取所有账户信息 # 在generator模块，会比较accounts和cookies用户名进而，accounts中有而cookies中没有的用户名，会用来模拟登陆，生成cookies
:return: 所有用户名
"""
return self.db.hkeys(self.name)
def all(self):
"""
获取所有键值对
:return: 用户名和密码或Cookies的映射表
"""
return self.db.hgetall(self.name)
def count(self):
"""
获取数目
:return: 数目
"""
return self.db.hlen(self.name) # 注意，使用的是hlen，没有hcount方法
def random(self):
"""
随机得到键值，用于随机Cookies获取
:return: 随机Cookies
"""
return random.choice(self.db.hvals(self.name)) # 注意是random.choice，不是random.random这是取0-1内的小数。
if __name__ == '__main__':
conn = ReidsClient("acounts","weibo")
result = conn.set('kvradspgbnqonhv-eow693@yahoo.com', 'Xdnxwovqp9')
print(result)
（1）新建了一个RedisClient类，因为所有的账号和cookies是存储在redis中的，所以类名是RedisClient，之后对哈希表的操作，都是针对redis数据库的操作，所以要明白存储模块的类名为什么叫RedisClient;
（2）初始化init()方法里，首先初始化StrictRedis对象，建立Redis连接。然后有两个关键参数type和website，分别代表类型和站点名称，它们就是用来拼接Hash名称的两个字段。
（3）name()方法拼接了type和website，组成Hash的名称;如果这是存储账户的Hash，那么此处的type为accounts、website为weibo，如果是存储Cookies的Hash，那么此处的type为cookies、website为weibo。加@property设置成类属性，这样，后面方法使用就不用加（）当做方法来使用了。
（4）set()、get()、delete()方法分别代表设置、获取、删除Hash的某一个键值对;
（5）username()方法，获取accounts或者cookies里的用户名信息。在generator模块，会比较accounts和cookies用户名accounts中有而cookies中没有的用户名，会用来模拟登陆，生成cookies。
（6）all()方法是取出cookies表里面的所有键值对，在tester的时候会将取出来的进行验证，是否有效；
（7）count()获取Hash的长度;
（8）random()方法比较重要，它主要用于从Hash里随机选取一个Cookies并返回。每调用一次random()方法，就会获得随机的Cookies，此方法与接口模块对接即可实现请求接口获取随机Cookies。取的hvals，所以不会取到用户名，在API模块随机获取cookies会用到。
2. 生成模块
生成模块负责获取各个账号信息并模拟登录，随后生成Cookies并保存。我们首先获取两个Hash的信息，看看账户的Hash比Cookies的Hash多了哪些还没有生成Cookies的账号，然后将剩余的账号遍历，再去生成Cookies即可。
generator.py
import json
from selenium import webdriver
from selenium.webdriver import DesiredCapabilities
from CookiesPool.cookiespool.config import *
from CookiesPool.cookiespool.db import RedisClient
from CookiesPool.weibologin.loginweibo import LoginWeibo
from CookiesPool.zhihulogin.loginzhihu import Zhihu
class CookiesGenerator(object):
def __init__(self, website='default'):
"""
父类, 初始化一些对象
:param website: 名称
:param browser: 浏览器, 若不使用浏览器则可设置为 None
"""
self.website = website
self.cookies_db = RedisClient('cookies', self.website) # 存储用户名和cookies
self.accounts_db = RedisClient('accounts', self.website) # 存储用户名和密码
self.init_browser()
def __del__(self):
self.close()
def init_browser(self):
"""
通过browser参数初始化全局浏览器供模拟登录使用
:return:
"""
# self.option = webdriver.ChromeOptions()
# self.option.add_argument('headless')
# self.browser = webdriver.Chrome(executable_path='F:\BaiduNetdiskDownload\cookie_pool\chromedriver',chrome_options=self.option)
if BROWSER_TYPE == 'PhantomJS':
caps = DesiredCapabilities.PHANTOMJS
caps[
"phantomjs.page.settings.userAgent"] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36'
self.browser = webdriver.PhantomJS(desired_capabilities=caps)
self.browser.set_window_size(1400, 500)
elif BROWSER_TYPE == 'Chrome':
self.browser = webdriver.Chrome()
def new_cookies(self, username, password):
"""
新生成Cookies，子类需要重写
:param username: 用户名
:param password: 密码
:return:
"""
raise NotImplementedError
def process_cookies(self, cookies):
"""
处理Cookies
:param cookies:
:return:
"""
dict = {}
for cookie in cookies:
dict[cookie['name']] = cookie['value']
return dict
def run(self):
"""
运行, 得到所有账户, 然后顺次模拟登录
:return:
"""
accounts_usernames = self.accounts_db.usernames()
cookies_usernames = self.cookies_db.usernames()
for username in accounts_usernames:
if not username in cookies_usernames:
password = self.accounts_db.get(username)
print('正在生成Cookies', '账号', username, '密码', password)
result = self.new_cookies(username, password)
# 成功获取
if self.website == 'weibo':
if result.get('status') == 1:
cookies = self.process_cookies(result.get('content'))
print('成功获取到Cookies', cookies)
if self.cookies_db.set(username, json.dumps(cookies)):
print('成功保存Cookies')
# 密码错误，移除账号
elif result.get('status') == 2:
print(result.get('content'))
if self.accounts_db.delete(username):
print('成功删除账号')
else:
print(result.get('content'))
if self.website == 'zhihu':
if result.get('status') == 1:
cookies = result.get('content')
print('成功获取到Cookies', cookies)
if self.cookies_db.set(username, json.dumps(cookies)):
print('成功保存Cookies')
else:
print('所有账号都已经成功获取Cookies')
def close(self):
"""
关闭
:return:
"""
try:
print('Closing Browser')
self.browser.close()
del self.browser
except TypeError:
print('Browser not opened')
class WeiboCookiesGenerator(CookiesGenerator):
def __init__(self, website='weibo'):
"""
初始化操作
:param website: 站点名称
:param browser: 使用的浏览器
"""
CookiesGenerator.__init__(self, website)
self.website = website
def new_cookies(self, username, password):
"""
生成Cookies
:param username: 用户名
:param password: 密码
:return: 用户名和Cookies
"""
return LoginWeibo(username, password, self.browser).login()
class ZhihuCookiesGenerator(CookiesGenerator):
def __init__(self, website='zhihu'):
"""
初始化操作
:param website: 站点名称
:param browser: 使用的浏览器
"""
CookiesGenerator.__init__(self, website)
self.website = website
def new_cookies(self, username, password):
"""
生成Cookies
:param username: 用户名
:param password: 密码
:return: 用户名和Cookies
"""
return Zhihu(username, password).login()
if __name__ == '__main__':
generator = WeiboCookiesGenerator()
generator.run()
逻辑：
（1）定义一个Generator类，初始化方法init()里面要实例化accounts和cookies的db，除此之外还有一个主脚本和new_cookies()
（2）主程序run()方法
先调用2个db的username()方法，将它们各自的用户名取出来。然后通过if判断，将accounts中有，而cookies中没有的username查出来，然后调用new_cookies()生成cookies，因为每个网站对应的有自己的登录方式，所以在此将它们写到各自的子类中分别实现。
模拟登陆完之后，会传递回来一个字典result，根据result中的status键的状态码来判断是否登陆成功。在生成模块里我们可以根据不同的状态码做不同的处理。
result.get('status') ==1成功获取cookies，然后就result.get('content')取出cookies进行加工，具体实现是将cookies中的name-value键值对重新赋值给字典，然后进行json.dum序列化。然后传递给db的set方法进行存储cookies;
result.get('status') == 2就是失败了，账号h或密码错误，从accounts中将此账号的信息删除self.accounts_db.delete(username)
如状态码为3的情况，则代表登录失败的一些错误，此时不能判断是否用户名或密码错误，也不能成功获取Cookies，那么简单提示再进行下一个处理即可。
result ={
'status': 1,
'content': cookies
}
if self.website == 'weibo':
if result.get('status') == 1:
cookies = self.process_cookies(result.get('content'))
print('成功获取到Cookies', cookies)
if self.cookies_db.set(username, json.dumps(cookies)):
print('成功保存Cookies')
# 密码错误，移除账号
elif result.get('status') == 2:
print(result.get('content'))
if self.accounts_db.delete(username):
print('成功删除账号')
else:
print(result.get('content'))
注意：字典中取某个键的值的方式 result.get('content')
（3）如果要扩展其他站点，只需要实现new_cookies()方法即可。
代码运行之后就会遍历一次尚未生成Cookies的账号，模拟登录生成新的Cookies
chaojiying.py
import requests
from hashlib import md5
class Chaojiying(object):
def __init__(self, username, password, soft_id):
self.username = username
self.password = md5(password.encode('utf-8')).hexdigest()
self.soft_id = soft_id
self.base_params = {
'user': self.username,
'pass2': self.password,
'softid': self.soft_id,
}
self.headers = {
'Connection': 'Keep-Alive',
'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
}
def post_pic(self, im, codetype):
"""
im: 图片字节
codetype: 题目类型 参考 http://www.chaojiying.com/price.html
"""
params = {
'codetype': codetype,
}
params.update(self.base_params)
files = {'userfile': ('ccc.jpg', im)}
r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers)
return r.json()
def report_error(self, im_id):
"""
im_id:报错题目的图片ID
"""
params = {
'id': im_id,
}
params.update(self.base_params)
r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
return r.json()
loginweibo.py：登录新浪微博，需要加一个获取Cookies的方法，并针对不同的情况返回不同的结果
import requests
from requests import RequestException
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from CookiesPool.chaojiying import Chaojiying
# 超级鹰用户名、密码、软件ID、
CHAOJIYING_USERNAME = ''
CHAOJIYING_PASSWORD = ''
CHAOJIYING_SOFT_ID =
CHAOJIYING_KIND = 1902
class LoginWeibo():
def __init__(self,username,password,browser):
self.url = 'https://www.weibo.com'
self.browser = browser
self.wait = WebDriverWait(self.browser,20)
self.username = username
self.password = password
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
# def __del__(self):
# self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
#找到用户名和密码输入框
'''
<input id="loginname" type="text" class="W_input" maxlength="128" autocomplete="off" action-data="text=邮箱/会员帐号/手机号" action-type="text_copy" name="username" node-type="username" tabindex="1">
'''
username = self.wait.until(EC.presence_of_element_located((By.ID,'loginname')))
'''
<input type="password" class="W_input" maxlength="24" autocomplete="off" value="" action-type="text_copy" name="password" node-type="password" tabindex="2">
'''
password = self.wait.until(EC.presence_of_element_located((By.NAME,'password')))
#输入用户名和密码
username.send_keys(self.username)
password.send_keys(self.password)
def get_click_button(self):
'''
找到登录按钮
:return:
'''
'''
<a href="javascript:void(0)" class="W_btn_a btn_32px " action-type="btn_submit" node-type="submitBtn" suda-data="key=tblog_weibologin3&value=click_sign" tabindex="6"><span node-type="submitStates">登录</span></a>
'''
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'W_btn_a')))
return button
def login_successfully(self):
"""
判断登陆是否成功
:return:
"""
'''
登录成功才能看到
<em class="W_ficon ficon_mail S_ficon">I</em>
'''
try:
return bool(
WebDriverWait(self.browser,5).until(EC.presence_of_element_located((By.CSS_SELECTOR,'.ficon_mail')))
)
except TimeoutException:
return False
def get_click_image(self,name='captcha.png'):
"""
获取验证码图片
:param name:
:return: 图片对象
"""
try:
'''
<img width="95" height="34" action-type="btn_change_verifycode" node-type="verifycode_image" src="https://login.sina.com.cn/cgi/pin.php?r=88815771&s=0&p=gz-66c0488ef9191010d88bea8c9f3a09fdf3bf">
'''
element = self.wait.until(EC.presence_of_element_located((By.XPATH,'//img[@action-type="btn_change_verifycode"]')))
image_url = element.get_attribute('src')
image = get_html(image_url).content
with open(name, 'wb') as f:
f.write(image)
return image
except NoSuchElementException:
print('')
return None
def password_error(self):
"""
判断是否密码错误
:return:
"""
try:
element = WebDriverWait(self.browser, 5).until(
EC.presence_of_element_located((By.XPATH, '//span[@node-type="text"]')))
print(element.text)
if element.text == '用户名或密码错误。查看帮助':
return True
except TimeoutException:
return False
def get_cookies(self):
"""
获取Cookies
:return:
"""
print(self.browser.get_cookies())
return self.browser.get_cookies()
def login(self):
#打开网址 输入用户名和密码
self.open()
# 点击登录按钮
button = self.get_click_button()
button.click()
if self.password_error():
print('用户名或密码错误')
return {
'status': 2,
'content': '用户名或密码错误'
}
if self.login_successfully():
print('登录成功')
#获取帐号对应的cookies
cookies = self.get_cookies()
return {
'status': 1,
'content': cookies
}
else: #有时会需要验证码
# 获取验证码图片
image = self.get_click_image()
# 识别验证码
result = self.chaojiying.post_pic(image, CHAOJIYING_KIND)
print(result)
# 输入验证码
verifycode = self.wait.until(EC.presence_of_element_located((By.NAME, 'verifycode')))
verifycode.send_keys(result['pic_str'])
# 点击登录按钮
button = self.get_click_button()
button.click()
if self.login_successfully():
print('登录成功')
# 获取帐号对应的cookies
cookies = self.get_cookies()
return {
'status': 1,
'content': cookies
}
else:
self.chaojiying.report_error(result['pic_id'])
self.login()
# return {
# 'status': 3,
# 'content': '登录失败'
# }
def get_html(url):
try:
# 添加User-Agent，放在headers中，伪装成浏览器
headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
response.encoding = response.apparent_encoding
return response
return None
except RequestException:
return None
if __name__ == '__main__':
result = LoginWeibo('','',webdriver.Chrome()).login()
loginzhihu.py：使用requests模拟登录微博，登录成功后，获取帐号对应的cookies
import requests
import re
import execjs
import time
import hmac
from hashlib import sha1
class Zhihu(object):
def __init__(self, username, password):
self.username = username
self.password = password
self.session = requests.session()
self.headers = {
'content-type': 'application/x-www-form-urlencoded',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.109 Safari/537.36',
'x-zse-83': '3_1.1'
}
def login(self):
# 请求login_url,udid_url,captcha_url加载所需要的cookie
login_url = 'https://www.zhihu.com/signup?next=/'
resp = self.session.get(login_url, headers=self.headers)
print("请求{}，响应状态码:{}".format(login_url, resp.status_code))
# print(self.session.cookies.get_dict())
# self.save_file('login',resp.text)
udid_url = 'https://www.zhihu.com/udid'
resp = self.session.post(udid_url, headers=self.headers)
print("请求{}，响应状态码:{}".format(udid_url, resp.status_code))
# print(self.session.cookies.get_dict())
captcha_url = 'https://www.zhihu.com/api/v3/oauth/captcha?lang=en'
resp = self.session.get(captcha_url, headers=self.headers)
print("请求{}，响应状态码:{}".format(captcha_url, resp.status_code))
# print(self.session.cookies.get_dict())
# print(resp.text)
# self.save_file('captcha',resp.text)
# 校验是否需要验证吗，需要则直接退出，还没遇到过需要验证码的
if re.search('true', resp.text):
print('需要验证码')
exit()
# 获取signature参数
self.time_str = str(int(time.time() * 1000))
signature = self.get_signature()
# print(signature)
# 拼接需要加密的字符串
string = "client_id=c3cef7c66a1843f8b3a9e6a1e3160e20&grant_type=password×tamp={}&source=com.zhihu.web&signature={}&username={}&password={}&captcha=&lang=en&ref_source=homepage&utm_source=".format(
self.time_str, signature, self.username, self.password)
# print(string)
# 加密字符串
encrypt_string = self.encrypt(string)
# print(encrypt_string)
# post请求登陆接口
post_url = "https://www.zhihu.com/api/v3/oauth/sign_in"
resp = self.session.post(post_url, data=encrypt_string, headers=self.headers)
print("请求{}，响应状态码:{}".format(post_url, resp.status_code))
print(self.session.cookies.get_dict())
# print(resp.text)
# self.save_file('post', resp.text)
# 校验是否登陆成功
if re.search('user_id', resp.text):
print('登陆成功')
return {
'status': 1,
'content': self.session.cookies.get_dict()
}
else:
print("登陆失败")
return {
'status': 2,
'content': "登陆失败"
}
def test(self):
# 请求个人信息接口查看个人信息
me_url = 'https://www.zhihu.com/api/v4/me'
data = {
'include': 'ad_type;available_message_types,default_notifications_count,follow_notifications_count,vote_thank_notifications_count,messages_count;draft_count;following_question_count;account_status,is_bind_phone,is_force_renamed,email,renamed_fullname;ad_type'
}
resp = self.session.get(me_url, data=data, headers=self.headers)
print("请求{}，响应状态码:{}".format(me_url, resp.status_code))
print(resp.text)
return resp.status_code
# self.save_file('me',resp.text)
def encrypt(self, string):
with open('zhihu.js', 'r', encoding='utf-8') as f:
js = f.read()
result = execjs.compile(js).call('encrypt', string)
return result
def get_signature(self):
h = hmac.new(key='d1b964811afb40118a12068ff74a12f4'.encode('utf-8'), digestmod=sha1)
grant_type = 'password'
client_id = 'c3cef7c66a1843f8b3a9e6a1e3160e20'
source = 'com.zhihu.web'
now = self.time_str
h.update((grant_type + client_id + source + now).encode('utf-8'))
return h.hexdigest()
def save_file(self, name, html):
with open('{}.html'.format(name), 'w', encoding='utf-8') as f:
f.write(html)
if __name__ == "__main__":
account = Zhihu('', '')
account.login()
account.test()
知识点：cookies
根据Netscape公司的规定，Cookie格式如下：
Set－Cookie: NAME=VALUE；Expires=DATE；Path=PATH；Domain=DOMAIN_NAME；SECURE
NAME=VALUE：
这是每一个Cookie均必须有的部分。NAME是该Cookie的名称，VALUE是该Cookie的值。在字符串“NAME=VALUE”中，不含分号、逗号和空格等字符。
Expires=DATE：Expires
变量是一个只写变量，它确定了Cookie有效终止日期。该属性值DATE必须以特定的格式来书写：星期几，DD－MM－YY HH:MM:SS GMT，GMT表示这是格林尼治时间。反之，不以这样的格式来书写，系统将无法识别。该变量可省，如果缺省时，则Cookie的属性值不会保存在用户的硬盘中，而仅仅保存在内存当中，Cookie文件将随着浏览器的关闭而自动消失。
Domain=DOMAIN－NAME:Domain
该变量是一个只写变量，它确定了哪些Internet域中的Web服务器可读取浏览器所存取的Cookie，即只有来自这个域的页面才可以使用Cookie中的信息。这项设置是可选的，如果缺省时，设置Cookie的属性值为该Web服务器的域名。
Path=PATH：Path
属性定义了Web服务器上哪些路径下的页面可获取服务器设置的Cookie。一般如果用户输入的URL中的路径部分从第一个字符开始包含Path属性所定义的字符串，浏览器就认为通过检查。如果Path属性的值为“/”，则Web服务器上所有的WWW资源均可读取该Cookie。同样该项设置是可选的，如果缺省时，则Path的属性值为Web服务器传给浏览器的资源的路径名。可以看出我们借助对Domain和Path两个变量的设置，即可有效地控制Cookie文件被访问的范围。
Secure：
在Cookie中标记该变量，表明只有当浏览器和Web Server之间的通信协议为加密认证协议时，浏览器才向服务器提交相应的Cookie。当前这种协议只有一种，即为HTTPS。
在模拟登陆成功后获得cookies，把cookies字典的name和value提取出来，重新赋值给dict字典，以便后续存储在redis的cookies_weibo中，存储的时候采用set方法，传入采用json.dumps()序列化之后的cookies
def process_cookies(self, cookies):
dict = {}
for cookie in cookies:
dict[cookie['name']] = cookie['value']
return dict
3. 检测模块
我们现在可以用生成模块来生成Cookies，但还是免不了Cookies失效的问题，例如时间太长导致Cookies失效，或者Cookies使用太频繁导致无法正常请求网页。如果遇到这样的Cookies，我们肯定不能让它继续保存在数据库里。
所以我们还需要增加一个定时检测模块，它负责遍历池中的所有Cookies，同时设置好对应的检测链接，我们用一个个Cookies去请求这个链接。如果请求成功，或者状态码合法，那么该Cookies有效；如果请求失败，或者无法获取正常的数据，比如直接跳回登录页面或者跳到验证页面，那么此Cookies无效，我们需要将该Cookies从数据库中移除。
此Cookies移除之后，刚才所说的生成模块就会检测到Cookies的Hash和账号的Hash相比少了此账号的Cookies，生成模块就会认为这个账号还没生成Cookies，那么就会用此账号重新登录，此账号的Cookies又被重新更新。
定时检测数据库中的Cookies 能否正常登录。检测模块需要做的就是检测Cookies失效，然后将其从数据中移除。tester.py：
import json
import re
import requests
from requests.exceptions import ConnectionError
from CookiesPool.cookiespool.db import *
from CookiesPool.cookiespool.config import *
class ValidTester:
def __init__(self,website):
self.website = website
self.accounts_db = RedisClient("counts",self.website)
self.cookies_db = RedisClient("cookies", self.website)
def test(self,username,cookies):
'''
如果要求其子类一定要实现，不实现的时候会导致问题，那么采用raise的方式就很好。
而此时产生的问题分类是NotImplementedError。
:return:
'''
raise NotImplementedError
def run(self):
cookies_group = self.cookies_db.all()
for username,cookies in cookies_group.item():
self.test(username,cookies)
class WeiboValidTester(ValidTester):
def __init__(self,website="weibo"): # 指定website为微博
ValidTester.__init__(self,website)
# super().__init__(website)
def test(self,username,cookies):
print('正在测试Cookies', '用户名', username)
try:
cookies = json.loads(cookies)
except:
print('Cookies不合法', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
return
try:
url = TEST_URL_MAP[self.website] # 从字典里面取出weibo等对应的url，注意取的时候用字典的形式
response = requests.get(url=url,cookies=cookies,timeout=5,allow_redirects=False)
if response.status_code == 200:
html = response.text
ret = re.findall("'islogin']='1'",html)
if ret:
print('Cookies有效', username)
else:
print('Cookies失效', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
else:
print('Cookies失效', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
except ConnectionError as e: # 那就是链接异常
print('发生异常', e.args)
class ZhihuValidTester(ValidTester):
def __init__(self,website="zhihu"): # 指定website为知乎
ValidTester.__init__(self,website)
# super().__init__(website)
def test(self,username,cookies):
print('正在测试Cookies', '用户名', username)
try:
cookies = json.loads(cookies)
except:
print('Cookies不合法', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
return
try:
url = TEST_URL_MAP[self.website] # 从字典里面取出weibo等对应的url，注意取的时候用字典的形式
response = requests.get(url=url,cookies=cookies,timeout=5,allow_redirects=False)
if response.status_code == 200:
html = response.text
ret = re.findall("'islogin']='1'",html)
if ret:
print('Cookies有效', username)
else:
print('Cookies失效', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
else:
print('Cookies失效', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
except ConnectionError as e: # 那就是链接异常
print('发生异常', e.args)
if __name__ == '__main__':
WeiboValidTester().run()
代码解析：
（1）父类
为了实现通用可扩展性，我们首先定义一个检测器的父类，声明一些通用组件，实现如下所示：
class ValidTester(object):
def __init__(self, website='default'):
self.website = website
self.cookies_db = RedisClient('cookies', self.website)
self.accounts_db = RedisClient('accounts', self.website)
def test(self, username, cookies):
raise NotImplementedError
def run(self):
cookies_groups = self.cookies_db.all()
for username, cookies in cookies_groups.items():
self.test(username, cookies)
在这里定义了一个父类叫作ValidTester，在init()方法里指定好站点的名称website，另外建立两个存储模块连接对象cookies_db和accounts_db，分别负责操作Cookies和accounts的Hash，run()方法是入口，在这里是遍历了所有的Cookies，然后调用test()方法进行测试，在这里test()方法是没有实现的，也就是说我们需要写一个子类来重写这个test()方法。
知识点1：****dic.items()
用于提取字典种的key和value值，并将key和它对应的value用元组包围起来，返回值的类型是 dict_items
dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
li = list(dic.items())
print(li) # [('name', 'helen'), ('age', 18), ('sex', 'women')]
知识点2：
Python编程中raise可以实现报出错误的功能，而报错的条件可以由程序员自己去定制。在面向对象编程中，可以先预留一个方法接口不实现，在其子类中实现。如果要求其子类一定要实现，不实现的时候会导致问题，那么采用raise的方式就很好。而此时产生的问题分类是NotImplementedError。
（2）子类
每个子类负责各自不同网站的检测，如检测微博的就可以定义为WeiboValidTester，实现其独有的test()方法来检测微博的Cookies是否合法，然后做相应的处理，所以在这里我们还需要再加一个子类来继承这个ValidTester，重写其test()方法，实现如下：
import json
import requests
from requests.exceptions import ConnectionError
class WeiboValidTester(ValidTester):
def __init__(self, website='weibo'):
ValidTester.__init__(self, website)
def test(self, username, cookies):
print('正在测试Cookies', '用户名', username)
try:
cookies = json.loads(cookies)
except TypeError:
print('Cookies不合法', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
return
try:
test_url = TEST_URL_MAP[self.website]
response = requests.get(test_url, cookies=cookies, timeout=5, allow_redirects=False)
if response.status_code == 200:
print('Cookies有效', username)
print('部分测试结果', response.text[0:50])
else:
print(response.status_code, response.headers)
print('Cookies失效', username)
self.cookies_db.delete(username)
print('删除Cookies', username)
except ConnectionError as e:
print('发生异常', e.args)
首先，在初始化时，继承父类的init(), 有如下2种方式
class Person(Animal):
def __init__(self, name, hp, ad, sex):
Animal.__init__(self, name, hp, ad) # 执行父类方法，需要self
super().__init__(name, hp, ad) # 简写.效果同上。它不需要传参数Person,self。因为它本来就在类里面,自动获取参数
self.sex = sex
然后，test()方法。
第一步：将Cookies转化为字典，检测Cookies的格式，如果格式不正确，直接将其删除。
json.loads（）反序列化，读取。（和dumps相反，loads函数则是将json格式的数据解码，转换为Python字典）
import json
dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
ret = json.dumps(dic,ensure_ascii=False) # 序列化时，不使用ascii码
res = json.loads(ret) # 反序列化
print(type(ret),ret) # <class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
print(type(res),res) # <class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
第二步：1.如果格式没问题，那么就拿此Cookies使用requests模块请求被检测的URL。（检测的URL可以是某个Ajax接口，为了实现可配置化，我们将测试URL也定义成字典）。对微博来说，我们用Cookies去请求目标站点，同时禁止重定向和设置超时时间
2.得到Response之后检测其返回状态码。如果直接返回200状态码，则Cookies有效，否则可能遇到了302跳转等情况，一般会跳转到登录页面，则Cookies已失效。如果Cookies失效，我们将其从Cookies的Hash里移除即可。状态码检测完成之后，还可以通过检测某个标志性的东西，是否存在于新页面。进一步做判断。
4. 接口模块
生成模块和检测模块如果定时运行就可以完成Cookies实时检测和更新。但是Cookies最终还是需要给爬虫来用，同时一个Cookies池可供多个爬虫使用，所以我们还需要定义一个Web接口，爬虫访问此接口便可以取到随机的Cookies。我们采用Flask来实现接口的搭建。提供对外服务的接口。api.py:
接口模块主要分成以下几部分：
1、导入flask，实例化一个Flask对象，在主程序中开启flask服务
from flask import Flask, g
__all__ = ['app']
app = Flask(__name__)
if __name__ == '__main__':
app.run(host=API_HOST, port=API_PORT)
2、通过flask的g对象，使用反射，为flask设置属性，也就是链接redis实例化出我们的cookies_weibo数据库，方便后面调用set()、random()、counts()方法
def get_conn():
for website in GENERATOR_MAP:
print(website)
if not hasattr(g, website):
setattr(g, website + '_cookies', eval('RedisClient' + '("cookies", "' + website + '")'))
setattr(g, website + '_accounts', eval('RedisClient' + '("accounts", "' + website + '")'))
return g
3、通过flask的路由，建立几个视图函数。调用cookies_weibo数据库的set()、random()、counts()方法
完整代码
import json
from flask import Flask, g
from CookiesPool.cookiespool.config import *
from CookiesPool.cookiespool.db import *
__all__ = ['app']
app = Flask(__name__)
@app.route('/')
def index():
return '<h2>Welcome to Cookie Pool System</h2>'
def get_conn():
"""
获取
:return:
"""
for website in GENERATOR_MAP:
print(website)
if not hasattr(g, website):
setattr(g, website + '_cookies', eval('RedisClient' + '("cookies", "' + website + '")'))
setattr(g, website + '_accounts', eval('RedisClient' + '("accounts", "' + website + '")'))
return g
@app.route('/<website>/random')
def random(website):
"""
获取随机的Cookie, 访问地址如 /weibo/random
:return: 随机Cookie
"""
g = get_conn()
cookies = getattr(g, website + '_cookies').random()
return cookies
@app.route('/<website>/add/<username>/<password>')
def add(website, username, password):
"""
添加用户, 访问地址如 /weibo/add/user/password
:param website: 站点
:param username: 用户名
:param password: 密码
:return:
"""
g = get_conn()
print(username, password)
getattr(g, website + '_accounts').set(username, password)
return json.dumps({'status': '1'})
@app.route('/<website>/count')
def count(website):
"""
获取Cookies总数
"""
g = get_conn()
count = getattr(g, website + '_cookies').count()
return json.dumps({'status': '1', 'count': count})
if __name__ == '__main__':
app.run(host=API_HOST, port=API_PORT)
我们同样需要实现通用的配置来对接不同的站点，所以接口链接的第一个字段定义为站点名称，第二个字段定义为获取的方法，例如，/weibo/random是获取微博的随机Cookies，/zhihu/random是获取知乎的随机Cookies。
知识点1：
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run(host='0.0.0.0',port=9000)
- 第1行，引入Flask类，Flask类实现了一个WSGI应用
- 第3行，app是Flask的实例，它接收包或者模块的名字作为参数，但一般都是传递name。让flask.helpers.get_root_path函数通过传入这个名字确定程序的根目录，以便获得静态文件和模板文件的目录。
- 第5~7行，使用app.route装饰器会将URL和执行的视图函数的关系保存到app.url_map属性上。处理URL和视图函数的关系的程序就是路由，这里的视图函数就是hello_world。
- 第9行，使用这个判断可以保证当其他文件引用这个文件的时候（例如“from hello import app”）不会执行这个判断内的代码，也就是不会执行app.run函数。
- 第10行，执行app.run就可以启动服务了。默认Flask只监听虚拟机的本地127.0.0.1这个地址，端口为5000。 而我们对虚拟机做的端口转发端口是9000，所以需要制定host和port参数，0.0.0.0表示监听所有地址，这样就可以在本机访问了。 服务器启动后，会调用werkzeug.serving.run_simple进入轮询，默认使用单进程单线程的werkzeug.serving.BaseWSGIServer处理请求， 实际上还是使用标准库BaseHTTPServer.HTTPServer，通过select.select做0.5秒的“while TRUE”的事件轮询。 当我们访问“http://127.0.0.1:9000/”,通过app.url_map找到注册的“/”这个URL模式,就找到了对应的hello_world函数执行，返回“hello world!”,状态码为200。 如果访问一个不存在的路径，如访问“http://127.0.0.1:9000/a”,Flask找不到对应的模式，就会向浏览器返回“Not Found”，状态码为404'''
要想明白“@app.route()”的工作原理，先看一看Python中的装饰器（就是以“@”开头的）。理解了装饰器的概念，再继续来看路由：
什么是路由：处理URL和函数之间关系的程序。简单的说：路由就是将URL绑定到一个函数上面，这样浏览器客户端向web服务器发送一个URL请求后，服务器中的路由收到这个URL后，能立马找到对应的函数进行处理。
以下三个路由的例子：
@app.route('/')def index():
pass
@app.route('/<username>')
def show_user(username):
pass
@app.route('/post/<int:post_id>')
def show_post(post_id):
pass
- 第1个路由：捕获到 “/”，就进入函数进行处理，里面的函数叫做视图函数。URL从左到右第一个“/”为止一般是首页，因此第1一个路由是处理首页。
- 第2个路由：捕获到 “/<username>” ，其中尖括号<....> 这一部分是动态可变的部分，其中不可以带有斜杠的。而且这个动态部分当做参数传递给了视图函数。
- 第3个路由：捕获到 “/post/<int:post_id>” 其中 “/post/”是静态部分，“<int:post_id>”是动态部分，但是这个动态部分必须是个int类型的整数，同样其中不可以带有斜杠。同样这个动态部分也成为参数传入了视图函数show_post。这个rule是 <converter:name>的形式，而converter除了有int，还有float，path，string。
注意本例中add视图函数，传参规则
@app.route('/<website>/add/<username>/<password>')
def add(website, username, password):
"""
添加用户, 访问地址如 /weibo/add/user/password
"""
g = get_conn()
print(username, password)
getattr(g, website + '_accounts').set(username, password)
return json.dumps({'status': '1'})
还有一些需要注意的URL规则：
- 1.如果路由中的URL规则是有斜杠结尾的，但是用户请求的时候URL结尾没有斜杠，则会自动将用户重定向到带有斜杠的页面。
- 2.如果路由中的URL规则结尾不带斜杠的，但是用户请求时带了斜杠，那么就会返回404错误响应。
- 3.还可以为同一个视图函数，定义多个URL规则：
这指定/users/将是第1页的URL，并且 /users/page/N将是第N页的URL
知识点2：
for 直接循环一个字典时,下面这种情形，出来的结果只有key，没有value
# 如果需要查询多个key，请使用for循环
dic = {'name': 'summer', 'age': 21}
for i in dic:
print(i)
'''
执行输出：
age
Name
'''
知识点3：反射的应用
hasattr(obj, attr):
这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
getattr(obj, attr):
调用这个方法将返回obj中名为attr值的属性的值，例如如果attr为'bar'，则返回obj.bar。
setattr(obj, attr, val):
调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为'bar'，则相当于obj.bar = val
delattr(obj, name)
该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar
在g对象中3次使用反射
# 检查g对象是否有
if not hasattr(g, website):
# 为g对象设置属性，实例化cookies_weibo这个db
setattr(g, website + "_cookies", eval('ReidsClient' + '("cookies",website)'))
# 在获取cookies_weibo这个对象的cookies没有使用常规的obj.random()，而是使用getattr()方法获得
cookies = getattr(g,website + "_cookies").random() # 注意写法，g的website_weibo是g的一个属性，同时它也是一个对象，对象调用random()方法
知识点4：eval()的调用
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
setattr(g, "accounts_"+website,eval('ReidsClient' + '("accounts",website)'))
这里是想使用eval方法实例化一个accounts_weibo对象，ReidisClient是类，实例化时给init()初始化函数传参，也就是之前的type和website
注意:
- eval函数里面是字符串，所以类名外面要加字符串形式;
- 字符串形式的类名使用加号+拼接带字符串的括号；
- 括号里面传参里面传参，如果是确定的字符串就传字符串形式的参数，如果是变量，就传变量，反正括号（）外有引号包围，整体还是字符串；
- website作为变量，以下2种形式等同，建议第一种；
website = "weibo"
arg1 = eval('("accounts",website)')
arg2 = eval('("accounts", "' + website + '")')
print(arg1,type(arg1))
print(arg2,type(arg2))
'''
结果输出：
('accounts', 'weibo') <class 'tuple'>
('accounts', 'weibo') <class 'tuple'>
'''
5. 调度模块
最后，我们再加一个调度模块让这几个模块配合运行起来，主要的工作就是驱动几个模块定时运行，同时各个模块需要在不同进程上运行。
思想：
1.定义一个Scheduler类。里面有一个run方法，是它的主脚本；除此之外还有3个方法generator、tester、api，将generator和tester的map字典进行遍历，同时利用eval()动态新建各个类的对象，调用其入口run()方法运行各个模块;
2.在run()主脚本里，先使用if判断在配置文件中是否开启执行generator、tester、api的开关。如果开启了，就在本模块里通过多进程的方式，使它们各自调用起来。
scheduler.py
import time
from multiprocessing import Process # 注意process和Process都有，要首字母大写的
from CookiesPool.cookiespool.api import app # api模块只引入了app
from CookiesPool.cookiespool.config import * # 其他模块是*
from CookiesPool.cookiespool.generator import *
from CookiesPool.cookiespool.tester import *
class Scheduler(object):
@staticmethod
def generate_cookie(cycle=CYCLE):
while True:
print('Cookies生成进程开始运行')
try:
for website, cls in GENERATOR_MAP.items():
generator = eval(cls + '(website="' + website + '")')
generator.run()
print('Cookies生成完成')
generator.close()
time.sleep(cycle)
except Exception as e:
print(e.args)
@staticmethod
def valid_cookie(cycle=CYCLE):
while True:
print('Cookies检测进程开始运行')
try:
for website, cls in TESTER_MAP.items():
tester = eval(cls + '(website="' + website + '")')
tester.run()
print('Cookies检测完成')
del tester
time.sleep(cycle)
except Exception as e:
print(e.args)
@staticmethod
def api():
app.run(host=API_HOST, port=API_PORT)
def run(self):
if GENERATOR_PROCESS: # 等价于if GENERATOR_PROCESS == True:
generate_process = Process(target=Scheduler.generate_cookie)
generate_process.start()
if VALID_PROCESS:
valid_process = Process(target=Scheduler.valid_cookie)
valid_process.start()
if API_PROCESS:
api_process = Process(target=Scheduler.api)
api_process.start()
if __name__ == '__main__':
scheduler = Scheduler()
scheduler.run()
知识点1：进程
同时，各个模块的多进程使用了multiprocessing中的Process类，调用其start()方法即可启动各个进程。
p.start()
启动进程，并自动调用该子进程中的p.run()
p.run()
进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.join([timeout])
主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
另外，注意target后跟的是函数名，不加括号
知识点2：eval的使用
- 首先，for循环map里有哪些网站；
- 然后，使用eval()实例化tester对象。因为cls是变量，所以没有加引号，后面跟着括号，里面放着参数，第一个website因为是固定的实例化时的变量，所以在括号内没有加引号，而第二个按理来说应该是一个字符串，但是例子中又是一个实实在在的变量，为了做区分，就加了两个引号，并且左右2个加号。
for website, cls in TESTER_MAP.items():
tester = eval(cls + '(website="' + website + '")')
tester.run()
print('Cookies检测完成')
del tester:
至此，我们的Cookies就全部完成了。
