Введение: некоторые страницы информации в рептилии , необходимо войти в. После открытия страницы входа в систему , клиент генерирует печенье, сохранить информацию SessionID в Куки, запрос после входа на сервер после выполнения поколения Cookies. Сервер определяет , что соответствующий Cookies SessionID, и таким образом найти сессию. Если текущий сеанс действителен, сервер определяет , является ли пользователь в настоящее время вошли в систему , вернуться на запрос информации на странице, так что вы можете увидеть страницу после авторизации.
Здесь в основном после получения входа Cookies. Чтобы вернуться Кук можно вручную ввести имя пользователя и пароль в браузере, а затем Cookies переписанная, делая таким образом увеличиваешь искатели ручного назначения нагрузки автоматизированы, необходимо завершить процесс подачи заявки, которая используется для имитации программы входа в системе , Войдите ниже , чтобы понять методы , связанные с моделирования и как сохранить пул Куки.
Симуляция журнала в и ползать GitHub
принцип имитации входа, чтобы сохранить Cookies после входа в систему .
Научитесь журнал моделирования на GitHub, в то время как восхождение на информационную страницу после входа в систему взять, например , как друзья динамических, личной информации и другой контент.
Вы должны использовать библиотеку там: запросы и библиотеку LXML.
1, анализ процесса Войти
с открытым GitHub Войти страницу https://github.com/login, введите имя пользователя и пароль, открытые инструменты для разработчиков, проверить Сохранить вариант журнала, что означает , что дисплей постоянного журнал. Нажмите кнопку для входа, он будет отображаться каждый процесс запроса в соответствии с инструментами разработчика. Нажмите на первый запрос (сессии), в своей странице детали, как показано на рисунке 1-1.
![На фиг. 1-1 сеанса детали запроса поверхность На фиг. 1-1 сеанса детали запроса поверхность](https://img2018.cnblogs.com/blog/1501522/201907/1501522-20190701110721683-510472476.png)
На фиг. 1-1 запроса сеанса , прежде чем поверхности
из фигуры можно видеть , что запрос URL - https://github.com/session, запрос режима является ПОСТ. Читайте дальше, можно наблюдать и Форма запроса данных заголовков из двух частей. Рисунок 1-2.
![Рисунок 1-2 заголовков запроса и детали Форма данных страницы Рисунок 1-2 заголовков запроса и детали Форма данных страницы](https://img2018.cnblogs.com/blog/1501522/201907/1501522-20190701110735252-254471412.png)
Рисунок 1-2 заголовков запроса и детали формы данных страниц
заголовков , который содержит информацию о печенье, Host, Origin, Referer, User-Agent и т.д. Форма данных включает в себя шесть полей, совершающие фиксированная строка Войти, utf8 это проверка символов, authenticity_token больше, предварительное суждение является Base64 зашифрованная строка, Логин это имя пользователя Логин, пароль Пароль войти в систему , webauthn-поддержка сертификации страницы по умолчанию поддерживается.
Исходя из вышеизложенного, содержание не может быть построена теперь Куки и authenticity_token. Следующие продолжают смотреть на то, как эти две части приобретения контента. Доступ перед подписанием страницу входа в систему , которая доступна форма GET. Введите имя пользователя и пароль и нажмите кнопку входа в систему , браузер посылает две части информации, то есть печенье и authenticity_token должен быть установлен , когда вход доступа к странице.
Выход снова войти в систему , ясно печенье, обратно на страницу входа в систему . Повторно входа в систему , перехваченное запрос происходит, как показано на рисунке 1-3.
![Фиг перехвачены запрос 1-3 Фиг перехвачены запрос 1-3](https://img2018.cnblogs.com/blog/1501522/201907/1501522-20190701110748141-401563494.png)
图1-3 截获的请求
在截获的请求中,Response Headers有一个 Set-Cookie 字段。这就是设置 Cookies 的过程。另外,在Response Headers中没有和authenticity_token相关的信息,这个 authenticity_token 可能隐藏在其他地方或者计算出来的。不过在网页的源代码中,搜索 authenticity_token 相关的字段,发现了源代码里面隐藏着此信息,是由一个隐藏式表单元素。如图1-4所示。
![1-4 authenticity_token элементы формы, показанные на фиг. 1-4 authenticity_token элементы формы, показанные на фиг.](https://img2018.cnblogs.com/blog/1501522/201907/1501522-20190701110800482-541615894.png)
图1-4 表单元素之authenticity_token
到此,已经获取到了所有信息,接下来实现模拟登录。
2、模拟登录代码实例
先来定义一个Login 类,初始化一些变量,代码如下所示:
import requests
from lxml import etre
class Login():
"""登录类,初始化一些变量"""
def __init__(self):
self.headers = {
'Referer': 'https://github.com/login',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36',
'Host': 'github.com',
}
self.login_url = 'https://github.com/login'
self.post_url = 'https://github.com/session'
self.logined_url = 'https://github.com/settings/profile' # 登录成功后的页面
self.session = requests.Session()
这段代码中最重要的一个变量是requests库的 Session,它可以维持一个会话,而且可以自动处理 Cookies,不用担心 Cookies的问题。接下来,访问登录页面还要完成两件事,一是通过登录页面获取初始的 Cookies,二是提取出 authenticity_token。下面实现一个token()方法,代码如下所示:
def token(self):
response = self.session.get(self.login_url, headers=self.headers)
selector = etree.HTML(response.text)
token = selector.xpath('//div//input[2]/@value') # 注意获取到的是一个列表类型
return token
这里用Session对象的 get() 方法访问GitHub的登录页面,接着用XPath解析出登录所需的 authenticity_token 信息并返回。现在已经获取初始的 Cookies和authenticity_token,下面开始模拟登录,实现一个 login() 方法,代码如下所示:
def login(self, email, password):
post_data = {
'commit': 'Sign in',
'utf8': '✓',
'authenticity_token': self.token()[0],
'login': email,
'password': password,
'webauthn-support': 'supported'
}
response = self.session.post(self.post_url, data=post_data, headers=self.headers)
if response.status_code == 200:
self.dynamics(response.text)
response = self.session.get(self.logined_url, headers=self.headers)
if response.status_code == 200:
self.profile(response.text)
这里先构造一个表单,复制各个字段,其中email和password是以变量的形式传递。然后再用Session对象的post()方法模拟登录即可。由于 requests 自动处理了重定向信息,登录成功后就可直接跳转到首页,首页有显示所关注人的动态信息,得到响应后调用dynamics()方法对其进行处理。接下来再用Session对象请求个人详情页,调用profile()方法处理个人详情页信息。其中,dynamics()和profile()方法的实现如下所示:
def dynamics(self, html):
"""处理登录成功后的页面,即主页面内容"""
# 页面已经发生跳转,该段代码的输出为空
selector = etree.HTML(html)
print(html)
dynamics = selector.xpath('//div[contains(@class, "news")]//div[contains(@class, "Box")]')
for item in dynamics:
dynamic = ' '.join(item.xpath('.//div[@class="title"]//text()')).strip()
print(dynamic)
def profile(self, html):
"""处理登录成功后的 profile 页面"""
selector = etree.HTML(html)
# 下面获取到的每一项数据都是列表
name = selector.xpath('//input[@id="user_profile_name"]/@value')
url = selector.xpath('//input[@id="user_profile_blog"]/@value')
company = selector.xpath('//input[@id="user_profile_company"]/@value')
location = selector.xpath('//input[@id="user_profile_location"]/@value')
email = selector.xpath('//select[@id="user_profile_email"]/option[@value!=""]/text()')
print(name, email, url, company, location)
if __name__ == '__main__':
login = Login()
login.login(email='email or username', password='password')
这里用XPath对信息进行提取,在dynamics()方法里,提取所有的动态信息并输出(网址已发生跳转,输出为空)。在profile()里,提取个人信息并将其输出。现在完成了整个类的编写,在最后面的if代码块中,先创建Login类对象,然后运行程序,通过调用login()方法传入用户名和密码,成功实现了模拟登录,并且成功输出用户个人信息。
利用requests的Session实现模拟登录操作,最重要的是分析思路,只要各个参数都成功获取,模拟登录就没有问题。登录成功后,就相当于建立一个 Session会话,Session对象维护着Cookies的信息,直接请求就会得到模拟登录成功后的页面。
二、 Cookies池的搭建
不登录直接爬取网站内容可能有下面的限制:
(1)、设置了登录限制的页面不能爬取。如某些论坛设置了登录可查看资源,一些博客设置了登录才可查看全文等。
(2)、有的页面请求过于频繁,访问容易被限制或者IP被封,但是登录后不会出现这些问题。因此登录后被反爬的可能性低。
例如新浪财经官方微博的Ajax接口 https://m.weibo.cn/api/container/getIndex?uid=1804544030&type=uid&page=1&containerid=1076031804544030,这个网站用浏览器直接访问返回JSON格式信息,直接解析JSON即可提取信息。这个接口在没有登录的情况下会有请求频率检测。一段时间内请求过于频繁,请求就会被限制并提示请求过于频繁。
重新打开浏览器窗口,打开 https://passport.weibo.cn/signin/login?entry=mweibo&r=https://m.weibo.cn/,登录微博账号后重新打开这API接口连接可以正常显示。但是登录后一直用同一个账号频繁请求,也会有可能被封号。所在在大规模抓取,就要拥有很多账号,每次请求随机选择一个账号,这样降低单个账号的访问频率,来降低被封的概率。要维护多个账号的登录信息,就要用到Cookies池。下面就Cookies池的搭建做一些了解。
以新浪微博为例实现一个Cookies池的搭建过程。Cookies池中保存了许多微博账号和登录后的Cookies信息,并且Cookies池还需要定时检测每个Cookies的有效性,如果Cookies无效,就删除该Cookies并模拟登录生成的Cookies。同时Cookies池还需要一个重要的接口,即获取随机Cookies的接口,Cookies运行后,只要请求该接口,即可随机获得一个Cookies并用其爬取。由此可知,Cookies池需要自动生成Cookies、定时检测Cookies、提供随机Cookies等功能。
基本要求:Redis数据库正常运行。Python的redis-py、requests、Selelnium和Flask库。以及Chrome浏览器的安装并配置 ChromeDriver。
1、Cookies池架构
Cookies池架构的基本模块分为4块:存储模块、生成模块、检测模块和接口模块。每个模块功能如下:
(1)、存储模块负责存储每个账号的用户名密码以及每个账号对应的Cookies信息,同时还需要提供一些方法来实现方便的存取操作。
(2)、生成模块可生成新的Cookies。从存储模块获取账号的用户名和密码,然后模拟登录目标页面,判断登录成功,就将Cookies返回并交给存储模块存储。
(3)、检测模块定时检测数据库中的Cookies。可设置一个检测连接,不同的站点检测连接不同,检测模块会逐个获取账号对应的Cookies去请求链接,如果返回的状态是有效的,此Cookies就没有失效,否则Cookies失效并移除。接下来等待生成模块重新生成。
(4)、接口模块用API对外提供服务接口。可用的Cookies有多个,可随机返回Cookies的接口,这样保证每个Cookies都有可能被取到。Cookies越多,每个Cookies被取到的概率越小,封号的风险也越小。
2、Cookies 池的实现
对各个模块的实现过程做一些了解。
(1)、存储模块
存储的内容有账号信息和Cookies信息。账号由用户名和密码组成,将用户名和密码在数据库中存储成映射关系。Cookies存成JSON字符串,并且要对应用户名信息,实际也是用户名和Cookies的映射。可以用Redis的Hash结构,需要建立两个Hash结构,用户名和密码Hash,用户名和Cookies的Hash。
Hash的Key对应账号,Value对应密码或者Cookies。还要注意的是,Cookies池要做到可扩展,也就是存储的账号和Cookies不一定只有新浪微博的,其他站点同样可以对接此Cookies池,所以对Hash的名称做二级分类,如存微博账号的Hash名称可以是 accounts:weibo,Cookies的名称可以是 cookies:weibo。如果要扩展知乎的Cookies池,可使用 accounts:zhihu和 cookies:zhihu。
下面代码创建一个存储模块类,用以提供一些Hash的基本操作,代码如下:
首先将一些基本配置放在一个config.py文件,避免各个模块的代码杂乱,config.py 文件的代码如下:
# Redis 数据库地址
REDIS_HOST = '192.168.64.50'
# Redis 端口
REDIS_PORT = 6379
# Redis密码,无密码就为 None
REDIS_PASSWORD = None
# 产生器使用的浏览器
BROWSER_TYPE = 'Chrome'
# 产生器类,如要扩展其他站点,就在这里配置
GENERATOR_MAP = {
'weibo': 'WeiboCookiesGenerator',
}
# 测试类,如要扩展其他站点,就在这里配置
TESTER_MAP = {
'weibo': 'WeiboValidTester',
}
TEST_URL_MAP = {
'weibo': 'https://m.weibo.cn/api/container/getIndex?uid=1804544030&type=uid&page=1&containerid=1076031804544030',
}
# 产生器和验证器循环周期
CYCLE = 120
# API地址和端口
API_HOST = '0.0.0.0'
API_PORT = 5000
# 产生器开关,模拟登录添加Cookies
GENERATOR_PROCESS = False
# 验证器开关,循环检测数据库中Cookies是否可用,不可用删除
VALID_PROCESS = False
# API接口服务
API_PROCESS = True
下面是存储模块的代码,代码如下所示:
import random
import redis
from cookiespool.config import *
class RedisClient():
def __init__(self, type, website, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
"""
初始化Redis连接
:param type:
:param website:
:param host: 地址
:param port: 端口
:param password: 密码
"""
self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)
self.type = type
self.website = website
def name(self):
"""
获取Hash的名称
:return: Hash名称
"""
return "{type}:{website}".format(type=self.type, website=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):
"""
根据键名删除键值对
:param username: 用户名
:return: 删除结果
"""
return self.db.hdel(self.name(), username)
def count(self):
"""
获取数目
:return: 数目
"""
return self.db.hlen(self.name())
def random(self):
"""
随机得到键值,用于随机Cookies获取
:return: 随机Cookies
"""
return random.choice(self.db.hvals(self.name()))
def username(self):
"""
获取所有账户信息
:return: 所有用户名
"""
return self.db.hkeys(self.name())
def all(self):
"""
获取所有键值对
:return: 用户名和密码或Cookies的映射表
"""
return self.db.hgetall(self.name())
if __name__ == '__main__':
conn = RedisClient('accounts', 'weibo')
result = conn.set('michael', 'python')
print(result)
首先创建RedisClient类,初始化__init__()方法的两个关键参数type和website,分别代表类型和站点名称,这是用来拼接Hash名称的两个字段。例如存储账户的Hash,type是accounts、website是webo,如果是存储Cookies的Hash,那么type是cookies、website是weibo。后面的几个字段代表了Redis连接的初始化信息,初始化StrictRedis对象,建立Redis连接。
name()方法用于拼接type和website,组成Hash名称。set()、get()、delete()分别是设置、获取、删除Hash的某一个键值对,count()获取Hash的长度。
random()方法用于从Hash里随机选取一个Cookies并返回。每调用一次random()方法,就获得随机的Cookies,该方法与接口模块对接用来实现获取随机Cookies。
(2)、生成模块
生成模块负责获取各个账号信息并模拟登录,随后生成Cookies并保存。首先获取两个Hash的信息,对比账户的Hash与Cookies的Hash,看看哪些还没有生成Cookies的账号,然后将剩余账号遍历,再去生成Cookies即可。详细代码如下:
import time
from io import BytesIO
from PIL import Image
#from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from os import listdir
from os.path import abspath, dirname
TEMPLATER_FOLDER = dirname(abspath(__file__)) + '/templates/'
class WeiboCookies():
def __init__(self, username, password, browser):
self.url = 'https://passport.weibo.cn/signin/login?entry=mweibo&r=https://m.weibo.cn/'
self.browser = browser
self.wait = WebDriverWait(self.browser, 20)
self.username = username
self.password = password
def open(self):
"""
打开网页输入用户名密码并点击
:return: None
"""
self.browser.delete_all_cookies() # 首先清除浏览器缓存的Cookies
self.browser.get(self.url)
username = self.wait.until(EC.presence_of_element_located((By.ID, 'loginName')))
password = self.wait.until(EC.presence_of_element_located((By.ID, 'loginPassword')))
submit = self.wait.until(EC.element_to_be_clickable((By.ID, 'loginAction')))
username.send_keys(self.username)
password.send_keys(self.password)
time.sleep(1)
submit.click()
def password_error(self):
"""
判断是否密码错误
:return:
"""
try:
return WebDriverWait(self.browser, 5).until(
EC.text_to_be_present_in_element((By.ID, 'errorMsg'), '用户名或密码错误')
)
except TimeoutException:
return False
def login_successfully(self):
"""
判断是否登录成功
:return:
"""
try:
return bool(
WebDriverWait(self.browser, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'lite-iconf-profile'))))
except TimeoutException:
return False
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
try:
img = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'patt-shadow')))
except TimeoutException:
print('未出现验证码')
self.open()
time.sleep(2)
location = img.location
size = img.size
top, bottom, left, right =location['y'], location['y'] + size['height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_image(self):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
return captcha
def is_pixel_equal(self, image1, image2, x, y):
"""
判断两个像素是否相同
:param image1: 图片1
:param image2: 图片2
:param x: 位置x
:param y: 位置y
:return: 像素是否相同
"""
# 取两个图片的像素点
pixel1 = image1.load()[x, y]
pixel2 = image2.load()[x, y]
threshold = 20
if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(
pixel1[2] - pixel2[2]) < threshold:
return True
else:
return False
def same_image(self, image, template):
"""
识别相似验证码
:param image: 待识别的验证码
:param template: 模板
:return:
"""
# 相似度阈值
threshold = 0.99
count = 0
for x in range(image.width):
for y in range(image.height):
# 判断像素是否相同
if self.is_pixel_equal(image, template, x, y):
count += 1
result = float(count) / (image.width * image.height)
if result > threshold:
print('成功匹配')
return True
return False
def detect_image(self, image):
"""
匹配图片
:param image: 图片
:return: 手动顺序
"""
for template_name in listdir(TEMPLATER_FOLDER):
print('正在匹配', template_name)
template = Image.open(TEMPLATER_FOLDER + template_name)
if self.same_image(image, template):
# 返回顺序
numbers = [int(number) for number in list(template_name.split('.')[0])]
print('拖动顺序', numbers)
return numbers
def move(self, numbers):
"""
根据顺序拖动
:param numbers:
:return:
"""
# 获得四个按点
try:
circles = self.browser.find_elements_by_css_selector('.patt-wrap .patt-circ')
dx = dy = 0
for index in range(4):
circle = circles[numbers[index] - 1]
# 如果是第一次循环
if index == 0:
# 点击第一个按点
ActionChains(self.browser) \
.move_to_element_with_offset(circle, circle.size['width'] / 2, circle.size['height'] / 2) \
.click_and_hold().perform()
else:
# 小幅移动次数
times = 30
# 拖动
for i in range(times):
ActionChains(self.browser).move_by_offset(dx / times, dy / times).perform()
time.sleep(1 / times)
# 如果是最后一次循环
if index == 3:
# 松开鼠标
ActionChains(self.browser).release().perform()
else:
# 计算下一次偏移
dx = circle[numbers[index + 1] - 1].location['x'] - circle.location['x']
dy = circle[numbers[index + 1] - 1].location['y'] - circle.location['y']
except:
return False
def get_cookies(self):
"""
获取Cookies
:return:
"""
return self.browser.get_cookies()
def main(self):
"""
破解入口
:return:
"""
self.open()
if self.password_error():
return {
'status': 2,
'content': '用户名或密码错误'
}
# 如果不需验证码直接登录成功
if self.login_successfully():
cookies = self.get_cookies()
return {
'status': 1,
'content': cookies
}
# 获取验证码图片
image = self.get_image()
numbers = self.detect_image(image)
self.move(numbers)
if self.login_successfully():
cookies = self.get_cookies() # content键对应的值是列表,列表内是字典
return {
'status': 1,
'content': cookies
}
else:
return {
'status': 3,
'content': '登录失败'
}
if __name__ == '__main__':
browser = webdriver.Chrome()
result = WeiboCookies('[email protected]', 'password', browser).main()
print(result)
在 WeiboCookies 类中,首先对接了新浪微博的四宫格验证码。在main() 方法中,调用cookies的获取方法,并针对不同的情况返回不同的结果。返回结果类型是字典,并且附有状态码status,在生成模块中可以根据不同的状态码做不同的处理。例如状态码为1时,表示成功获取Cookies,只需将Cookies保存到数据库即可。状态码为2表示用户名和密码错误,这时就应该把当前数据库中存储的账号信息删除。如果状态码为3时,则表示登录失败,此时不能判断是否用户名或密码错误,也不能成功获取Cookies,这时可做一些提示,进行下一个处理即可,完整的实现代码如下所示:
import json
from selenium import webdriver
from selenium.webdriver import DesiredCapabilities
from cookiespool.config import *
from redisdb import RedisClient
from login.weibo.cookies import WeiboCookies
class CookiesGenerator():
def __init__(self, website='default'):
"""
父类,初始化一些对象
:param website: 名称
"""
self.website = website
self.cookies_db = RedisClient('cookies', self.website) # 创建Redis数据库连接,参数是Redis的Hash键要用到的
self.accounts_db = RedisClient('accounts', self.website)
self.init_browser()
def __del__(self):
self.close()
def init_browser(self):
"""
通过browser参数初始化全局浏览器供模拟登录使用
:return:
"""
if BROWSER_TYPE == 'PhantomJS':
caps = DesiredCapabilities.PHANTOMJS
caps["phantomjs.page.settings.userAgent"] = \
'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36'
self.browser = webdriver.PhantomJS(desired_capabilities=caps)
self.browser.set_window_size(1300, 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 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'))
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:
"""
CookiesGenerator.__init__(self, website)
self.website = website
def new_cookies(self, username, password):
"""
生成Cookies
:param username: 用户名
:param password: 密码
:return: 用户名和Cookies
"""
# 调用了 login模块下的cookies.py文件中的 WeiboCookies,self.browser由父类提供
return WeiboCookies(username, password, self.browser).main()
if __name__ == '__main__':
generator = WeiboCookiesGenerator(website='https://passport.weibo.cn/signin/login?entry=mweibo&r=https://m.weibo.cn/')
generator.run()
要扩展其他站点,只要实现new_cookies() 方法即可,然后按此规则返回对应的模拟登录结果,如1代表获取成功,2代表用户名或密码错误。
3、 检测模块
Cookies时间太长导致失效,或者Cookies使用太频繁造成无法正常请求网页。有这样的Cookies需要及时清理或者替换。所以需要一个定时检测模块来遍历Cookies池中的所有Cookies,同时设置好对应的检测链接,用每个Cookies去请求这个链接。请求成功或者状态码合法,则该Cookies有效;请求失败,或者无法获取正常数据,如跳转到登录页面或者验证页面,则此Cookies无效,需要将该Cookies从数据库中移除。
移除Cookies后,前面的生成模块就会检测到Cookies的Hash和账号的Hash相比少了此账号的Cookies,生成模块就会认为这个账号还没有生成Cookies,就用此账号重新登录,此账号的Cookies又被重新更新。
检测模块主要作用是检测Cookies失效,将其从数据库中移除。要考虑通用可扩展性,首先定义一个检测器的父类,声明一些通用组件,代码如下所示:
import json
import requests
from requests.exceptions import ConnectionError
from redisdb import *
class ValidTester():
def __init__(self, website='default'):
self.website = website
self.cookies_db = RedisClient('cookies', self.website)
self.accouts_db = RedisClient('account', 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) # 调用 test 方法测试,子类提供 test 方法
class WeiboValidTester(ValidTester):
"""测试微博,如果要测试其他网站,可创建相应的测试类,并且继承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代码块没有引发异常,就执行下面的try代码块
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)
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)
if __name__ == '__main__':
WeiboValidTester().run()
这段代码中定义了一个父类ValidTester,在其__init__()方法中指定了站点名称website,另外建立两个存储模块连接对象cookies_db 和 accounts_db,分别负责操作Cookies 和账号的hash,run()方法是入口,这里遍历了所有的Cookies,然后调用test()方法进行测试,test()方法由子类来实现,每个子类负责各自不同的网站的检测。如检测微博的可定义为WeiboValidTester,实现其独有的 test() 方法来检测微博的Cookies是否合法,然后做相应的处理。WeiboValidTester类就是继承了ValidTester类的子类。
子类的test()方法首先将Cookies转化为字典,检测Cookies的格式,如果格式不正确,直接将其删除,如果没有格式问题,就拿此 Cookies请求被检测的URL。test()方法在这里检测的是微博,检测的URL可以是某个Ajax接口,为了实现可配置化,将测试URL也定义成字典,如下所示:
TEST_URL_MAP = {'weibo': 'https://m.weibo.cn/'}
要扩展(检测)其他站点,可统一在字典里添加。对微博来说,用Cookies去请求目标站点,同时禁止重定向和设置超时时间,得到响应后检测其返回状态码。返回的是200,则Cookies有效,如果遇到302跳转等情况,一般会跳转到登录页面,则 Cookies已失效,此时将失效的Cookies从Cookies的Hash里移除即可。
4、接口模块
生成模块和检测模块定时运行可完成Cookies实时检测和更新。但Cookies最终是给爬虫用的,同时一个Cookies池可供多个爬虫使用,所以需要定义一个Web接口,爬虫访问该接口就可获取随机的Cookies。这个接口用Flask来搭建,代码如下所示:
import json
from flask import Flask, g
from cookiespool.config import *
from redisdb 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
:param website:
: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='127.0.0.1')
这里random方法实现通用的配置来对接不同的站点,所以接口链接的第一个字段定义为站点名称,第二个字段定义为获取方法,例如 /weibo/random是获取微博的随机Cookies,/zhihu/random是获取知乎的随机Cookies。
5、调度模块
最后再加一个调度模块,让这几个模块配合起来运行,主要工作就是驱动几个模块定时运行,同时各个模块需要在不同的进程上运行,代码实现如下所示:
import time
from multiprocessing import Process
from cookiesapi import app
from cookiespool.config import *
from cookiespool.generator import *
from cookiespool.tester import *
class Scheduler(object):
@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 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 api():
print('API接口开始运行')
app.run(host=API_HOST, port=API_PORT)
def run(self):
if API_PROCESS:
api_process = Process(target=Scheduler.api)
api_process.start()
if GENERATOR_PROCESS:
generate_process = Process(target=Scheduler.generate_cookie)
generate_process.start()
if VALID_PROCESS:
valid_process = Process(target=Scheduler.valid_cookie)
valid_process.start()
代码中用到的两个重要配置是,产生模块类和测试模块类的字典配置,该配置信息在 config 模块中,配置信息如下所示:
# 产生器类,如要扩展其他站点,就在这里配置
GENERATOR_MAP = {
'weibo': 'WeiboCookiesGenerator',
}
# 测试类,如要扩展其他站点,就在这里配置
TESTER_MAP = {
'weibo': 'WeiboValidTester',
}
这样配置可方便动态扩展使用,键名是站点名称,键值是类名。如有需要配置其它站点,可在字典中添加,例如要扩展知乎站点的产生模块,可以这样配置:
GENERATOR_MAP = {
'weibo': 'WeiboCookiesGenerator',
'zhihu': 'ZhihuCookiesGenerator',
}
Scheduler类里对字典遍历,并利用 eval() 方法创建各个类的对象,调用其入口 run() 方法运行各个模块。同时,各个模块的多进程使用了 multiprocessing 中的 Process 类,调用其 start()方法即可启动各个进程。
最后,还需要为各个模块设置一个开关,可以在配置文件中设置开关的开启和关闭状态,如下所示:
# 产生器开关,模拟登录添加Cookies
GENERATOR_PROCESS = False
# 验证器开关,循环检测数据库中Cookies是否可用,不可用删除
VALID_PROCESS = False
# API接口服务
API_PROCESS = True
这几个开关的值为True则开启,为False则为关闭。要让代码能够成功运行,还需要导入账号和密码,为此再写一个导入账号和密码的模块,这个模块的代码如下所示:
from redisdb import RedisClient
conn = RedisClient('accounts', 'weibo')
def set(account, sep='----'):
username, password = account.split(sep)
result = conn.set(username, password)
print('账号', username, '密码', password)
print('录入成功' if result else '录入失败')
def scan():
print('请输入账号密码组,输入exit退出读入')
while True:
account = input()
if account == 'exit':
break
set(account)
if __name__ == '__main__':
scan()
运行这个模块,就将录入的账号和密码存储到 Redis 数据库中。最终,还需要写一个总的运行程序入口模块,这个模块很简单,主要是调用调度模块的run()方法运行程序。
from cookiespool.scheduler import Scheduler
def main():
s = Scheduler()
s.run()
if __name__ == '__main__':
main()
经测试,代码运行成功,各个模块都正常启动,测试模块逐个测试Cookies,生成模块获取还未生成Cookies的账号的Ccookies,各个模块并行运行,互不干扰。这里测试了一个账号,控制台的输出信息如下所示:
Cookies 检测进程开始运行
API接口开始运行
* Serving Flask app "cookiesapi" (lazy loading)
* Environment: production
WARNING: Do not use the development server in a production environment.
Use a production WSGI server instead.
* Debug mode: off
Cookies 检测完成
Cookies生成进程开始运行
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Cookies генерируются пароль учетной записи abcd1234 1234567890 (где выход не соответствует действительности номер счета и пароль учетной записи и пароль)
успешно приобретаемые Cookies { 'M_WEIBOCN_PARAMS': 'Uicode % 3D10000011% 26fid% 3D102803', 'MLOGIN': '1', .. . (позже опущен)}
успешно сохраненные Cookies
Все счета были успешно получены печенье
поколения Cookies завершения
закрытия браузера
в это время случайно сгенерированных в адресной строке браузера , чтобы получить доступ к интерфейсу http://127.0.0.1:5000/weibo/random могут видеть прямо Печенье, как показано на рисунке, проект гусеничного может быть достигнута до тех пор , как интерфейс для запроса о приобретении случайного Куки 1-5.
![Фигура получения случайных куки в браузере 1-5 Фигура получения случайных куки в браузере 1-5](https://img2018.cnblogs.com/blog/1501522/201907/1501522-20190701110815524-395450162.png)
Фигура получения случайных куки в браузере 1-5