0%

Python

11.1 Charles 的使用

Charles 是一个网络抓包工具,我们可以用它来做 App 的抓包分析,得到 App 运行过程中发生的所有网络请求和响应内容,这就和 Web 端浏览器的开发者工具 Network 部分看到的结果一致。 相比 Fiddler 来说,Charles 的功能更强大,而且跨平台支持更好。所以我们选用 Charles 作为主要的移动端抓包工具,用于分析移动 App 的数据包,辅助完成 App 数据抓取工作。

1. 本节目标

本节我们以京东 App 为例,通过 Charles 抓取 App 运行过程中的网络数据包,然后查看具体的 Request 和 Response 内容,以此来了解 Charles 的用法。

2. 准备工作

请确保已经正确安装 Charles 并开启了代理服务,手机和 Charles 处于同一个局域网下,Charles 代理和 CharlesCA 证书设置好,另外需要开启 SSL 监听,具体的配置可以参考第 1 章的说明。

3. 原理

首先 Charles 运行在自己的 PC 上,Charles 运行的时候会在 PC 的 8888 端口开启一个代理服务,这个服务实际上是一个 HTTP/HTTPS 的代理。 确保手机和 PC 在同一个局域网内,我们可以使用手机模拟器通过虚拟网络连接,也可以使用手机真机和 PC 通过无线网络连接。 设置手机代理为 Charles 的代理地址,这样手机访问互联网的数据包就会流经 Charles,Charles 再转发这些数据包到真实的服务器,服务器返回的数据包再由 Charles 转发回手机,Charles 就起到中间人的作用,所有流量包都可以捕捉到,因此所有 HTTP 请求和响应都可以捕获到。同时 Charles 还有权力对请求和响应进行修改。

4. 抓包

初始状态下 Charles 的运行界面如图 11-1 所示: 图 11-1 Charles 运行界面 Charles 会一直监听 PC 和手机发生的网络数据包,捕获到的数据包就会显示在左侧,随着时间的推移,捕获的数据包越来越多,左侧列表的内容也会越来越多。 可以看到,图中左侧显示了 Charles 抓取到的请求站点,我们点击任意一个条目便可以查看对应请求的详细信息,其中包括 Request、Response 等内容。 接下来清空 Charles 的抓取结果,点击左侧的扫帚按钮即可清空当前捕获到的所有请求。然后点击第二个监听按钮,确保监听按钮是打开的,这表示 Charles 正在监听 App 的网络数据流,如图 11-2 所示。 图 11-2 监听过程 这时打开手机京东,注意一定要提前设置好 Charles 的代理并配置好 CA 证书,否则没有效果。 打开任意一个商品,如 iPhone,然后打开它的商品评论页面,如图 11-3 所示。 图 11-3 评论页面 不断上拉加载评论,可以看到 Charles 捕获到这个过程中京东 App 内发生的所有网络请求,如图 11-4 所示。 图 11-4 监听结果 左侧列表中会出现一个 api.m.jd.com 链接,而且它在不停闪动,很可能就是当前 App 发出的获取评论数据的请求被 Charles 捕获到了。我们点击将其展开,继续上拉刷新评论。随着上拉的进行,此处又会出现一个个网络请求记录,这时新出现的数据包请求确定就是获取评论的请求。 为了验证其正确性,我们点击查看其中一个条目的详情信息。切换到 Contents 选项卡,这时我们发现一些 JSON 数据,核对一下结果,结果有 commentData 字段,其内容和我们在 App 中看到的评论内容一致,如图 11-5 所示。 图 11-5 Json 数据结果 这时可以确定,此请求对应的接口就是获取商品评论的接口。这样我们就成功捕获到了在上拉刷新的过程中发生的请求和响应内容。

5. 分析

现在分析一下这个请求和响应的详细信息。首先可以回到 Overview 选项卡,上方显示了请求的接口 URL,接着是响应状态 Status Code、请求方式 Method 等,如图 11-6 所示。 图 11-6 监听结果 这个结果和原本在 Web 端用浏览器开发者工具内捕获到的结果形式是类似的。 接下来点击 Contents 选项卡,查看该请求和响应的详情信息。 上半部分显示的是 Request 的信息,下半部分显示的是 Response 的信息。比如针对 Reqeust,我们切换到 Headers 选项卡即可看到该 Request 的 Headers 信息,针对 Response,我们切换到 JSON TEXT 选项卡即可看到该 Response 的 Body 信息,并且该内容已经被格式化,如图 11-7 所示。 图 11-7 监听结果 由于这个请求是 POST 请求,所以我们还需要关心的就是 POST 的表单信息,切换到 Form 选项卡即可查看,如图 11-8 所示。 图 11-8 监听结果 这样我们就成功抓取 App 中的评论接口的请求和响应,并且可以查看 Response 返回的 JSON 数据。 至于其他 App,我们同样可以使用这样的方式来分析。如果我们可以直接分析得到请求的 URL 和参数的规律,直接用程序模拟即可批量抓取。

6. 重发

Charles 还有一个强大功能,它可以将捕获到的请求加以修改并发送修改后的请求。点击上方的修改按钮,左侧列表就多了一个以编辑图标为开头的链接,这就代表此链接对应的请求正在被我们修改,如图 11-9 所示。 图 11-9 编辑页面 我们可以将 Form 中的某个字段移除,比如这里将 partner 字段移除,然后点击 Remove。这时我们已经对原来请求携带的 Form Data 做了修改,然后点击下方的 Execute 按钮即可执行修改后的请求,如图 11-10 所示。 图 11-10 编辑页面 可以发现左侧列表再次出现了接口的请求结果,内容仍然不变,如图 11-11 所示。 图 11-11 重新请求后结果 删除 Form 表单中的 partner 字段并没有带来什么影响,所以这个字段是无关紧要的。 有了这个功能,我们就可以方便地使用 Charles 来做调试,可以通过修改参数、接口等来测试不同请求的响应状态,就可以知道哪些参数是必要的哪些是不必要的,以及参数分别有什么规律,最后得到一个最简单的接口和参数形式以供程序模拟调用使用。

7. 结语

以上内容便是通过 Charles 抓包分析 App 请求的过程。通过 Charles,我们成功抓取 App 中流经的网络数据包,捕获原始的数据,还可以修改原始请求和重新发起修改后的请求进行接口测试。 知道了请求和响应的具体信息,如果我们可以分析得到请求的 URL 和参数的规律,直接用程序模拟即可批量抓取,这当然最好不过了。 但是随着技术的发展,App 接口往往会带有密钥,我们并不能直接找到这些规律,那么怎么办呢?接下来,我们将了解利用 Charles 和 mitmdump 直接对接 Python 脚本实时处理抓取到的 Response 的过程。

Python

10.2 Cookies 池的搭建

很多时候,在爬取没有登录的情况下,我们也可以访问一部分页面或请求一些接口,因为毕竟网站本身需要做 SEO,不会对所有页面都设置登录限制。 但是,不登录直接爬取会有一些弊端,弊端主要有以下两点。

  • 设置了登录限制的页面无法爬取。如某论坛设置了登录才可查看资源,某博客设置了登录才可查看全文等,这些页面都需要登录账号才可以查看和爬取。
  • 一些页面和接口虽然可以直接请求,但是请求一旦频繁,访问就容易被限制或者 IP 直接被封,但是登录之后就不会出现这样的问题,因此登录之后被反爬的可能性更低。

下面我们就第二种情况做一个简单的实验。以微博为例,我们先找到一个 Ajax 接口,例如新浪财经官方微博的信息接口 https://m.weibo.cn/api/container/getIndex?uid=1638782947&luicode=20000174 &type=uid&value=1638782947&containerid=1005051638782947,如果用浏览器直接访问,返回的数据是 JSON 格式,如图 10-7 所示,其中包含了新浪财经官方微博的一些信息,直接解析 JSON 即可提取信息。 图 10-7 返回数据 但是,这个接口在没有登录的情况下会有请求频率检测。如果一段时间内访问太过频繁,比如打开这个链接,一直不断刷新,则会看到请求频率过高的提示,如图 10-8 所示。 图 10-8 提示页面 如果重新打开一个浏览器窗口,打开 https://passport.weibo.cn/signin/login?entry=mweibo&r\= https://m.weibo.cn/,登录微博账号之后重新打开此链接,则页面正常显示接口的结果,而未登录的页面仍然显示请求过于频繁,如图 10-9 所示。 图 10-9 对比页面 图中左侧是登录了账号之后请求接口的结果,右侧是未登录账号请求接口的结果,二者的接口链接是完全一样的。未登录状态无法正常访问,而登录状态可以正常显示。 因此,登录账号可以降低被封禁的概率。 我们可以尝试登录之后再做爬取,被封禁的几率会小很多,但是也不能完全排除被封禁的风险。如果一直用同一个账号频繁请求,那就有可能遇到请求过于频繁而封号的问题。 如果需要做大规模抓取,我们就需要拥有很多账号,每次请求随机选取一个账号,这样就降低了单个账号的访问频率,被封的概率又会大大降低。 那么如何维护多个账号的登录信息呢?这时就需要用到 Cookies 池了。接下来我们看看 Cookies 池的构建方法。

1. 本节目标

我们以新浪微博为例来实现一个 Cookies 池的搭建过程。Cookies 池中保存了许多新浪微博账号和登录后的 Cookies 信息,并且 Cookies 池还需要定时检测每个 Cookies 的有效性,如果某 Cookies 无效,那就删除该 Cookies 并模拟登录生成新的 Cookies。同时 Cookies 池还需要一个非常重要的接口,即获取随机 Cookies 的接口,Cookies 运行后,我们只需请求该接口,即可随机获得一个 Cookies 并用其爬取。 由此可见,Cookies 池需要有自动生成 Cookies、定时检测 Cookies、提供随机 Cookies 等几大核心功能。

2. 准备工作

搭建之前肯定需要一些微博的账号。需要安装好 Redis 数据库并使其正常运行。需要安装 Python 的 redis-py、requests、Selelnium 和 Flask 库。另外,还需要安装 Chrome 浏览器并配置好 ChromeDriver,其流程可以参考第一章的安装说明。

3. Cookies 池架构

Cookies 的架构和代理池类似,同样是 4 个核心模块,如图 10-10 所示。 图 10-10 Cookies 池架构 Cookies 池架构的基本模块分为 4 块:存储模块、生成模块、检测模块和接口模块。每个模块的功能如下。

  • 存储模块负责存储每个账号的用户名密码以及每个账号对应的 Cookies 信息,同时还需要提供一些方法来实现方便的存取操作。
  • 生成模块负责生成新的 Cookies。此模块会从存储模块逐个拿取账号的用户名和密码,然后模拟登录目标页面,判断登录成功,就将 Cookies 返回并交给存储模块存储。
  • 检测模块需要定时检测数据库中的 Cookies。在这里我们需要设置一个检测链接,不同的站点检测链接不同,检测模块会逐个拿取账号对应的 Cookies 去请求链接,如果返回的状态是有效的,那么此 Cookies 没有失效,否则 Cookies 失效并移除。接下来等待生成模块重新生成即可。
  • 接口模块需要用 API 来提供对外服务的接口。由于可用的 Cookies 可能有多个,我们可以随机返回 Cookies 的接口,这样保证每个 Cookies 都有可能被取到。Cookies 越多,每个 Cookies 被取到的概率就会越小,从而减少被封号的风险。

以上设计 Cookies 池的基本思路和前面讲的代理池有相似之处。接下来我们设计整体的架构,然后用代码实现该 Cookies 池。

4. Cookies 池的实现

首先分别了解各个模块的实现过程。

存储模块

其实,需要存储的内容无非就是账号信息和 Cookies 信息。账号由用户名和密码两部分组成,我们可以存成用户名和密码的映射。Cookies 可以存成 JSON 字符串,但是我们后面得需要根据账号来生成 Cookies。生成的时候我们需要知道哪些账号已经生成了 Cookies,哪些没有生成,所以需要同时保存该 Cookies 对应的用户名信息,其实也是用户名和 Cookies 的映射。这里就是两组映射,我们自然而然想到 Redis 的 Hash,于是就建立两个 Hash,结构分别如图 10-11 和图 10-12 所示。 图 10-11 用户名密码 Hash 结构 图 10-12 用户名 Cookies Hash 结构 Hash 的 Key 就是账号,Value 对应着密码或者 Cookies。另外需要注意,由于 Cookies 池需要做到可扩展,存储的账号和 Cookies 不一定单单只有本例中的微博,其他站点同样可以对接此 Cookies 池,所以这里 Hash 的名称可以做二级分类,例如存账号的 Hash 名称可以为 accounts:weibo,Cookies 的 Hash 名称可以为 cookies:weibo。如要扩展知乎的 Cookies 池,我们就可以使用 accounts:zhihu 和 cookies:zhihu,这样比较方便。 好,接下来我们就创建一个存储模块类,用以提供一些 Hash 的基本操作,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import random
import redis

class RedisClient(object):
def __init__(self, type, website, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
"""
初始化 Redis 连接
: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 usernames(self):
"""
获取所有账户信息
:return: 所有用户名
"""
return self.db.hkeys(self.name())

def all(self):
"""
获取所有键值对
:return: 用户名和密码或 Cookies 的映射表
"""return self.db.hgetall(self.name())

这里我们新建了一个 RedisClient 类,初始化init() 方法有两个关键参数 type 和 website,分别代表类型和站点名称,它们就是用来拼接 Hash 名称的两个字段。如果这是存储账户的 Hash,那么此处的 type 为 accounts、website 为 weibo,如果是存储 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。

生成模块

生成模块负责获取各个账号信息并模拟登录,随后生成 Cookies 并保存。我们首先获取两个 Hash 的信息,看看账户的 Hash 比 Cookies 的 Hash 多了哪些还没有生成 Cookies 的账号,然后将剩余的账号遍历,再去生成 Cookies 即可。

这里主要逻辑就是找出那些还没有对应 Cookies 的账号,然后再逐个获取 Cookies,代码如下:

​```python
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)

1
2

因为我们对接的是新浪微博,前面我们已经破解了新浪微博的四宫格验证码,在这里我们直接对接过来即可,不过现在需要加一个获取 Cookies 的方法,并针对不同的情况返回不同的结果,逻辑如下所示:

def get_cookies(self):
return self.browser.get_cookies()

def main(self):
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('captcha.png')
numbers = self.detect_image(image)
self.move(numbers)
if self.login_successfully():
    cookies = self.get_cookies()
    return {
        'status': 1,
        'content': cookies
    }
else:
    return {
        'status': 3,
        'content': ' 登录失败 '
    }
1
2

这里返回结果的类型是字典,并且附有状态码 status,在生成模块里我们可以根据不同的状态码做不同的处理。例如状态码为 1 的情况,表示成功获取 Cookies,我们只需要将 Cookies 保存到数据库即可。如状态码为 2 的情况,代表用户名或密码错误,那么我们就应该把当前数据库中存储的账号信息删除。如状态码为 3 的情况,则代表登录失败的一些错误,此时不能判断是否用户名或密码错误,也不能成功获取 Cookies,那么简单提示再进行下一个处理即可,类似代码实现如下所示:

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.accountsdb.delete(username):
print(‘ 成功删除账号 ‘)
else:
print(result.get(‘content’))

1
2
3
4
5
6

如果要扩展其他站点,只需要实现 new_cookies() 方法即可,然后按此处理规则返回对应的模拟登录结果,比如 1 代表获取成功,2 代表用户名或密码错误。 代码运行之后就会遍历一次尚未生成 Cookies 的账号,模拟登录生成新的 Cookies

#### 检测模块

我们现在可以用生成模块来生成 Cookies,但还是免不了 Cookies 失效的问题,例如时间太长导致 Cookies 失效,或者 Cookies 使用太频繁导致无法正常请求网页。如果遇到这样的 Cookies,我们肯定不能让它继续保存在数据库里。 所以我们还需要增加一个定时检测模块,它负责遍历池中的所有 Cookies,同时设置好对应的检测链接,我们用一个个 Cookies 去请求这个链接。如果请求成功,或者状态码合法,那么该 Cookies 有效;如果请求失败,或者无法获取正常的数据,比如直接跳回登录页面或者跳到验证页面,那么此 Cookies 无效,我们需要将该 Cookies 从数据库中移除。 此 Cookies 移除之后,刚才所说的生成模块就会检测到 CookiesHash 和账号的 Hash 相比少了此账号的 Cookies,生成模块就会认为这个账号还没生成 Cookies,那么就会用此账号重新登录,此账号的 Cookies 又被重新更新。 检测模块需要做的就是检测 Cookies 失效,然后将其从数据中移除。 为了实现通用可扩展性,我们首先定义一个检测器的父类,声明一些通用组件,实现如下所示:

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)
1
2

在这里定义了一个父类叫作 ValidTester,在**init**() 方法里指定好站点的名称 website,另外建立两个存储模块连接对象 cookies_db 和 accounts_db,分别负责操作 Cookies 和账号的 Hash,run() 方法是入口,在这里是遍历了所有的 Cookies,然后调用 test() 方法进行测试,在这里 test() 方法是没有实现的,也就是说我们需要写一个子类来重写这个 test() 方法,每个子类负责各自不同网站的检测,如检测微博的就可以定义为 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)
1
2

test() 方法首先将 Cookies 转化为字典,检测 Cookies 的格式,如果格式不正确,直接将其删除,如果格式没问题,那么就拿此 Cookies 请求被检测的 URL。test() 方法在这里检测微博,检测的 URL 可以是某个 Ajax 接口,为了实现可配置化,我们将测试 URL 也定义成字典,如下所示:

TESTURLMAP = {‘weibo’: ‘https://m.weibo.cn/'}

1
2
3
4
5
6

如果要扩展其他站点,我们可以统一在字典里添加。对微博来说,我们用 Cookies 去请求目标站点,同时禁止重定向和设置超时时间,得到响应之后检测其返回状态码。如果直接返回 200 状态码,则 Cookies 有效,否则可能遇到了 302 跳转等情况,一般会跳转到登录页面,则 Cookies 已失效。如果 Cookies 失效,我们将其从 CookiesHash 里移除即可。

#### 接口模块

生成模块和检测模块如果定时运行就可以完成 Cookies 实时检测和更新。但是 Cookies 最终还是需要给爬虫来用,同时一个 Cookies 池可供多个爬虫使用,所以我们还需要定义一个 Web 接口,爬虫访问此接口便可以取到随机的 Cookies。我们采用 Flask 来实现接口的搭建,代码如下所示:

import json
from flask import Flask, g
app = Flask(__name
)

生成模块的配置字典

GENERATOR_MAP = {‘weibo’: ‘WeiboCookiesGenerator’}
@app.route(‘/‘)
def index():
return ‘

Welcome to Cookie Pool System

def get_conn():
for website in GENERATOR_MAP:
if not hasattr(g, website):
setattr(g, website + ‘_cookies’, eval(‘RedisClient’ + ‘(“cookies”, “‘ + website + ‘“)’))
return g

@app.route(‘//random’)
def random(website):
“””
获取随机的 Cookie, 访问地址如 /weibo/random
:return: 随机 Cookie
“””
g = get_conn()
cookies = getattr(g, website + ‘_cookies’).random()
return cookies

1
2
3
4
5
6

我们同样需要实现通用的配置来对接不同的站点,所以接口链接的第一个字段定义为站点名称,第二个字段定义为获取的方法,例如,/weibo/random 是获取微博的随机 Cookies,/zhihu/random 是获取知乎的随机 Cookies。

#### 调度模块

最后,我们再加一个调度模块让这几个模块配合运行起来,主要的工作就是驱动几个模块定时运行,同时各个模块需要在不同进程上运行,实现如下所示:

import time
from multiprocessing import Process
from cookiespool.api 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()
1
2

这里用到了两个重要的配置,即产生模块类和测试模块类的字典配置,如下所示:

产生模块类,如扩展其他站点,请在此配置

GENERATOR_MAP = {‘weibo’: ‘WeiboCookiesGenerator’}

测试模块类,如扩展其他站点,请在此配置

TESTER_MAP = {‘weibo’: ‘WeiboValidTester’}

1
2

这样的配置是为了方便动态扩展使用的,键名为站点名称,键值为类名。如需要配置其他站点可以在字典中添加,如扩展知乎站点的产生模块,则可以配置成:

GENERATOR_MAP = {
‘weibo’: ‘WeiboCookiesGenerator’,
‘zhihu’: ‘ZhihuCookiesGenerator’,
}
1
2

Scheduler 里将字典进行遍历,同时利用 eval() 动态新建各个类的对象,调用其入口 run() 方法运行各个模块。同时,各个模块的多进程使用了 multiprocessing 中的 Process 类,调用其 start() 方法即可启动各个进程。 另外,各个模块还设有模块开关,我们可以在配置文件中自由设置开关的开启和关闭,如下所示:

产生模块开关

GENERATOR_PROCESS = True

验证模块开关

VALID_PROCESS = False

接口模块开关

API_PROCESS = True

1
2

定义为 True 即可开启该模块,定义为 False 即关闭此模块。 至此,我们的 Cookies 就全部完成了。接下来我们将模块同时开启,启动调度器,控制台类似输出如下所示:

API 接口开始运行

  • Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
    Cookies 生成进程开始运行
    Cookies 检测进程开始运行
    正在生成 Cookies 账号 14747223314 密码 asdf1129
    正在测试 Cookies 用户名 14747219309
    Cookies 有效 14747219309
    正在测试 Cookies 用户名 14740626332
    Cookies 有效 14740626332
    正在测试 Cookies 用户名 14740691419
    Cookies 有效 14740691419
    正在测试 Cookies 用户名 14740618009
    Cookies 有效 14740618009
    正在测试 Cookies 用户名 14740636046
    Cookies 有效 14740636046
    正在测试 Cookies 用户名 14747222472
    Cookies 有效 14747222472
    Cookies 检测完成
    验证码位置 420 580 384 544
    成功匹配
    拖动顺序 [1, 4, 2, 3]
    成功获取到 Cookies {‘SUHB’: ‘08J77UIj4w5n_T’, ‘SCF’: ‘AimcUCUVvHjswSBmTswKh0g4kNj4K7_U9k57YzxbqFt4SFBhXq3Lx4YSNO9VuBV841BMHFIaH4ipnfqZnK7W6Qs.’, ‘SSOLoginState’: ‘1501439488’, ‘_T_WM’: ‘99b7d656220aeb9207b5db97743adc02’, ‘M_WEIBOCN_PARAMS’: ‘uicode%3D20000174’, ‘SUB’: ‘_2A250elZQDeRhGeBM6VAR8ifEzTuIHXVXhXoYrDV6PUJbkdBeLXTxkW17ZoYhhJ92N_RGCjmHpfv9TB8OJQ..’}
    成功保存 Cookies
    ```

以上所示是程序运行的控制台输出内容,我们从中可以看到各个模块都正常启动,测试模块逐个测试 Cookies,生成模块获取尚未生成 Cookies 的账号的 Cookies,各个模块并行运行,互不干扰。 我们可以访问接口获取随机的 Cookies,如图 10-13 所示。 图 10-13 接口页面 爬虫只需要请求该接口就可以实现随机 Cookies 的获取。

5. 本节代码

本节代码地址:https://github.com/Python3WebSpider/CookiesPool

6. 结语

以上内容便是 Cookies 池的用法,后文中我们会利用该 Cookies 池和之前所讲的代理池来进行新浪微博的大规模爬取。

Python

我们先以一个最简单的实例来了解模拟登录后页面的抓取过程,其原理在于模拟登录后 Cookies 的维护。

1. 本节目标

本节将讲解以 GitHub 为例来实现模拟登录的过程,同时爬取登录后才可以访问的页面信息,如好友动态、个人信息等内容。 我们应该都听说过 GitHub,如果在我们在 Github 上关注了某些人,在登录之后就会看到他们最近的动态信息,比如他们最近收藏了哪个 Repository,创建了哪个组织,推送了哪些代码。但是退出登录之后,我们就无法再看到这些信息。 如果希望爬取 GitHub 上所关注人的最近动态,我们就需要模拟登录 GitHub。

2. 环境准备

请确保已经安装好了 requests 和 lxml 库,如没有安装可以参考第 1 章的安装说明。

3. 分析登录过程

首先要分析登录的过程,需要探究后台的登录请求是怎样发送的,登录之后又有怎样的处理过程。 如果已经登录 GitHub,先退出登录,同时清除 Cookies。 打开 GitHub 的登录页面,链接为 https://github.com/login,输入 GitHub 的用户名和密码,打开开发者工具,将 Preserve Log 选项勾选上,这表示显示持续日志,如图 10-1 所示。 图 10-1 开发者工具设置 点击登录按钮,这时便会看到开发者工具下方显示了各个请求过程,如图 10-2 所示。 图 10-2 请求过程 点击第一个请求,进入其详情页面,如图 10-3 所示。 图 10-3 详情页面 可以看到请求的 URL 为 https://github.com/session,请求方式为 POST。再往下看,我们观察到它的 Form Data 和 Headers 这两部分内容,如图 10-4 所示。 图 10-4 详情页面 Headers 里面包含了 Cookies、Host、Origin、Referer、User-Agent 等信息。Form Data 包含了 5 个字段,commit 是固定的字符串 Sign in,utf8 是一个勾选字符,authenticity_token 较长,其初步判断是一个 Base64 加密的字符串,login 是登录的用户名,password 是登录的密码。 综上所述,我们现在无法直接构造的内容有 Cookies 和 authenticity_token。下面我们再来探寻一下这两部分内容如何获取。 在登录之前我们会访问到一个登录页面,此页面是通过 GET 形式访问的。输入用户名密码,点击登录按钮,浏览器发送这两部分信息,也就是说 Cookies 和 authenticity_token 一定是在访问登录页的时候设置的。 这时再退出登录,回到登录页,同时清空 Cookies,重新访问登录页,截获发生的请求,如图 10-5 所示。 图 10-5 截获请求 访问登录页面的请求如图所示,Response Headers 有一个 Set-Cookie 字段。这就是设置 Cookies 的过程。 另外,我们发现 Response Headers 没有和 authenticity_token 相关的信息,所以可能 authenticity_token 还隐藏在其他的地方或者是计算出来的。我们再从网页的源码探寻,搜索相关字段,发现源代码里面隐藏着此信息,它是一个隐藏式表单元素,如图 10-6 所示。 图 10-6 表单元素 现在我们已经获取到所有信息,接下来实现模拟登录。

4. 代码实战

首先我们定义一个 Login 类,初始化一些变量:

1
2
3
4
5
6
7
8
9
10
11
class Login(object):
def __init__(self):
self.headers = {
'Referer': 'https://github.com/',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 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() 方法,如下所示:

1
2
3
4
5
6
7
from lxml import etree

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')[0]
return token

我们用 Session 对象的 get() 方法访问 GitHub 的登录页面,然后用 XPath 解析出登录所需的 authenticity_token 信息并返回。 现在已经获取初始的 Cookies 和 authenticity_token,开始模拟登录,实现一个 login() 方法,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def login(self, email, password):
post_data = {
'commit': 'Sign in',
'utf8': '✓',
'authenticity_token': self.token(),
'login': email,
'password': password
}

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() 方法的实现如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
def dynamics(self, html):
selector = etree.HTML(html)
dynamics = selector.xpath('//div[contains(@class, "news")]//div[contains(@class, "alert")]')
for item in dynamics:
dynamic = ' '.join(item.xpath('.//div[@class="title"]//text()')).strip()
print(dynamic)

def profile(self, html):
selector = etree.HTML(html)
name = selector.xpath('//input[@id="user_profile_name"]/@value')[0]
email = selector.xpath('//select[@id="user_profile_email"]/option[@value!=""]/text()')
print(name, email)

在这里,我们仍然使用 XPath 对信息进行提取。在 dynamics() 方法里,我们提取了所有的动态信息,然后将其遍历输出。在 prifile() 方法里,我们提取了个人的昵称和绑定的邮箱,然后将其输出。 这样,整个类的编写就完成了。

5. 运行

我们新建一个 Login 对象,然后运行程序,如下所示:

1
2
3
if __name__ == "__main__":
login = Login()
login.login(email='cqc@cuiqingcai.com', password='password')

在 login() 方法传入用户名和密码,实现模拟登录。 可以看到控制台有类似如下输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
GrahamCampbell  starred  nunomaduro/zero-framework
GrahamCampbell starred nunomaduro/laravel-zero
happyAnger6 created repository happyAnger6/nodejs_chatroom
viosey starred nitely/Spirit
lbgws2 starred Germey/TaobaoMM
EasyChris starred ageitgey/face_recognition
callmewhy starred macmade/GitHubUpdates
sindresorhus starred sholladay/squatter
SamyPesse starred graphcool/chromeless
wbotelhos starred tkadlec/grunt-perfbudget
wbotelhos created repository wbotelhos/eggy
leohxj starred MacGesture/MacGesture
GrahamCampbell starred GrahamCampbell/Analyzer
EasyChris starred golang/go
mitulgolakiya starred veltman/flubber
liaoyuming pushed to student at Germey/SecurityCourse
leohxj starred jasonslyvia/a-cartoon-intro-to-redux-cn
ruanyf starred ericchiang/pup
ruanyf starred bpesquet/thejsway
louwailou forked Germey/ScrapyTutorial to louwailou/ScrapyTutorial
Lving forked shadowsocksr-backup/shadowsocksr to Lving/shadowsocksr
qifuren1985 starred Germey/ADSLProxyPool
QWp6t starred laravel/framework
Germey ['1016903103@qq.com', 'cqc@cuiqingcai.com']

可以发现,我们成功获取到关注的人的动态信息和个人的昵称及绑定邮箱。模拟登录成功!

6. 本节代码

本节代码地址:https://github.com/Python3WebSpider/GithubLogin

7. 结语

我们利用 requests 的 Session 实现了模拟登录操作,其中最重要的还是分析思路,只要各个参数都成功获取,那么模拟登录是没有问题的。 登录成功,这就相当于建立了一个 Session 会话,Session 对象维护着 Cookies 的信息,直接请求就会得到模拟登录成功后的页面。

技术杂谈

最近工作遇到了一个问题。对我们公司的开发小组来说,整个小组的人员都在一个 Repository 下面协作,这个 Repository 里面的文件夹非常多,而我只负责其中的一个功能的开发,我开发的功能所在的文件夹是可以独立维护的,它不依赖于 Repository 里面的其他的任何一个文件夹。

现在我新招到了一位实习生,会跟我一同做这个功能。但很尴尬的是,原则上来说实习生是不能有整个 Repository 的权限的,因为其他的文件夹下可能有包含一些关键信息,那我又怎么把我的这一部分的代码共享给他呢?

有的小伙伴可能说可以用软连接,但是用软连接的话实际上是不行的,因为 git 在 commit 软连接的时候会把它当成文件对待的。

比如说我有一个文件夹啊,我创建了一个软连接到这个文件夹,创建的链接文件实际上是不能以文件夹的形式提交到 Git 仓库的。

那么怎么办呢?硬链接就好了。

我使用的是 Mac OS 系统,可选的方案有 hln、bindfs,但前者是不能链接文件夹的。

一个比较可行的方案就是使用 bindfs,安装方法如下:

1
brew install bindfs

然后使用如下命令即可:

1
bindfs source target

这样的话,比如我大库里面有个文件夹,名字叫做 foo,我就可以在我其他的目录下创建一个对该目录的挂载点 bar。

1
bindfs /var/project1/foo /var/project2/bar

这样我在 project1 下修改 foo 文件夹下的内容,project2 下的 bar 文件夹下的内容也会跟着修改了,我只需要把想要链接的文件夹都放在 project2 下,project2 作为一个独立的 Git 仓库,实习生只能看到我分离出来的内容,看不到大库 project1 下的内容。

这样如果实习生更新了 project2 的 bar 文件夹,提交到了 project2 对应的 Git 仓库,我从上面 pull 下代码,这样 project1 里面的 foo 文件夹也会跟着更新了,这样我再把新的改动提交到 project1 即可。

技术杂谈

做爬虫的同学肯定或多或少会为验证码苦恼过,在最初的时候,大部分验证码都是图形验证码。但是前几年「极验」验证码横空出世,行为验证码变得越来越流行,其中之一的形式便是滑块验证码。 滑块验证码是怎样的呢?如图所示,验证码是一张矩形图,图片左侧会出现一个滑块,右侧会出现一个缺口,下侧会出现一个滑轨。左侧的滑块会随着滑轨的拖动而移动,如果能将左侧滑块正好滑动到右侧缺口处,就算完成了验证。 image-20191107023051548 由于这种验证码交互形式比较友好,且安全性、美观度上也会更高,像这种类似的验证码也变得越来越流行。另外不仅仅是「极验」,其他很多验证码服务商也推出了类似的验证码服务,如「网易易盾」等,上图所示的就是「网易易盾」的滑动验证码。 没错,确实这种滑动验证码的出现让很多网站变得更安全。但是做爬虫的可就苦恼了,如果采用自动化的方法来绕过这种滑动验证码,关键部分在于以下两点:

  • 找出目标缺口的位置。
  • 模拟人的滑动轨迹将滑块滑动到缺口处。

那么问题来了,第一步怎么做呢? 我们怎么识别目标缺口到底在图片的哪个地方?大家可能想到的答案有:

  • 直接手工一把梭。
  • 利用图像处理算法检测缺口处特征。
  • 对接打码平台,获取缺口位置。

另外对于极验来说,之前还有一种方法来识别缺口,那就是对比原图和缺口图的不同之处,通过遍历像素点来找出缺口的位置,但这种方法就比较投机了。如果换家验证码服务商,不给我们原图,我们就无从比较计算了。 总之,我们的目标就是输入一张图,输出缺口的的位置。 上面的方法呢,要么费时费钱、要么准确率不高。那还有没有其他的解决方案呢? 当然有。 现在深度学习这么火,基于深度学习的图像识别技术已经发展得比较成熟了。那么我们能不能利用它来识别缺口位置呢? 答案是,没问题,我们只需要将这个问题归结成一个深度学习的「目标检测」问题就好了。 听到这里,现在可能有的同学已经望而却步了,深度学习?我一点基础都没有呀,咋办? 不用担心,本节介绍的内容全程没有一行代码,不需要任何深度学习基础,我们只需要动动手点一点就能搭建一个识别验证码缺口的深度学习的模型。 这么神奇?是的,那么本节我就带大家来实现一下吧。

目标检测

首先在开始之前简单说下目标检测。什么叫目标检测?顾名思义,就是把我们想找的东西找出来。比如给一张「狗」的图片,如图所示: image-20191107024841075 我们想知道这只狗在哪,它的舌头在哪,找到了就把它们框选出来,这就是目标检测。 经过目标检测算法处理之后,我们期望得到的图片是这样的: image-20191107025008947 可以看到这只狗和它的舌头就被框选出来了,这就完成了一个不错的目标检测。 现在比较流行的目标检测算法有 R-CNN、Fast R-CNN、Faster R-CNN、SSD、YOLO 等,感兴趣同学的可以了解一下,当然看不懂也没有什么影响。 另外再提一个地方,不懂深度学习的同学可以看看,懂的直接跳过下面一段。 我们既然要搭建一个模型来实现一个目标检测算法,那模型怎么知道我们究竟想识别个什么东西?就比如上图,模型咋知道我们想识别的是狗而不是草,是舌头而不是鼻子。这是因为,既然叫深度学习,那得有学习的东西。所以,搭建一个深度学习模型需要训练数据。啥也不告诉模型,模型从哪里去学习?所以,我们得预先有一些标注好位置的图片供模型去学习(训练),比如准备好多张狗的图片和狗的轮廓标注位置,模型在训练过程中会自动学习到图片和标注位置的关系。模型训练好了之后,我们给模型一个没有见过的类似的狗的图,模型也能找出来目标的位置了。 所以,迁移到验证码缺口识别这个任务上来,我们第一步就是给模型提供一些训练数据,训练数据就包括验证码的图片和缺口的位置标注轮廓信息。 好,既然如此,我们第一步就得准备一批验证码数据供标注和训练了。

准备训练数据

这里我用的是网易易盾的验证码,链接为:http://dun.163.com/trial/jigsaw。 我写爬虫爬下来了一些验证码的图,具体怎么爬的就不再赘述了,简单粗暴直接干就行了。 爬下来的验证码图类似这样子: image-20191107030722603 我们不需要滑轨的部分,只保留验证码本身的图片和上面的两个缺口就行了,下面是我准备的一些验证码图: image-20191107030825681 我爬了大约上千张吧,越多越好。当然对于今天的任务来说,其实几十上百张已经就够了。

标注缺口位置

下一步就是把缺口的位置标注出来了。想一想这一步又不太好办,我难道还得每张图片量一量吗?这费了劲了,那咋整啊? 很多同学可能到了这一步就望而却步了,更别提后面的搭建模型训练了。 但我们在文章开头说了,我们不需要写一行代码,点一点就能把模型搭建好。怎么做到的呢?我们可以借助于一些平台和工具。 在这里就要请出今天的主角—— ModelArts 了,这是我发现的华为云的一个深度学习平台,借助它我们可以完成数据标注、模型训练、模型部署三个步骤,最重要的是,我们不需要写代码,只需要点来点去就可以完成了。 让我们进入 ModelArts 来看看: image-20191107031802815 它已经内置了一些深度学习模型,包括图像分类、物体检测、预测分析等等,我们可以直接利用它们来快速搭建属于自己的模型。 在这里我们就切换到「自动学习」的选项卡,创建一个物体检测的项目。 image-20191107032040036 进入项目里面,可以看到最上面会显示三个步骤:

  • 数据标注
  • 模型训练
  • 部署上线

也就是说,经过这三步,我们就可以搭建和部署一个深度学习模型。 页面如图所示: image-20191107032248156 那我们先来第一步——数据标注,这里我把一些验证码的图上传到页面中,在这里我上传了 112 张图: image-20191107032407896 上传完毕之后我们可以点击每一张图片进行标注了,这个平台提供了非常方便的标注功能,只需要鼠标拖拽个轮廓就完成了,112 张图标注完也就几分钟,标注的时候就框选这么个轮廓就行了,如图所示: image-20191107032556453 在这里边界需要把整个缺口的图全框选出来,其中上边界和右边界和标注框相切即可,总之确保标注框正好把缺口图框选出来就行,平台会自动保存和记录标注的像素点位置。 标注完一个,它会提示要添加一个名字,我在这里添加的名字叫「边界」,可以随意指定。 等全部标注完毕,点击「保存并返回」按钮即可。

训练

好,标注完了我们就可以开始训练了。我们在这里不需要写任何的代码,因为平台已经给我们写好了,内置了目标检测的深度学习模型,我们只需要提供数据训练就行了,如图所示: image-20191107033005181 在这里,我们只需要设置一下「最大训练时长」就好了,这么点图片其实几分钟就能训练完了,「最大训练时长」随意填写即可,最小不小于 0.05,填写完了之后就可以点击「开始训练」按钮训练了。 等几分钟,就会训练完成了,可以看到类似如图的页面: image-20191107033211474 这里显示了模型的各个参数和指标。 是的,你没看错,我们没有写任何代码,只过了几分钟,模型就已经训练完,并且可以部署上线了。

部署测试

然后进行下一步,部署上线,直接点击左上角的部署按钮即可: image-20191107033411530 过一会儿, 部署成功之后便可以看到类似这样的界面: image-20191107033446107 在这里我们可以上传任意的验证码图片进行测试,比如我随意上传一张没有标注过的验证码图,然后它会给我们展示出预测结果,如图所示: image-20191107033907756 可以看到,它就把缺口的位置检测出来了,同时在右侧显示了具体的像素值和置信度:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
"detection_classes": [
"边界"
],
"detection_boxes": [
[
16.579784393310547,
331.89569091796875,
124.46369934082031,
435.0449523925781
]
],
"detection_scores": [
0.9999219179153442
]
}

是的,检测的结果还是比较准确的。有了这个结果,我们下一步模拟滑动到标注结果的左边界位置就好了!具体的模拟过程这里就不展开讲了。 另外平台同时还提供了模型部署后的 URL 接口和接口调用指南,也就是我们只需要向接口上传任意的验证码图片,就可以得到缺口的位置了!调用方式可以见:https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0063.html。 嗯,就是这样,我们通过非常简单的操作,不需要任何代码,几分钟就搭建了一个深度学习模型,准确率也还不错。 当然这里我们只标注了 100 多张,标注得越多,标注得越精确,模型的准确率也会越高的。 以上便是利用 ModelArts 搭建滑动验证码缺口识别模型的方法,十分简洁高效。大家感兴趣可以了解下 ModelArts:https://www.huaweicloud.com/product/modelarts.html

技术杂谈

人工智能技术(以下称 AI)是人类优秀的发现和创造之一,它代表着至少几十年的未来。在传统的编程中,工程师将自己的想法和业务变成代码,计算机会根据代码设定的逻辑运行。与之不同的是,AI 使计算机有了「属于自己的思想」,它就像生物一样,能够「看」、「听」、「说」、「动」、「理解」、「分辨」和「思考」。 AI 在图像识别和文本处理方面的效果尤为突出,且已经应用到人类的生活中,例如人脸识别、对话、车牌识别、城市智慧大脑项目中的目标检测和目标分类等。 接下来,我们将了解图像分类的需求、完成任务的前提条件和任务实践。

图像分类以及目标检测的需求

AI 的能力和应用都非常广泛,这里我们主要讨论的是图像分类。 图像分类,其实是对图像中主要目标的识别和归类。例如在很多张随机图片中分辨出哪一张中有直升飞机、哪一张中有狗。或者给定一张图片,让计算机分辨图像中主要目标的类别。 目标检测,指的是检测目标在图片中的位置。例如智慧交通项目中,路面监控摄像头拍摄画面中车辆的位置。目标检测涉及两种技术:分类和定位。也就是说先判定图片中是否存在指定的目标,然后还需要确定目标在图片中的位置。 这样的技术将会应用在人脸识别打卡、视频监控警报、停车场、高速收费站和城市智慧交通等项目当中。

计算机识图的步骤

我们可以将计算机的看作是一个小朋友,它在拥有「分辨」的能力之前,必须经历「看」和「认识」这两个步骤,在看过很多图片后,它就会形成自己的「认知」,也就是获得了「分辨」能力。 简单来说,AI 工程师必须准备很多张不同的图片,并且将一大部分图片中的目标标注出来,然后让计算机提取每张图片中的特征,最后就会形成「认知」。 想一想,你还小的时候,是如何分辨鸭子和鹅的呢? 是不是根据它们的特征进行判断的?

学习和编程实现任务需要的条件

了解完需求和步骤之后,我们还需要准备一些条件:

  • 首先,你必须是一名 IT 工程师。
  • 然后你有一定的数学和统计学习基础。
  • 你还得了解计算机处理图像的方式。
  • 如果图片较多,你需要一台拥有较高算力 GPU 的计算机,否则计算机的「学习」速度会非常慢。

具备以上条件后,再通过短时间(几天或一周)的学习,我们就能够完成图像分类的任务。 讨论个额外的话题,人人都能够做 AI 工程师吗? AI 的门槛是比较高的,首先得具备高等数学、统计学习和编程等基础,然后要有很强的学习能力。对于 IT 工程师来说:

  • 编程基础是没有问题的
  • 学习能力看个人,但花时间、下功夫肯定会有进步
  • 高等数学基础,得好好补
  • 统计学习基础,也得好好补
  • 经济上无压力

如果你想要成为一名 AI 工程师,那么「高学历」几乎是必备的。无论是一线互联网企业或者新崛起的 AI 独角兽,它们为 AI 工程师设立的学历门槛都是「硕士」。除非特别优秀的、才华横溢的大专或本科生,否则是不可能有机会进入这样的企业做 AI 工程师的。 AI 在硬件、软件、数据资料和人才方面都是很费钱的,普通的 IT 工程师也就是学习了解一下,远远达不到产品商用的要求。 普通的中小企业,极少有资质和经济能力吸引高学历且优秀的 AI 工程师,这就导致了资源的聚拢和倾斜。 想要将图像分类技术商用,在让计算机经历「看」、「认识」的步骤并拥有「分辨」能力后,还要将其转换为 Web 服务。 但我只想将人脸识别或者图像分类的功能集成到我的项目当中,就那么困难吗? 我只是一个很小的企业,想要在原来普通的视频监控系统中增加「家人识别」、「陌生人警报」、「火灾警报」和「生物闯入提醒」等功能,没有上述的条件和经济投入,就不能实现了吗? 我好苦恼! 有什么好办法吗?

ModelArts 简介和条件

ModelArts 是华为云推出的产品,它是面向开发者的一站式 AI 开发平台。 它为机器学习与深度学习提供海量数据预处理及半自动化标注、大规模分布式 Training、自动化模型生成,及端-边-云模型按需部署能力,帮助用户快速创建和部署模型,管理全周期 AI 工作流。 它为用户提供了以下可选模式:

  • 零编码经验、零 AI 经验的自动学习模式
  • 有 AI 研发经验的全流程开发模式

同时,它将 AI 开发的整个过程都集成了进来。例如数据标注、模型训练、参数优化、服务部署、开放接口等,这就是「全周期 AI 工作流」。 还有,平台上的操作都是可视化的。 这些条件对于想要将 AI 技术应用于产品,但无奈条件不佳的个人开发者和企业提供了机会,这很重要!可以说 ModelArts) 缩短了 AI 商用的时间,降低了对应的经济成本、时间成本和人力成本。 更贴心的是,华为云 ModelArts) 为用户准备了很多的教程。即使用户没有经验,但只要按照教程指引进行操作,也能够实现自己的 AI 需求。 想想就美滋滋,太棒了! 赶紧体验一下!

图像分类服务实践

这次我们以零 AI 基础和零编码经验的自动学习模式演示如何搭建一个图像分类的 AI 服务。

前期准备和相关设置

首先打开华为云官网,将鼠标移动导航栏的「EI 企业智能」菜单上,并在弹出的选项中选择「AI 开发平台 ModelArts」。 进入到 ModelArts) 主页后,可以浏览一下关于 ModelArts) 的介绍。 点击 Banner 处的「进入控制台」按钮,页面会跳转到 ModelArts 控制台。控制台大体分为几个区域: 区域 2 自动学习模式中有图像分类,将鼠标移动到图标上,并点击弹出的「开始体验」按钮。如果是华为云的新用户,网页会提示我们输入访问密钥和私有访问密钥。 没有密钥的开发者可以点击页面给出的链接并按照指引获取密钥,得到两种密钥后将其填入框中,点击「确定」按钮即可。 此时正式进入项目创建流程中,点击「图像分类」中的「创建项目」按钮(华为云为用户准备了对应的教程,很贴心)。 在创建项目的页面中,我们需要填两三项配置。要注意的是,项目是按需计费的,这次我们只是体验,也没有训练和存储太多数据,所以费用很低,大家不用担心。 项目名称可以根据需求设定一个容易记的,案例中我将其设定为 ImageCLF-Test-Pro。在训练数据的存储选择处,点击输入框中的文件夹图标,在弹出的选项卡中新建 obs 桶 并在创建的桶中新建文件夹 最后输入描述,并点击页面右下角的「创建项目」按钮即可。

上传图片和标注

项目创建好之后,我们需要准备用于训练的多张图片,图片尽量清晰、种类超过 2 类、每种分类的图片数量不少于 5 张。 当然,数据越多、形态越丰富、标注越准确,那么训练结果就会越好,AI 服务的体验就会越好。 这里我准备了一些直升机、坦克和狗的图片,共 45 张。 将其批量导入后勾选同类型的图片,一次性为多张图添加标签。 依次将 3 类图片标注后,左侧图片标注的「未标注」选项卡中的图就会清空,而「已标注」选项卡中可以看到标注好的图片。

训练设置

右侧的标签栏会显示每种分类和对应的图片数量,下方的训练设置可以让我们设置训练时长的上限,高级设置中还有推理时间。 这个我们不必理解它的作用,可以按照默认值进行,也可以稍微调整,例如将训练时长的上限改为 0.2。

开始训练

设置好后点击「开始训练」按钮就会进入训练状态,耐心等待一段时间(图片越少训练时间越短)。 训练页左侧会显示训练状态,例如初始化、运行中和运行成功/失败等。训练完成后,右侧会给出运行时长、准确率、评估结果和训练参数等信息。

服务的自动化部署

我们的目的是搭建一个图像分类的 AI 服务,所以在训练结束后点击左侧的「部署」按钮,此时会进入自动化部署的流程。 稍微等待些许时间(本次约 10 分钟)后,页面提示部署完成,同时页面将会分为 3 栏。 左侧 1 区为部署状态和控制。中间 2 区可以在线测试图片分类,右侧 3 区会显示在线测试的结果(包括准确率),右侧 4 区提供了 API 接口,方便我们将其集成到 Web 应用当中。

在线预测,训练结果测试

我们来测试一下,准备几张没有经过标注的图片,图片中可以包含狗、直升机和坦克。点击中间 2 区的「上传」按钮并选择一张图片,然后点击「预测」按钮。 1 秒中不到,右侧 3 区就会返回本次预测的结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
"predicted_label": "狗",
"scores": [
[
"狗",
"0.840"
],
[
"直升机",
"0.084"
],
[
"坦克",
"0.076"
]
]
}

这次我们上传的是包含狗的图片,返回的预测结果中显示本次预测的标签是「狗」,并且列出了可信度较高的几个类别和对应的可信度(1 为 100% 肯定),其中最高的是 「0.840-狗」。 这次上传直升机的图片试试。 返回的预测结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
"predicted_label": "直升机",
"scores": [
[
"直升机",
"0.810"
],
[
"狗",
"0.114"
],
[
"坦克",
"0.075"
]
]
}

再试试坦克 返回的预测结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
"predicted_label": "坦克",
"scores": [
[
"坦克",
"0.818"
],
[
"狗",
"0.092"
],
[
"直升机",
"0.090"
]
]
}

从几次测试的结果可以看出,预测的结果非常准确,而且给出的可信度也比较高。这次准备的图片并不是很多,形态也不是很丰富,但预测效果却非常好,不得不说华为云 ModelArts 开发团队为此做了很多的优化,甚至比我自己(深度学习入门水平)编写代码用卷积神经网络训练和预测的结果要好。 如果想要将其集成到 Web 应用中,只需要根据页面给出的「接口调用指南」的指引进行操作即可。

释放资源

如果不是真正商用,仅仅作为学习和练习,那么在操作完成后记得点击左侧 1 区的「停止」按钮。然后在华为云导航栏中的搜索框输入「OBS」,点击搜索结果后跳转到 OBS 主页,接着再 OBS 主页点击「管理控制台」,进入到 OBS 控制台中,删除之前创建的桶即可。这样就不会导致资源占用,也不会产生费用了。

小结

体验了一下 ModelArts,我感觉非常奈斯! 每处都有提示或教程指引,操作过程流畅,没有出现卡顿、报错等问题。 批量数据标注太好用了!批量导入、批量标注,自动计数,舒服! 训练速度很快,应该是用了云 GPU,这样就算我的电脑没有显卡也能够快速完成训练。 以前还在考虑,学习 AI 是否需要准备更强的硬件设备,现在好了,在 ModelArts 上操作,就不用考虑这些条件了。 本次我们体验的是自动学习,也就是简洁易用的傻瓜式操作。对于专业的 AI 工程师来说,可以选择全流程开发模式。批量数据标注、本地代码编写、本地调试、云端训练、云端部署等一气呵成。 棒! 有兴趣的开发者可以前往华为云 ModelArts) 体验。


备注:文中配图均出自互联网,通过搜索引擎而来。

Python

前面讲解了代理池的维护和付费代理的相关使用方法,接下来我们进行一下实战演练,利用代理来爬取微信公众号的文章。

1. 本节目标

我们的主要目标是利用代理爬取微信公众号的文章,提取正文、发表日期、公众号等内容,爬取来源是搜狗微信,其链接为 http://weixin.sogou.com/,然后把爬取结果保存到 MySQL 数据库。

2. 准备工作

首先需要准备并正常运行前文中所介绍的代理池。这里需要用的 Python 库有 aiohttp、requests、redis-py、pyquery、Flask、PyMySQL,如这些库没有安装可以参考第 1 章的安装说明。

3. 爬取分析

搜狗对微信公众平台的公众号和文章做了整合。我们可以通过上面的链接搜索到相关的公众号和文章,例如搜索 NBA,可以搜索到最新的文章,如图 9-21 所示。 图 9-21 搜索结果 点击搜索后,搜索结果的 URL 中其实有很多无关 GET 请求参数,将无关的参数去掉,只保留 type 和 query 参数,例如 http://weixin.sogou.com/weixin?type=2&query=NBA,搜索关键词为 NBA,类型为 2,2 代表搜索微信文章。 下拉网页,点击下一页即可翻页,如图 9-22 所示。 图 9-22 翻页列表 注意,如果没有输入账号登录,那只能看到 10 页的内容,登录之后可以看到 100 页内容,如图 9-23 和图 9-24 所示。 图 9-23 不登录的结果 图 9-24 登录后的结果 如果需要爬取更多内容,就需要登录并使用 Cookies 来爬取。 搜狗微信站点的反爬虫能力很强,如连续刷新,站点就会弹出类似如图 9-25 所示的验证。 图 9-25 验证码页面 网络请求出现了 302 跳转,返回状态码为 302,跳转的链接开头为 http://weixin.sogou.com/antispider/,这很明显就是一个反爬虫的验证页面。所以我们得出结论,如果服务器返回状态码为 302 而非 200,则 IP 访问次数太高,IP 被封禁,此请求就是失败了。 如果遇到这种情况,我们可以选择识别验证码并解封,也可以使用代理直接切换 IP。在这里我们采用第二种方法,使用代理直接跳过这个验证。代理使用上一节所讲的代理池,还需要更改检测的 URL 为搜狗微信的站点。 对于这种反爬能力很强的网站来说,如果我们遇到此种返回状态就需要重试。所以我们采用另一种爬取方式,借助数据库构造一个爬取队列,待爬取的请求都放到队列里,如果请求失败了重新放回队列,就会被重新调度爬取。 在这里我们可以采用 Redis 的队列数据结构,新的请求就加入队列,或者有需要重试的请求也放回队列。调度的时候如果队列不为空,那就把一个个请求取出来执行,得到响应后再进行解析,提取出我们想要的结果。 这次我们采用 MySQL 存储,借助 PyMySQL 库,将爬取结果构造为一个字典,实现动态存储。 综上所述,我们本节实现的功能有如下几点。

  • 修改代理池检测链接为搜狗微信站点
  • 构造 Redis 爬取队列,用队列实现请求的存取
  • 实现异常处理,失败的请求重新加入队列
  • 实现翻页和提取文章列表并把对应请求加入队列
  • 实现微信文章的信息的提取
  • 将提取到的信息保存到 MySQL

好,那么接下来我们就用代码来实现一下。

4. 构造 Request

既然我们要用队列来存储请求,那么肯定要实现一个请求 Request 的数据结构,这个请求需要包含一些必要信息,如请求链接、请求头、请求方式、超时时间。另外对于某个请求,我们需要实现对应的方法来处理它的响应,所以需要再加一个 Callback 回调函数。每次翻页请求需要代理来实现,所以还需要一个参数 NeedProxy。如果一个请求失败次数太多,那就不再重新请求了,所以还需要加失败次数的记录。 这些字段都需要作为 Request 的一部分,组成一个完整的 Request 对象放入队列去调度,这样从队列获取出来的时候直接执行这个 Request 对象就好了。 我们可以采用继承 reqeusts 库中的 Request 对象的方式来实现这个数据结构。requests 库中已经有了 Request 对象,它将请求 Request 作为一个整体对象去执行,得到响应后再返回。其实 requests 库的 get()、post() 等方法都是通过执行 Request 对象实现的。 我们首先看看 Request 对象的源码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Request(RequestHooksMixin):
def __init__(self,
method=None, url=None, headers=None, files=None, data=None,
params=None, auth=None, cookies=None, hooks=None, json=None):

# Default empty dicts for dict params.
data = [] if data is None else data
files = [] if files is None else files
headers = {} if headers is None else headers
params = {} if params is None else params
hooks = {} if hooks is None else hooks

self.hooks = default_hooks()
for (k, v) in list(hooks.items()):
self.register_hook(event=k, hook=v)

self.method = method
self.url = url
self.headers = headers
self.files = files
self.data = data
self.json = json
self.params = params
self.auth = auth
self.cookies = cookies

这是 requests 库中 Request 对象的构造方法。这个 Request 已经包含了请求方式、请求链接、请求头这几个属性,但是相比我们需要的还差了几个。我们需要实现一个特定的数据结构,在原先基础上加入上文所提到的额外几个属性。这里我们需要继承 Request 对象重新实现一个请求,将它定义为 WeixinRequest,实现如下:

1
2
3
4
5
6
7
8
9
10
TIMEOUT = 10
from requests import Request

class WeixinRequest(Request):
def __init__(self, url, callback, method='GET', headers=None, need_proxy=False, fail_time=0, timeout=TIMEOUT):
Request.__init__(self, method, url, headers)
self.callback = callback
self.need_proxy = need_proxy
self.fail_time = fail_time
self.timeout = timeout

在这里我们实现了 WeixinRequest 数据结构。init() 方法先调用了 Request 的init() 方法,然后加入额外的几个参数,定义为 callback、need_proxy、fail_time、timeout,分别代表回调函数、是否需要代理爬取、失败次数、超时时间。 我们就可以将 WeixinRequest 作为一个整体来执行,一个个 WeixinRequest 对象都是独立的,每个请求都有自己的属性。例如,我们可以调用它的 callback,就可以知道这个请求的响应应该用什么方法来处理,调用 fail_time 就可以知道这个请求失败了多少次,判断失败次数是不是到了阈值,该不该丢弃这个请求。这里我们采用了面向对象的一些思想。

5. 实现请求队列

接下来我们就需要构造请求队列,实现请求的存取。存取无非就是两个操作,一个是放,一个是取,所以这里利用 Redis 的 rpush() 和 lpop() 方法即可。 另外还需要注意,存取不能直接存 Request 对象,Redis 里面存的是字符串。所以在存 Request 对象之前我们先把它序列化,取出来的时候再将其反序列化,这个过程可以利用 pickle 模块实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from pickle import dumps, loads
from request import WeixinRequest

class RedisQueue():
def __init__(self):
"""初始化 Redis"""
self.db = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)

def add(self, request):
"""
向队列添加序列化后的 Request
:param request: 请求对象
:param fail_time: 失败次数
:return: 添加结果
"""
if isinstance(request, WeixinRequest):
return self.db.rpush(REDIS_KEY, dumps(request))
return False

def pop(self):
"""
取出下一个 Request 并反序列化
:return: Request or None
"""
if self.db.llen(REDIS_KEY):
return loads(self.db.lpop(REDIS_KEY))
else:
return False

def empty(self):
return self.db.llen(REDIS_KEY) == 0

这里实现了一个 RedisQueue,它的 init() 构造方法里面初始化了一个 StrictRedis 对象。随后实现了 add() 方法,首先判断 Request 的类型,如果是 WeixinRequest,那么就把程序就会用 pickle 的 dumps() 方法序列化,然后再调用 rpush() 方法加入队列。pop() 方法则相反,调用 lpop() 方法将请求从队列取出,然后再用 pickle 的 loads() 方法将其转为 WeixinRequest 对象。另外,empty() 方法返回队列是否为空,只需要判断队列长度是否为 0 即可。 在调度的时候,我们只需要新建一个 RedisQueue 对象,然后调用 add() 方法,传入 WeixinRequest 对象,即可将 WeixinRequest 加入队列,调用 pop() 方法,即可取出下一个 WeixinRequest 对象,非常简单易用。

6. 修改代理池

接下来我们要生成请求并开始爬取。在此之前还需要做一件事,那就是先找一些可用代理。 之前代理池检测的 URL 并不是搜狗微信站点,所以我们需要将代理池检测的 URL 修改成搜狗微信站点,以便于把被搜狗微信站点封禁的代理剔除掉,留下可用代理。 现在将代理池的设置文件中的 TEST_URL 修改一下,如 http://weixin.sogou.com/weixin?type=2& query=nba,被本站点封的代理就会减分,正常请求的代理就会赋值为 100,最后留下的就是可用代理。 修改之后将获取模块、检测模块、接口模块的开关都设置为 True,让代理池运行一会,如图 9-26 所示。 图 9-26 代理池运行结果 这样,数据库中留下的 100 分的代理就是针对搜狗微信的可用代理了,如图 9-27 所示。 图 9-27 可用代理列表 同时访问代理接口,接口设置为 5555,访问 http://127.0.0.1:5555/random,即可获取到随机可用代理,如图 9-28 所示。 图 9-28 代理接口 再定义一个函数来获取随机代理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PROXY_POOL_URL = 'http://127.0.0.1:5555/random'

def get_proxy(self):
"""
从代理池获取代理
:return:
"""
try:
response = requests.get(PROXY_POOL_URL)
if response.status_code == 200:
print('Get Proxy', response.text)
return response.text
return None
except requests.ConnectionError:
return None

7. 第一个请求

一切准备工作都做好,下面我们就可以构造第一个请求放到队列里以供调度了。定义一个 Spider 类,实现 start() 方法的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from requests import Session
from db import RedisQueue
from request import WeixinRequest
from urllib.parse import urlencode

class Spider():
base_url = 'http://weixin.sogou.com/weixin'
keyword = 'NBA'
headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4,zh-TW;q=0.2,mt;q=0.2',
'Cache-Control': 'max-age=0',
'Connection': 'keep-alive',
'Cookie': 'IPLOC=CN1100; SUID=6FEDCF3C541C940A000000005968CF55; SUV=1500041046435211; ABTEST=0|1500041048|v1; SNUID=CEA85AE02A2F7E6EAFF9C1FE2ABEBE6F; weixinIndexVisited=1; JSESSIONID=aaar_m7LEIW-jg_gikPZv; ld=Wkllllllll2BzGMVlllllVOo8cUlllll5G@HbZllll9lllllRklll5@@@@@@@@@@',
'Host': 'weixin.sogou.com',
'Upgrade-Insecure-Requests': '1',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
}
session = Session()
queue = RedisQueue()

def start(self):
"""初始化工作"""
# 全局更新 Headers
self.session.headers.update(self.headers)
start_url = self.base_url + '?' + urlencode({'query': self.keyword, 'type': 2})
weixin_request = WeixinRequest(url=start_url, callback=self.parse_index, need_proxy=True)
# 调度第一个请求
self.queue.add(weixin_request)

这里定义了 Spider 类,设置了很多全局变量,比如 keyword 设置为 NBA,headers 就是请求头。在浏览器里登录账号,然后在开发者工具里将请求头复制出来,记得带上 Cookie 字段,这样才能爬取 100 页的内容。然后初始化了 Session 和 RedisQueue 对象,它们分别用来执行请求和存储请求。 首先,start() 方法全局更新了 headers,使得所有请求都能应用 Cookies。然后构造了一个起始 URL:http://weixin.sogou.com/weixin?type=2&query=NBA,随后用改 URL 构造了一个 WeixinRequest 对象。回调函数是 Spider 类的 parse_index() 方法,也就是当这个请求成功之后就用 parse_index() 来处理和解析。need_proxy 参数设置为 True,代表执行这个请求需要用到代理。随后我们调用了 RedisQueue 的 add() 方法,将这个请求加入队列,等待调度。

8. 调度请求

加入第一个请求之后,调度开始了。我们首先从队列中取出这个请求,将它的结果解析出来,生成新的请求加入队列,然后拿出新的请求,将结果解析,再生成新的请求加入队列,这样循环往复执行,直到队列中没有请求,则代表爬取结束。我们用代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
VALID_STATUSES = [200]

def schedule(self):
"""
调度请求
:return:
"""
while not self.queue.empty():
weixin_request = self.queue.pop()
callback = weixin_request.callback
print('Schedule', weixin_request.url)
response = self.request(weixin_request)
if response and response.status_code in VALID_STATUSES:
results = list(callback(response))
if results:
for result in results:
print('New Result', result)
if isinstance(result, WeixinRequest):
self.queue.add(result)
if isinstance(result, dict):
self.mysql.insert('articles', result)
else:
self.error(weixin_request)
else:
self.error(weixin_request)

在这里实现了一个 schedule() 方法,其内部是一个循环,循环的判断是队列不为空。 当队列不为空时,调用 pop() 方法取出下一个请求,调用 request() 方法执行这个请求,request() 方法的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from requests import ReadTimeout, ConnectionError

def request(self, weixin_request):
"""
执行请求
:param weixin_request: 请求
:return: 响应
"""
try:
if weixin_request.need_proxy:
proxy = get_proxy()
if proxy:
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy
}
return self.session.send(weixin_request.prepare(),
timeout=weixin_request.timeout, allow_redirects=False, proxies=proxies)
return self.session.send(weixin_request.prepare(), timeout=weixin_request.timeout, allow_redirects=False)
except (ConnectionError, ReadTimeout) as e:
print(e.args)
return False

这里首先判断这个请求是否需要代理,如果需要代理,则调用 get_proxy() 方法获取代理,然后调用 Session 的 send() 方法执行这个请求。这里的请求调用了 prepare() 方法转化为 Prepared Request,具体的用法可以参考 http://docs.python-requests.org/en/master/user/advanced/#prepared-requests,同时设置 allow_redirects 为 False,timeout 是该请求的超时时间,最后响应返回。 执行 request() 方法之后会得到两种结果:一种是 False,即请求失败,连接错误;另一种是 Response 对象,还需要判断状态码,如果状态码合法,那么就进行解析,否则重新将请求加回队列。 如果状态码合法,解析的时候就会调用 WeixinRequest 的回调函数进行解析。比如这里的回调函数是 parse_index(),其实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pyquery import PyQuery as pq

def parse_index(self, response):
"""
解析索引页
:param response: 响应
:return: 新的响应
"""
doc = pq(response.text)
items = doc('.news-box .news-list li .txt-box h3 a').items()
for item in items:
url = item.attr('href')
weixin_request = WeixinRequest(url=url, callback=self.parse_detail)
yield weixin_request
next = doc('#sogou_next').attr('href')
if next:
url = self.base_url + str(next)
weixin_request = WeixinRequest(url=url, callback=self.parse_index, need_proxy=True)
yield weixin_request

此方法做了两件事:一件事就是获取本页的所有微信文章链接,另一件事就是获取下一页的链接,再构造成 WeixinRequest 之后 yield 返回。 然后,schedule() 方法将返回的结果进行遍历,利用 isinstance() 方法判断返回结果,如果返回结果是 WeixinRequest,就将其重新加入队列。 至此,第一次循环结束。 这时 while 循环会继续执行。队列已经包含第一页内容的文章详情页请求和下一页的请求,所以第二次循环得到的下一个请求就是文章详情页的请求,程序重新调用 request() 方法获取其响应,然后调用其对应的回调函数解析。这时详情页请求的回调方法就不同了,这次是 parse_detail() 方法,此方法实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
def parse_detail(self, response):
"""
解析详情页
:param response: 响应
:return: 微信公众号文章
"""
doc = pq(response.text)
data = {'title': doc('.rich_media_title').text(),
'content': doc('.rich_media_content').text(),
'date': doc('#post-date').text(),
'nickname': doc('#js_profile_qrcode> div > strong').text(),
'wechat': doc('#js_profile_qrcode> div > p:nth-child(3) > span').text()}
yield data

这个方法解析了微信文章详情页的内容,提取出它的标题、正文文本、发布日期、发布人昵称、微信公众号名称,将这些信息组合成一个字典返回。 结果返回之后还需要判断类型,如是字典类型,程序就调用 mysql 对象的 insert() 方法将数据存入数据库。 这样,第二次循环执行完毕。 第三次循环、第四次循环,循环往复,每个请求都有各自的回调函数,索引页解析完毕之后会继续生成后续请求,详情页解析完毕之后会返回结果以便存储,直到爬取完毕。 现在,整个调度就完成了。 我们完善一下整个 Spider 代码,实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
from requests import Session
from config import *
from db import RedisQueue
from mysql import MySQL
from request import WeixinRequest
from urllib.parse import urlencode
import requests
from pyquery import PyQuery as pq
from requests import ReadTimeout, ConnectionError

class Spider():
base_url = 'http://weixin.sogou.com/weixin'
keyword = 'NBA'
headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4,zh-TW;q=0.2,mt;q=0.2',
'Cache-Control': 'max-age=0',
'Connection': 'keep-alive',
'Cookie': 'IPLOC=CN1100; SUID=6FEDCF3C541C940A000000005968CF55; SUV=1500041046435211; ABTEST=0|1500041048|v1; SNUID=CEA85AE02A2F7E6EAFF9C1FE2ABEBE6F; weixinIndexVisited=1; JSESSIONID=aaar_m7LEIW-jg_gikPZv; ld=Wkllllllll2BzGMVlllllVOo8cUlllll5G@HbZllll9lllllRklll5@@@@@@@@@@',
'Host': 'weixin.sogou.com',
'Upgrade-Insecure-Requests': '1',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
}
session = Session()
queue = RedisQueue()
mysql = MySQL()

def get_proxy(self):
"""
从代理池获取代理
:return:
"""
try:
response = requests.get(PROXY_POOL_URL)
if response.status_code == 200:
print('Get Proxy', response.text)
return response.text
return None
except requests.ConnectionError:
return None

def start(self):
"""初始化工作"""
# 全局更新 Headers
self.session.headers.update(self.headers)
start_url = self.base_url + '?' + urlencode({'query': self.keyword, 'type': 2})
weixin_request = WeixinRequest(url=start_url, callback=self.parse_index, need_proxy=True)
# 调度第一个请求
self.queue.add(weixin_request)

def parse_index(self, response):
"""
解析索引页
:param response: 响应
:return: 新的响应
"""
doc = pq(response.text)
items = doc('.news-box .news-list li .txt-box h3 a').items()
for item in items:
url = item.attr('href')
weixin_request = WeixinRequest(url=url, callback=self.parse_detail)
yield weixin_request
next = doc('#sogou_next').attr('href')
if next:
url = self.base_url + str(next)
weixin_request = WeixinRequest(url=url, callback=self.parse_index, need_proxy=True)
yield weixin_request

def parse_detail(self, response):
"""
解析详情页
:param response: 响应
:return: 微信公众号文章
"""
doc = pq(response.text)
data = {'title': doc('.rich_media_title').text(),
'content': doc('.rich_media_content').text(),
'date': doc('#post-date').text(),
'nickname': doc('#js_profile_qrcode> div > strong').text(),
'wechat': doc('#js_profile_qrcode> div > p:nth-child(3) > span').text()}
yield data

def request(self, weixin_request):
"""
执行请求
:param weixin_request: 请求
:return: 响应
"""
try:
if weixin_request.need_proxy:
proxy = self.get_proxy()
if proxy:
proxies = {
'http': 'http://' + proxy,
'https': 'https://' + proxy
}
return self.session.send(weixin_request.prepare(),
timeout=weixin_request.timeout, allow_redirects=False, proxies=proxies)
return self.session.send(weixin_request.prepare(), timeout=weixin_request.timeout, allow_redirects=False)
except (ConnectionError, ReadTimeout) as e:
print(e.args)
return False

def error(self, weixin_request):
"""
错误处理
:param weixin_request: 请求
:return:
"""
weixin_request.fail_time = weixin_request.fail_time + 1
print('Request Failed', weixin_request.fail_time, 'Times', weixin_request.url)
if weixin_request.fail_time < MAX_FAILED_TIME:
self.queue.add(weixin_request)

def schedule(self):
"""
调度请求
:return:
"""
while not self.queue.empty():
weixin_request = self.queue.pop()
callback = weixin_request.callback
print('Schedule', weixin_request.url)
response = self.request(weixin_request)
if response and response.status_code in VALID_STATUSES:
results = list(callback(response))
if results:
for result in results:
print('New Result', result)
if isinstance(result, WeixinRequest):
self.queue.add(result)
if isinstance(result, dict):
self.mysql.insert('articles', result)
else:
self.error(weixin_request)
else:
self.error(weixin_request)

def run(self):
"""
入口
:return:
"""
self.start()
self.schedule()

if __name__ == '__main__':
spider = Spider()
spider.run()

最后,我们加了一个 run() 方法作为入口,启动的时候只需要执行 Spider 的 run() 方法即可。

9. MySQL 存储

整个调度模块完成了,上面还没提及到的就是存储模块,在这里还需要定义一个 MySQL 类供存储数据,实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PASSWORD = 'foobared'
REDIS_KEY = 'weixin'

import pymysql
from config import *

class MySQL():
def __init__(self, host=MYSQL_HOST, username=MYSQL_USER, password=MYSQL_PASSWORD, port=MYSQL_PORT,
database=MYSQL_DATABASE):
"""
MySQL 初始化
:param host:
:param username:
:param password:
:param port:
:param database:
"""
try:
self.db = pymysql.connect(host, username, password, database, charset='utf8', port=port)
self.cursor = self.db.cursor()
except pymysql.MySQLError as e:
print(e.args)

def insert(self, table, data):
"""
插入数据
:param table:
:param data:
:return:
"""
keys = ', '.join(data.keys())
values = ', '.join(['% s'] * len(data))
sql_query = 'insert into % s (% s) values (% s)' % (table, keys, values)
try:
self.cursor.execute(sql_query, tuple(data.values()))
self.db.commit()
except pymysql.MySQLError as e:
print(e.args)
self.db.rollback()

init() 方法初始化了 MySQL 连接,需要 MySQL 的用户、密码、端口、数据库名等信息。数据库名为 weixin,需要自己创建。 insert() 方法传入表名和字典即可动态构造 SQL,在 5.2 节中也有讲到,SQL 构造之后执行即可插入数据。 我们还需要提前建立一个数据表,表名为 articles,建表的 SQL 语句如下:

1
2
3
4
5
6
7
8
CREATE TABLE `articles` (`id` int(11) NOT NULL,
`title` varchar(255) NOT NULL,
`content` text NOT NULL,
`date` varchar(255) NOT NULL,
`wechat` varchar(255) NOT NULL,
`nickname` varchar(255) NOT NULL
) DEFAULT CHARSET=utf8;
ALTER TABLE `articles` ADD PRIMARY KEY (`id`);

现在,我们的整个爬虫就算完成了。

10. 运行

示例运行结果如图 9-29 所示: 图 9-29 运行结果 程序首先调度了第一页结果对应的请求,获取了代理执行此请求,随后得到了 11 个新请求,请求都是 WeixinRequest 类型,将其再加入队列。随后继续调度新加入的请求,也就是文章详情页对应的请求,再执行,得到的就是文章详情对应的提取结果,提取结果是字典类型。 程序循环往复,不断爬取,直至所有结果爬取完毕,程序终止,爬取完成。 爬取结果如图 9-30 所示。 图 9-30 爬取结果 我们可以看到,相关微信文章都已被存储到数据库里了。

11. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/Weixin,运行之前请先配置好代理池。

12. 结语

以上内容便是使用代理爬取微信公众号文章的方法,涉及的新知识点不少,希望大家可以好好消化。

技术杂谈

我们尝试维护过一个代理池。代理池可以挑选出许多可用代理,但是常常其稳定性不高、响应速度慢,而且这些代理通常是公共代理,可能不止一人同时使用,其 IP 被封的概率很大。另外,这些代理可能有效时间比较短,虽然代理池一直在筛选,但如果没有及时更新状态,也有可能获取到不可用的代理。 如果要追求更加稳定的代理,就需要购买专有代理或者自己搭建代理服务器。但是服务器一般都是固定的 IP,我们总不能搭建 100 个代理就用 100 台服务器吧,这显然是不现实的。 所以,ADSL 动态拨号主机就派上用场了。下面我们来了解一下 ADSL 拨号代理服务器的相关设置。

1. 什么是 ADSL

ADSL(Asymmetric Digital Subscriber Line,非对称数字用户环路),它的上行和下行带宽不对称,它采用频分复用技术把普通的电话线分成了电话、上行和下行 3 个相对独立的信道,从而避免了相互之间的干扰。 ADSL 通过拨号的方式上网,需要输入 ADSL 账号和密码,每次拨号就更换一个 IP。IP 分布在多个 A 段,如果 IP 都能使用,则意味着 IP 量级可达千万。如果我们将 ADSL 主机作为代理,每隔一段时间主机拨号就换一个 IP,这样可以有效防止 IP 被封禁。另外,主机的稳定性很好,代理响应速度很快。

2. 准备工作

首先需要成功安装 Redis 数据库并启动服务,另外还需要安装 requests、redis-py、Tornado 库。如果没有安装,读者可以参考第一章的安装说明。

3. 购买主机

我们先购买一台动态拨号 VPS 主机,这样的主机服务商相当多。在这里使用了云立方,官方网站:http://www.yunlifang.cn/dynamicvps.asp。 建议选择电信线路。可以自行选择主机配置,主要考虑带宽是否满足需求。 然后进入拨号主机的后台,预装一个操作系统,如图 9-10 所示。 图 9-10 预装操作系统 推荐安装 CentOS 7 系统。 然后找到远程管理面板远程连接的用户名和密码,也就是 SSH 远程连接服务器的信息。比如我使用的 IP 和端口是 153.36.65.214:20063,用户名是 root。命令行下输入如下内容:

1
ssh root@153.36.65.214 -p 20063

输入管理密码,就可以连接上远程服务器了。 进入之后,我们发现一个可用的脚本文件 ppp.sh,这是拨号初始化的脚本。运行此脚本会提示输入拨号的用户名和密码,然后它就开始各种拨号配置。一次配置成功,后面拨号就不需要重复输入用户名和密码。 运行 ppp.sh 脚本,输入用户名、密码等待它的配置完成,如图 9-11 所示。 图 9-11 配置页面 提示成功之后就可以进行拨号了。注意,在拨号之前测试 ping 任何网站都是不通的,因为当前网络还没联通。输入如下拨号命令:

1
adsl-start

拨号命令成功运行,没有报错信息,耗时约几秒。接下来再去 ping 外网就可以通了。 如果要停止拨号,可以输入如下命令:

1
adsl-stop

之后,可以发现又连不通网络了,如图 9-12 所示。 图 9-12 拨号建立连接 断线重播的命令就是二者组合起来,先执行 adsl-stop,再执行 adsl-start。每次拨号,ifconfig 命令观察主机的 IP,发现主机的 IP 一直在变化,网卡名称叫作 ppp0,如图 9-13 所示。 图 9-13 网络设备信息 接下来,我们要做两件事:一是怎样将主机设置为代理服务器,二是怎样实时获取拨号主机的 IP。

4. 设置代理服务器

在 Linux 下搭建 HTTP 代理服务器,推荐 TinyProxy 和 Squid,配置都非常简单。在这里我们以 TinyProxy 为例来讲解一下怎样搭建代理服务器。

安装 TinyProxy

第一步就是安装 TinyProxy 软件。在这里我使用的系统是 CentOS,所以使用 yum 来安装。如果是其他系统,如 Ubuntu,可以选择 apt-get 等命令安装。 命令行执行 yum 安装指令:

1
2
3
yum install -y epel-release
yum update -y
yum install -y tinyproxy

运行完成之后就可以完成 tinyproxy 的安装了。

配置 TinyProxy

TinyProxy 安装完成之后还要配置一下才可以用作代理服务器。我们需要编辑配置文件,此文件一般的路径是 /etc/tinyproxy/tinyproxy.conf。 可以看到有一行

1
Port 8888

在这里可以设置代理的端口,默认是 8888。 继续向下找到如下代码:

1
Allow 127.0.0.1

这行代码表示被允许连接的主机 IP。如果希望连接任何主机,那就直接将这行代码注释即可。在这里我们选择直接注释,也就是任何主机都可以使用这台主机作为代理服务器。 修改为如下代码:

1
# Allow 127.0.0.1

设置完成之后重启 TinyProxy 即可:

1
2
systemctl enable tinyproxy.service
systemctl restart tinyproxy.service

防火墙开放该端口:

1
iptables -I INPUT -p tcp --dport 8888 -j ACCEPT

当然如果想直接关闭防火墙也可以:

1
systemctl stop firewalld.service

这样我们就完成了 TinyProxy 的配置了。

验证 TinyProxy

首先,用 ifconfig 查看当前主机的 IP。比如,当前我的主机拨号 IP 为 112.84.118.216,在其他的主机运行测试一下。 用 curl 命令设置代理请求 httpbin,检测代理是否生效。

1
curl -x 112.84.118.216:8888 httpbin.org/get

运行结果如图 9-14 所示: 图 9-14 运行结果 如果有正常的结果输出,并且 origin 的值为代理 IP 的地址,就证明 TinyProxy 配置成功了。

5. 动态获取 IP

现在可以执行命令让主机动态切换 IP,也在主机上搭建了代理服务器。我们只需要知道拨号后的 IP 就可以使用代理。 我们考虑到,在一台主机拨号切换 IP 的间隙代理是不可用的,在这拨号的几秒时间内如果有第二台主机顶替第一台主机,那就可以解决拨号间隙代理无法使用的问题了。所以我们要设计的架构必须要考虑支持多主机的问题。 假如有 10 台拨号主机同时需要维护,而爬虫需要使用这 10 台主机的代理,那么在爬虫端维护的开销是非常大的。如果爬虫在不同的机器上运行,那么每个爬虫必须要获得这 10 台拨号主机的配置,这显然是不理想的。 为了更加方便地使用代理,我们可以像上文的代理池一样定义一个统一的代理接口,爬虫端只需要配置代理接口即可获取可用代理。要搭建一个接口,就势必需要一台服务器,而接口的数据从哪里获得呢,当然最理想的还是选择数据库。 比如我们需要同时维护 10 台拨号主机,每台拨号主机都会定时拨号,那这样每台主机在某个时刻可用的代理只有一个,所以我们没有必要存储之前的拨号代理,因为重新拨号之后之前的代理已经不能用了,所以只需要将之前的代理更新其内容就好了。数据库要做的就是定时对每台主机的代理进行更新,而更新时又需要拨号主机的唯一标识,根据主机标识查出这条数据,然后将这条数据对应的代理更新。 所以数据库端就需要存储一个主机标识到代理的映射关系。那么很自然地我们就会想到关系型数据库,如 MySQL 或者 Redis 的 Hash 存储,只需存储一个映射关系,不需要很多字段,而且 Redis 比 MySQL 效率更高、使用更方便,所以最终选定的存储方式就是 Redis 的 Hash。

6. 存储模块

那么接下来我们要做可被远程访问的 Redis 数据库,各个拨号机器只需要将各自的主机标识和当前 IP 和端口(也就是代理)发送给数据库就好了。 先定义一个操作 Redis 数据库的类,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import redis
import random

# Redis 数据库 IP
REDIS_HOST = 'remoteaddress'
# Redis 数据库密码,如无则填 None
REDIS_PASSWORD = 'foobared'
# Redis 数据库端口
REDIS_PORT = 6379
# 代理池键名
PROXY_KEY = 'adsl'

class RedisClient(object):
def __init__(self, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, proxy_key=PROXY_KEY):
"""
初始化 Redis 连接
:param host: Redis 地址
:param port: Redis 端口
:param password: Redis 密码
:param proxy_key: Redis 哈希表名
"""
self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)
self.proxy_key = proxy_key

def set(self, name, proxy):
"""
设置代理
:param name: 主机名称
:param proxy: 代理
:return: 设置结果
"""
return self.db.hset(self.proxy_key, name, proxy)

def get(self, name):
"""
获取代理
:param name: 主机名称
:return: 代理
"""
return self.db.hget(self.proxy_key, name)

def count(self):
"""
获取代理总数
:return: 代理总数
"""
return self.db.hlen(self.proxy_key)

def remove(self, name):
"""
删除代理
:param name: 主机名称
:return: 删除结果
"""
return self.db.hdel(self.proxy_key, name)

def names(self):
"""
获取主机名称列表
:return: 获取主机名称列表
"""
return self.db.hkeys(self.proxy_key)

def proxies(self):
"""
获取代理列表
:return: 代理列表
"""
return self.db.hvals(self.proxy_key)

def random(self):
"""
随机获取代理
:return:
"""
proxies = self.proxies()
return random.choice(proxies)

def all(self):
"""
获取字典
:return:
"""return self.db.hgetall(self.proxy_key)

这里定义了一个 RedisClient 类,在init() 方法中初始化了 Redis 连接,其中 REDIS_HOST 就是远程 Redis 的地址,REDIS_PASSWORD 是密码,REDIS_PORT 是端口,PROXY_KEY 是存储代理的散列表的键名。 接下来定义了一个 set() 方法,这个方法用来向散列表添加映射关系。映射是从主机标识到代理的映射,比如一台主机的标识为 adsl1,当前的代理为 118.119.111.172:8888,那么散列表中就会存储一个 key 为 adsl1、value 为 118.119.111.172:8888 的映射,Hash 结构如图 9-15 所示。 图 9-15 Hash 结构 如果有多台主机,只需要向 Hash 中添加映射即可。 另外,get() 方法就是从散列表中取出某台主机对应的代理。remove() 方法则是从散列表中移除对应的主机的代理。还有 names()、proxies()、all() 方法则是分别获取散列表中的主机列表、代理列表及所有主机代理映射。count() 方法则是返回当前散列表的大小,也就是可用代理的数目。 最后还有一个比较重要的方法 random(),它随机从散列表中取出一个可用代理,类似前面代理池的思想,确保每个代理都能被取到。 如果要对数据库进行操作,只需要初始化 RedisClient 对象,然后调用它的 set() 或者 remove() 方法,即可对散列表进行设置和删除。

7. 拨号模块

接下来要做的就是拨号,并把新的 IP 保存到 Redis 散列表里。 首先是拨号定时,它分为定时拨号和非定时拨号两种选择。 非定时拨号:最好的方法就是向该主机发送一个信号,然后主机就启动拨号,但这样做的话,我们首先要搭建一个重新拨号的接口,如搭建一个 Web 接口,请求该接口即进行拨号,但开始拨号之后,此时主机的状态就从在线转为离线,而此时的 Web 接口也就相应失效了,拨号过程无法再连接,拨号之后接口的 IP 也变了,所以我们无法通过接口来方便地控制拨号过程和获取拨号结果,下次拨号还得改变拨号请求接口,所以非定时拨号的开销还是比较大的。 定时拨号:我们只需要在拨号主机上运行定时脚本即可,每隔一段时间拨号一次,更新 IP,然后将 IP 在 Redis 散列表中更新即可,非常简单易用,另外可以适当将拨号频率调高一点,减少短时间内 IP 被封的可能性。 在这里选择定时拨号。 接下来就是获取 IP。获取拨号后的 IP 非常简单,只需要调用 ifconfig 命令,然后解析出对应网卡的 IP 即可。 获取了 IP 之后,我们还需要进行有效性检测。拨号主机可以自己检测,比如可以利用 requests 设置自身的代理请求外网,如果成功,那么证明代理可用,然后再修改 Redis 散列表,更新代理。 需要注意,由于在拨号的间隙拨号主机是离线状态,而此时 Redis 散列表中还存留了上次的代理,一旦这个代理被取用了,该代理是无法使用的。为了避免这个情况,每台主机在拨号之前还需要将自身的代理从 Redis 散列表中移除。 这样基本的流程就理顺了,我们用如下代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import re
import time
import requests
from requests.exceptions import ConnectionError, ReadTimeout
from db import RedisClient

# 拨号网卡
ADSL_IFNAME = 'ppp0'
# 测试 URL
TEST_URL = 'http://www.baidu.com'
# 测试超时时间
TEST_TIMEOUT = 20
# 拨号间隔
ADSL_CYCLE = 100
# 拨号出错重试间隔
ADSL_ERROR_CYCLE = 5
# ADSL 命令
ADSL_BASH = 'adsl-stop;adsl-start'
# 代理运行端口
PROXY_PORT = 8888
# 客户端唯一标识
CLIENT_NAME = 'adsl1'

class Sender():
def get_ip(self, ifname=ADSL_IFNAME):
"""
获取本机 IP
:param ifname: 网卡名称
:return:
"""
(status, output) = subprocess.getstatusoutput('ifconfig')
if status == 0:
pattern = re.compile(ifname + '.*?inet.*?(d+.d+.d+.d+).*?netmask', re.S)
result = re.search(pattern, output)
if result:
ip = result.group(1)
return ip

def test_proxy(self, proxy):
"""
测试代理
:param proxy: 代理
:return: 测试结果
"""
try:
response = requests.get(TEST_URL, proxies={
'http': 'http://' + proxy,
'https': 'https://' + proxy
}, timeout=TEST_TIMEOUT)
if response.status_code == 200:
return True
except (ConnectionError, ReadTimeout):
return False

def remove_proxy(self):
"""
移除代理
:return: None
"""
self.redis = RedisClient()
self.redis.remove(CLIENT_NAME)
print('Successfully Removed Proxy')

def set_proxy(self, proxy):
"""
设置代理
:param proxy: 代理
:return: None
"""
self.redis = RedisClient()
if self.redis.set(CLIENT_NAME, proxy):
print('Successfully Set Proxy', proxy)

def adsl(self):
"""
拨号主进程
:return: None
"""
while True:
print('ADSL Start, Remove Proxy, Please wait')
self.remove_proxy()
(status, output) = subprocess.getstatusoutput(ADSL_BASH)
if status == 0:
print('ADSL Successfully')
ip = self.get_ip()
if ip:
print('Now IP', ip)
print('Testing Proxy, Please Wait')
proxy = '{ip}:{port}'.format(ip=ip, port=PROXY_PORT)
if self.test_proxy(proxy):
print('Valid Proxy')
self.set_proxy(proxy)
print('Sleeping')
time.sleep(ADSL_CYCLE)
else:
print('Invalid Proxy')
else:
print('Get IP Failed, Re Dialing')
time.sleep(ADSL_ERROR_CYCLE)
else:
print('ADSL Failed, Please Check')
time.sleep(ADSL_ERROR_CYCLE)
def run():
sender = Sender()
sender.adsl()

在这里定义了一个 Sender 类,它的主要作用是执行定时拨号,并将新的 IP 测试通过之后更新到远程 Redis 散列表里。 主方法是 adsl() 方法,它首先是一个无限循环,循环体内就是拨号的逻辑。 adsl() 方法首先调用了 remove_proxy() 方法,将远程 Redis 散列表中本机对应的代理移除,避免拨号时本主机的残留代理被取到。 接下来利用 subprocess 模块来执行拨号脚本,拨号脚本很简单,就是 stop 之后再 start,这里将拨号的命令直接定义成了 ADSL_BASH。 随后程序又调用 get_ip() 方法,通过 subprocess 模块执行获取 IP 的命令 ifconfig,然后根据网卡名称获取了当前拨号网卡的 IP 地址,即拨号后的 IP。 再接下来就需要测试代理有效性了。程序首先调用了 test_proxy() 方法,将自身的代理设置好,使用 requests 库来用代理连接 TEST_URL。在此 TEST_URL 设置为百度,如果请求成功,则证明代理有效。 如果代理有效,再调用 set_proxy() 方法将 Redis 散列表中本机对应的代理更新,设置时需要指定本机唯一标识和本机当前代理。本机唯一标识可随意配置,其对应的变量为 CLIENT_NAME,保证各台拨号主机不冲突即可。本机当前代理则由拨号后的新 IP 加端口组合而成。通过调用 RedisClient 的 set() 方法,参数 name 为本机唯一标识,proxy 为拨号后的新代理,执行之后便可以更新散列表中的本机代理了。 建议至少配置两台主机,这样在一台主机的拨号间隙还有另一台主机的代理可用。拨号主机的数量不限,越多越好。 在拨号主机上执行拨号脚本,示例输出如图 9-16 所示。 图 9-16 示例输出 首先移除了代理,再进行拨号,拨号完成之后获取新的 IP,代理检测成功之后就设置到 Redis 散列表中,然后等待一段时间再重新进行拨号。 我们添加了多台拨号主机,这样就有多个稳定的定时更新的代理可用了。Redis 散列表会实时更新各台拨号主机的代理,如图 9-17 所示。 图 9-17 Hash 结构 图中所示是四台 ADSL 拨号主机配置并运行后的散列表的内容,表中的代理都是可用的。

8. 接口模块

目前为止,我们已经成功实时更新拨号主机的代理。不过还缺少一个模块,那就是接口模块。像之前的代理池一样,我们也定义一些接口来获取代理,如 random 获取随机代理、count 获取代理个数等。 我们选用 Tornado 来实现,利用 Tornado 的 Server 模块搭建 Web 接口服务,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import json
import tornado.ioloop
import tornado.web
from tornado.web import RequestHandler, Application

# API 端口
API_PORT = 8000

class MainHandler(RequestHandler):
def initialize(self, redis):
self.redis = redis

def get(self, api=''):
if not api:
links = ['random', 'proxies', 'names', 'all', 'count']
self.write('<h4>Welcome to ADSL Proxy API</h4>')
for link in links:
self.write('<a href=' + link + '>' + link + '</a><br>')

if api == 'random':
result = self.redis.random()
if result:
self.write(result)

if api == 'names':
result = self.redis.names()
if result:
self.write(json.dumps(result))

if api == 'proxies':
result = self.redis.proxies()
if result:
self.write(json.dumps(result))

if api == 'all':
result = self.redis.all()
if result:
self.write(json.dumps(result))

if api == 'count':
self.write(str(self.redis.count()))

def server(redis, port=API_PORT, address=''):
application = Application([(r'/', MainHandler, dict(redis=redis)),
(r'/(.*)', MainHandler, dict(redis=redis)),
])
application.listen(port, address=address)
print('ADSL API Listening on', port)
tornado.ioloop.IOLoop.instance().start()

这里定义了 5 个接口,random 获取随机代理,names 获取主机列表,proxies 获取代理列表,all 获取代理映射,count 获取代理数量。 程序启动之后便会在 API_PORT 端口上运行 Web 服务,主页面如图 9-18 所示。 图 9-18 主页面 访问 proxies 接口可以获得所有代理列表,如图 9-19 所示。 图 9-19 代理列表 访问 random 接口可以获取随机可用代理,如图 9-20 所示。 图 9-20 随机代理 我们只需将接口部署到服务器上,即可通过 Web 接口获取可用代理,获取方式和代理池类似。

9. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/AdslProxy

10. 结语

本节介绍了 ADSL 拨号代理的搭建过程。通过这种代理,我们可以无限次更换 IP,而且线路非常稳定,抓取效果好很多。

技术杂谈

爬虫是大数据时代不可或缺的数据获取手段,它是综合技术的应用体现。

​有取就有失,有攻就有防。开发者为了保护数据,不得已想出了很多办法来限制爬虫对数据的获取。WEB 网站的构成使得 JavaScript 成为了开发者阻挡爬虫的最佳选择。

作为一名爬虫工程师,解决目标网站设置的反爬虫手段是职责所在。大家遇到的问题都很相似:

1、遇到加密的内容就无从下手,一片迷茫……!

2、会一点 JS 语法,能解一些简单的,但复杂的就不行了!

3、抠代码太繁杂了,根本不知道怎么办,一早上都定位不到函数入口!

4、混淆过后的代码,看得头都痛!

5、咦,这串加密的字符串怎么搞?

需求又如何呢?

爬虫工程师真的需要学习逆向吗?

在此之前我们在多个爬虫工程师群做了调查,投票结果如下:

在招聘方面

很多岗位都要求有逆向或者解决反爬虫的能力 甚至作为优先选择的条件

显然,拥有逆向能力的爬虫工程师的职业等级会变得更高、团队地位更高,薪资自然也更高。

本课程将主要从原理和技巧两个角度来为大家讲解 JavaScript 反爬虫绕过的相关知识。课程从反爬虫原理、工具介绍和使用、JavaScript 基础语法入手,结合常见的反爬虫现象及其绕过实战操作,帮助你掌握中级爬虫工程师必备的 JavaScript 逆向知识,向更高的职级迈进!

你将从本课程中收获什么?

序号

内容

重要程度

1

深入理解 JavaScript 反爬虫的根本原因

A+

2

了解工作中常用的 JavaScript 语法和知识

B

3

掌握各种逆向神器的基本使用和骚操作

A

4

深入理解 JavaScript 代码混淆的原理

A+

5

掌握 JavaScript 中常见的编码和加密方法

A

6

拥有快速定位加密代码位置的能力

A

7

轻松面对各种各样的加密字符串

A

学习案例的制作思路均来自实际网站在用的反爬虫手段,当你学习完整套课程后就可以独立面对前端反爬虫问题,平时的苦恼也将迎刃而解。

课程大纲设计

序号

标签

课程标题

1

追根究底

探寻 JavaScript 反爬虫的根本原因

2

浮沙之上

课程中用到的 JavaScript 语法和知识

3

奇门遁甲

使用 Python 执行 JavaScript

4

蓄势待发

浏览器开发者工具的介绍和使用技巧

5

磨刀霍霍

抓包和拦截工具的介绍和使用技巧

6

初窥门径

阻挠爬虫工程师的无限 debug

7

火眼金睛

定位加密参数对应代码位置的方法

8

拨开云雾

代码混淆的原理

9

一击即中

处理代码混淆的方法

10

知己知彼

掌握常见的编码和加密

11

长枪直入

轻松解决反人类的混淆代码

12

一叶障目

服务端返回的神秘字符串

13

螳臂当车

解密!AES 并不是每次都奏效

14

插翅难逃

纵然 CSS 加身也难逃命运的安排

15

真假猴王

Base64 竟有如此威力

16

过眼云烟

历练半生 归来仍是少年

备注:具体开课时的目录有可能与现在的大纲存在差异,但改动不大。 这课程大纲预售放出来,我们都不怕别的机构抄,随便它们模仿。

课程特色和内容制作团队介绍

自研练习平台,不触碰法律红线、练习案例不会过期。

我们没有xx顶级讲师,也没有国外xx计算机硕士博士,不存在的。

我们只有一线爬虫工程师,讲最实用的内容,做最有效的练习。团队成员包括:崔庆才、韦世东、陈祥安、张冶青、唐轶飞、蔡晋、冯威、戴煌金、周子淇。

不像在线课平台,加群后讲师根本没空回答问题。我们会持续跟进与交流,制作良心内容,恶心营销狗?干的事我们才不会干。

团队成员有图书出版经历,例如崔庆才的 IT 畅销书《Python3 网络爬虫开发实战》、韦世东即将出版的《Python3 反爬虫原理与绕过实战》。

团队水平如何请大家自行斟酌,这里我就不吹嘘什么了。

预售活动

课程在准备当中,现在开放预售。完整课程售价 399,预售 50 元抵正式课程 100 元,且可提前进入视频教程的微信交流群,甚至可以提出想看的内容,团队会酌情考虑加课。

预售目标为 1000 人,不足 1000 人预售取消,逐个退款。

预售成功后,开课之前可以申请退课退款,支持全额退款。

参与预售的朋友还可以参与开课前的营销活动。

未参与预售的朋友,只能在开课时按原价或活动价购买课程。

预售活动截止日期为 2019年10月31日。

开课时间

课程在准备当中,预计 2 个月左右可看,最迟 2020年01月20日 你就能看到了!

不过可以肯定的是,报名人数越多,内容制作越快。

如何报名

添加微信号:Domfreez,或者扫描下方二维码,与夜幕韦世东聊一聊。 我为粉丝争取到了额外的 50 元优惠,预售期间内主动出示优惠码:GERMEY01 即可在活动基础上再减 50 元! 相信我没错的,现在你只需要花 50 元预订,399 元的课程就抵扣了 150,正式开售的时候只需要再付 249 即可学习,从此前端反爬虫不再是烦恼! 声明: 本次活动最终解释权归内容制作方夜幕团队所有。

技术杂谈

本文为转载文章,旨在记录一些有用的知识点。

1. 概述

JSON-RPC 是一个无状态且轻量级的远程过程调用 (RPC) 协议。 本规范主要定义了一些数据结构及其相关的处理规则。它允许运行在基于 socket, http 等诸多不同消息传输环境的同一进程中。其使用 JSONRFC 4627)作为数据格式。 它为简单而生!

2. 约定

文档中关键字 “MUST”、”MUST NOT”、”REQUIRED”、”SHALL”、”SHALL NOT”、”SHOULD”、”SHOULD NOT”、”RECOMMENDED”、”MAY” 和 “OPTIONAL” 将在 RFC 2119 中得到详细的解释及描述。 由于 JSON-RPC 使用 JSON,它具有与其相同的类型系统 (见 http://www.json.orgRFC 4627)。JSON 可以表示四个基本类型 (String、Numbers、Booleans 和 Null) 和两个结构化类型 (Objects 和 Arrays)。 规范中,术语 “Primitive” 标记那 4 种原始类型,“Structured” 标记两种结构化类型。任何时候文档涉及 JSON 数据类型,第一个字母都必须大写:Object,Array,String,Number,Boolean,Null。包括 True 和 False 也要大写。 在客户端与任何被匹配到的服务端之间交换的所有成员名字应是区分大小写的。 函数、方法、过程都可以认为是可以互换的。 客户端被定义为请求对象的来源及响应对象的处理程序。 服务端被定义为响应对象的起源和请求对象的处理程序。 该规范的一种实现为可以轻而易举的填补这两个角色,即使是在同一时间,同一客户端或其他不相同的客户端。 该规范不涉及复杂层。

3. 兼容性

JSON-RPC 2.0 的请求对象和响应对象可能无法在现用的 JSON-RPC 1.0 客户端或服务端工作,然而我们可以很容易在两个版本间区分出 2.0,总会包含一个成员命名为 “jsonrpc” 且值为 “2.0”, 而 1.0 版本是不包含的。大部分的 2.0 实现应该考虑尝试处理 1.0 的对象,即使不是对等的也应给其相关提示。

4. 请求对象

发送一个请求对象至服务端代表一个 rpc 调用, 一个请求对象包含下列成员: jsonrpc

指定 JSON-RPC 协议版本的字符串,必须准确写为 “2.0”

method

包含所要调用方法名称的字符串,以 rpc 开头的方法名,用英文句号(U+002E or ASCII 46)连接的为预留给 rpc 内部的方法名及扩展名,且不能在其他地方使用。

params

调用方法所需要的结构化参数值,该成员参数可以被省略。

id

已建立客户端的唯一标识 id,值必须包含一个字符串、数值或 NULL 空值。如果不包含该成员则被认定为是一个通知。该值一般不为 NULL [1],若为数值则不应该包含小数 [2]

服务端必须回答相同的值如果包含在响应对象。 这个成员用来两个对象之间的关联上下文。 [1] 在请求对象中不建议使用 NULL 作为 id 值,因为该规范将使用空值认定为未知 id 的请求。另外,由于 JSON-RPC 1.0 的通知使用了空值,这可能引起处理上的混淆。 [2] 使用小数是不确定性的,因为许多十进制小数不能精准的表达为二进制小数。

4.1 通知

没有包含 “id” 成员的请求对象为通知, 作为通知的请求对象表明客户端对相应的响应对象并不感兴趣,本身也没有响应对象需要返回给客户端。服务端必须不回复一个通知,包含那些批量请求中的。 由于通知没有返回的响应对象,所以通知不确定是否被定义。同样,客户端不会意识到任何错误(例如参数缺省,内部错误)。

4.2 参数结构

rpc 调用如果存在参数则必须为基本类型或结构化类型的参数值,要么为索引数组,要么为关联数组对象。

  • 索引:参数必须为数组,并包含与服务端预期顺序一致的参数值。
  • 关联名称:参数必须为对象,并包含与服务端相匹配的参数成员名称。没有在预期中的成员名称可能会引起错误。名称必须完全匹配,包括方法的预期参数名以及大小写。

5. 响应对象

当发起一个 rpc 调用时,除通知之外,服务端都必须回复响应。响应表示为一个 JSON 对象,使用以下成员: jsonrpc

指定 JSON-RPC 协议版本的字符串,必须准确写为 “2.0”

result

该成员在成功时必须包含。 当调用方法引起错误时必须不包含该成员。 服务端中的被调用方法决定了该成员的值。

error

该成员在失败是必须包含。 当没有引起错误的时必须不包含该成员。 该成员参数值必须为 5.1 中定义的对象。

id

该成员必须包含。 该成员值必须于请求对象中的 id 成员值一致。 若在检查请求对象 id 时错误(例如参数错误或无效请求),则该值必须为空值。

响应对象必须包含 result 或 error 成员,但两个成员必须不能同时包含。

5.1 错误对象

当一个 rpc 调用遇到错误时,返回的响应对象必须包含错误成员参数,并且为带有下列成员参数的对象: code

使用数值表示该异常的错误类型。 必须为整数。

message

对该错误的简单描述字符串。 该描述应尽量限定在简短的一句话。

data

包含关于错误附加信息的基本类型或结构化类型。该成员可忽略。 该成员值由服务端定义(例如详细的错误信息,嵌套的错误等)。

-32768 至 - 32000 为保留的预定义错误代码。在该范围内的错误代码不能被明确定义,保留下列以供将来使用。错误代码基本与 XML-RPC 建议的一样,url: http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php

code

message

meaning

-32700

Parse error 语法解析错误

服务端接收到无效的 json。该错误发送于服务器尝试解析 json 文本

-32600

Invalid Request 无效请求

发送的 json 不是一个有效的请求对象。

-32601

Method not found 找不到方法

该方法不存在或无效

-32602

Invalid params 无效的参数

无效的方法参数。

-32603

Internal error 内部错误

JSON-RPC 内部错误。

-32000 to -32099

Server error 服务端错误

预留用于自定义的服务器错误。

除此之外剩余的错误类型代码可供应用程序作为自定义错误。

6. 批量调用

当需要同时发送多个请求对象时,客户端可以发送一个包含所有请求对象的数组。 当批量调用的所有请求对象处理完成时,服务端则需要返回一个包含相对应的响应对象数组。每个响应对象都应对应每个请求对象,除非是通知的请求对象。服务端可以并发的,以任意顺序和任意宽度的并行性来处理这些批量调用。 这些相应的响应对象可以任意顺序的包含在返回的数组中,而客户端应该是基于各个响应对象中的 id 成员来匹配对应的请求对象。 若批量调用的 rpc 操作本身非一个有效 json 或一个至少包含一个值的数组,则服务端返回的将单单是一个响应对象而非数组。若批量调用没有需要返回的响应对象,则服务端不需要返回任何结果且必须不能返回一个空数组给客户端。

7. 示例

语法:

--> data sent to Server data sent to Client

带索引数组参数的rpc调用:

1
2
3
4
5
\--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
{"jsonrpc": "2.0", "result": 19, "id": 1}

--> {"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}
{"jsonrpc": "2.0", "result": -19, "id": 2}

带关联数组参数的rpc调用:

1
2
3
4
5
\--> {"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}
{"jsonrpc": "2.0", "result": 19, "id": 3}

--> {"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}
{"jsonrpc": "2.0", "result": 19, "id": 4}

通知:

1
2
\--> {"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}
--> {"jsonrpc": "2.0", "method": "foobar"}

不包含调用方法的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": "foobar", "id": "1"}
{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "1"}

包含无效json的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": "foobar, "params": "bar", "baz]
{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}

包含无效请求对象的rpc调用:

1
2
\--> {"jsonrpc": "2.0", "method": 1, "params": "bar"}
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}

包含无效json的rpc批量调用:

1
2
3
4
5
\--> [
{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
{"jsonrpc": "2.0", "method"
]
{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}

包含空数组的rpc调用:

1
2
\--> []
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}

非空且无效的rpc批量调用:

1
2
3
4
\--> [1]
[
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
]

无效的rpc批量调用:

1
2
3
4
5
6
\--> [1,2,3]
[
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
]

rpc批量调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
\--> [
{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
{"jsonrpc": "2.0", "method": "subtract", "params": [42,23], "id": "2"},
{"foo": "boo"},
{"jsonrpc": "2.0", "method": "foo.get", "params": {"name": "myself"}, "id": "5"},
{"jsonrpc": "2.0", "method": "get_data", "id": "9"}
]
[
{"jsonrpc": "2.0", "result": 7, "id": "1"},
{"jsonrpc": "2.0", "result": 19, "id": "2"},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "5"},
{"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
]

所有都为通知的rpc批量调用:

1
2
3
4
5
6
\--> [
{"jsonrpc": "2.0", "method": "notify_sum", "params": [1,2,4]},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]}
]

//Nothing is returned for all notification batches

8. 扩展

以 rpc 开头的方法名预留作为系统扩展,且必须不能用于其他地方。每个系统扩展都应该有相关规范文档,所有系统扩展都应是可选的。

技术杂谈

在 Python 中,一般情况下我们可能直接用自带的 logging 模块来记录日志,包括我之前的时候也是一样。在使用时我们需要配置一些 Handler、Formatter 来进行一些处理,比如把日志输出到不同的位置,或者设置一个不同的输出格式,或者设置日志分块和备份。但其实个人感觉 logging 用起来其实并不是那么好用,其实主要还是配置较为繁琐。

常见使用

首先看看 logging 常见的解决方案吧,我一般会配置输出到文件、控制台和 Elasticsearch。输出到控制台就仅仅是方便直接查看的;输出到文件是方便直接存储,保留所有历史记录的备份;输出到 Elasticsearch,直接将 Elasticsearch 作为存储和分析的中心,使用 Kibana 可以非常方便地分析和查看运行情况。 所以在这里我基本会对 logging 做如下的封装写法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import logging
import sys
from os import makedirs
from os.path import dirname, exists

from cmreslogging.handlers import CMRESHandler

loggers = {}

LOG_ENABLED = True # 是否开启日志
LOG_TO_CONSOLE = True # 是否输出到控制台
LOG_TO_FILE = True # 是否输出到文件
LOG_TO_ES = True # 是否输出到 Elasticsearch

LOG_PATH = './runtime.log' # 日志文件路径
LOG_LEVEL = 'DEBUG' # 日志级别
LOG_FORMAT = '%(levelname)s - %(asctime)s - process: %(process)d - %(filename)s - %(name)s - %(lineno)d - %(module)s - %(message)s' # 每条日志输出格式
ELASTIC_SEARCH_HOST = 'eshost' # Elasticsearch Host
ELASTIC_SEARCH_PORT = 9200 # Elasticsearch Port
ELASTIC_SEARCH_INDEX = 'runtime' # Elasticsearch Index Name
APP_ENVIRONMENT = 'dev' # 运行环境,如测试环境还是生产环境

def get_logger(name=None):
"""
get logger by name
:param name: name of logger
:return: logger
"""
global loggers

if not name: name = __name__

if loggers.get(name):
return loggers.get(name)

logger = logging.getLogger(name)
logger.setLevel(LOG_LEVEL)

# 输出到控制台
if LOG_ENABLED and LOG_TO_CONSOLE:
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)

# 输出到文件
if LOG_ENABLED and LOG_TO_FILE:
# 如果路径不存在,创建日志文件文件夹
log_dir = dirname(log_path)
if not exists(log_dir): makedirs(log_dir)
# 添加 FileHandler
file_handler = logging.FileHandler(log_path, encoding='utf-8')
file_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# 输出到 Elasticsearch
if LOG_ENABLED and LOG_TO_ES:
# 添加 CMRESHandler
es_handler = CMRESHandler(hosts=[{'host': ELASTIC_SEARCH_HOST, 'port': ELASTIC_SEARCH_PORT}],
# 可以配置对应的认证权限
auth_type=CMRESHandler.AuthType.NO_AUTH,
es_index_name=ELASTIC_SEARCH_INDEX,
# 一个月分一个 Index
index_name_frequency=CMRESHandler.IndexNameFrequency.MONTHLY,
# 额外增加环境标识
es_additional_fields={'environment': APP_ENVIRONMENT}
)
es_handler.setLevel(level=LOG_LEVEL)
formatter = logging.Formatter(LOG_FORMAT)
es_handler.setFormatter(formatter)
logger.addHandler(es_handler)

# 保存到全局 loggers
loggers[name] = logger
return logger

定义完了怎么使用呢?只需要使用定义的方法获取一个 logger,然后 log 对应的内容即可:

1
2
logger = get_logger()
logger.debug('this is a message')

运行结果如下:

1
DEBUG - 2019-10-11 22:27:35,923 - process: 99490 - logger.py - __main__ - 81 - logger - this is a message

我们看看这个定义的基本实现吧。首先这里一些常量是用来定义 logging 模块的一些基本属性的,比如 LOG_ENABLED 代表是否开启日志功能,LOG_TO_ES 代表是否将日志输出到 Elasticsearch,另外还有很多其他的日志基本配置,如 LOG_FORMAT 配置了日志每个条目输出的基本格式,另外还有一些连接的必要信息。这些变量可以和运行时的命令行或环境变量对接起来,可以方便地实现一些开关和配置的更换。 然后定义了这么一个 get_logger 方法,接收一个参数 name。首先该方法拿到 name 之后,会到全局的 loggers 变量里面查找,loggers 变量是一个全局字典,如果有已经声明过的 logger,直接将其获取返回即可,不用再将其二次初始化。如果 loggers 里面没有找到 name 对应的 logger,那就进行创建即可。创建 logger 之后,可以为其添加各种对应的 Handler,如输出到控制台就用 StreamHandler,输出到文件就用 FileHandler 或 RotatingFileHandler,输出到 Elasticsearch 就用 CMRESHandler,分别配置好对应的信息即可。 最后呢,将新建的 logger 保存到全局的 loggers 里面并返回即可,这样如果有同名的 logger 便可以直接查找 loggers 直接返回了。 在这里依赖了额外的输出到 Elasticsearch 的包,叫做 CMRESHandler,它可以支持将日志输出到 Elasticsearch 里面,如果要使用的话可以安装一下:

1
pip install CMRESHandler

其 GitHub 地址是:https://github.com/cmanaha/python-elasticsearch-logger,具体的使用方式可以看看它的官方说明,如配置认证信息,配置 Index 分隔信息等等。 好,上面就是我之前常用的 logging 配置,通过如上的配置,我就可以实现将 logging 输出到三个位置,并可以实现对应的效果。比如输出到 Elasticsearch 之后,我就可以非常方便地使用 Kibana 来查看当前运行情况,ERROR Log 的比例等等,如图所示: 也可以在它的基础上做更进一步的统计分析。

loguru

上面的实现方式已经是一个较为可行的配置方案了。然而,我还是会感觉到有些 Handler 配起来麻烦,尤其是新建一个项目的很多时候懒得去写一些配置。即使是不用上文的配置,用最基本的几行 logging 配置,像如下的通用配置:

1
2
3
import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

我也懒得去写,感觉并不是一个优雅的实现方式。 有需求就有动力啊,这不,就有人实现了这么一个库,叫做 loguru,可以将 log 的配置和使用更加简单和方便。 下面我们来看看它到底是怎么用的吧。

安装

首先,这个库的安装方式很简单,就用基本的 pip 安装即可,Python 3 版本的安装如下:

1
pip3 install loguru

安装完毕之后,我们就可以在项目里使用这个 loguru 库了。

基本使用

那么这个库怎么来用呢?我们先用一个实例感受下:

1
2
3
from loguru import logger

logger.debug('this is a debug message')

看到了吧,不需要配置什么东西,直接引入一个 logger,然后调用其 debug 方法即可。 在 loguru 里面有且仅有一个主要对象,那就是 logger,loguru 里面有且仅有一个 logger,而且它已经被提前配置了一些基础信息,比如比较友好的格式化、文本颜色信息等等。 上面的代码运行结果如下:

1
2019-10-13 22:46:12.367 | DEBUG    | __main__:<module>:4 - this is a debug message

可以看到其默认的输出格式是上面的内容,有时间、级别、模块名、行号以及日志信息,不需要手动创建 logger,直接使用即可,另外其输出还是彩色的,看起来会更加友好。 以上的日志信息是直接输出到控制台的,并没有输出到其他的地方,如果想要输出到其他的位置,比如存为文件,我们只需要使用一行代码声明即可。 例如将结果同时输出到一个 runtime.log 文件里面,可以这么写:

1
2
3
4
from loguru import logger

logger.add('runtime.log')
logger.debug('this is a debug')

很简单吧,我们也不需要再声明一个 FileHandler 了,就一行 add 语句搞定,运行之后会发现目录下 runtime.log 里面同样出现了刚刚控制台输出的 DEBUG 信息。 上面就是一些基本的使用,但这还远远不够,下面我们来详细了解下它的一些功能模块。

详细使用

既然是日志,那么最常见的就是输出到文件了。loguru 对输出到文件的配置有非常强大的支持,比如支持输出到多个文件,分级别分别输出,过大创建新文件,过久自动删除等等。 下面我们分别看看这些怎样来实现,这里基本上就是 add 方法的使用介绍。因为这个 add 方法就相当于给 logger 添加了一个 Handler,它给我们暴露了许多参数来实现 Handler 的配置,下面我们来详细介绍下。 首先看看它的方法定义吧:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def add(
self,
sink,
*,
level=_defaults.LOGURU_LEVEL,
format=_defaults.LOGURU_FORMAT,
filter=_defaults.LOGURU_FILTER,
colorize=_defaults.LOGURU_COLORIZE,
serialize=_defaults.LOGURU_SERIALIZE,
backtrace=_defaults.LOGURU_BACKTRACE,
diagnose=_defaults.LOGURU_DIAGNOSE,
enqueue=_defaults.LOGURU_ENQUEUE,
catch=_defaults.LOGURU_CATCH,
**kwargs
):
pass

看看它的源代码,它支持这么多的参数,如 level、format、filter、color 等等,另外我们还注意到它有个非常重要的参数 sink,我们看看官方文档:https://loguru.readthedocs.io/en/stable/api/logger.html#sink,可以了解到通过 sink 我们可以传入多种不同的数据结构,汇总如下:

  • sink 可以传入一个 file 对象,例如 sys.stderr 或者 open('file.log', 'w') 都可以。
  • sink 可以直接传入一个 str 字符串或者 pathlib.Path 对象,其实就是代表文件路径的,如果识别到是这种类型,它会自动创建对应路径的日志文件并将日志输出进去。
  • sink 可以是一个方法,可以自行定义输出实现。
  • sink 可以是一个 logging 模块的 Handler,比如 FileHandler、StreamHandler 等等,或者上文中我们提到的 CMRESHandler 照样也是可以的,这样就可以实现自定义 Handler 的配置。
  • sink 还可以是一个自定义的类,具体的实现规范可以参见官方文档。

所以说,刚才我们所演示的输出到文件,仅仅给它传了一个 str 字符串路径,他就给我们创建了一个日志文件,就是这个原理。

基本参数

下面我们再了解下它的其他参数,例如 format、filter、level 等等。 其实它们的概念和格式和 logging 模块都是基本一样的了,例如这里使用 format、filter、level 来规定输出的格式:

1
logger.add('runtime.log', format="{time} {level} {message}", filter="my_module", level="INFO")

删除 sink

另外添加 sink 之后我们也可以对其进行删除,相当于重新刷新并写入新的内容。 删除的时候根据刚刚 add 方法返回的 id 进行删除即可,看下面的例子:

1
2
3
4
5
6
from loguru import logger

trace = logger.add('runtime.log')
logger.debug('this is a debug message')
logger.remove(trace)
logger.debug('this is another debug message')

看这里,我们首先 add 了一个 sink,然后获取它的返回值,赋值为 trace。随后输出了一条日志,然后将 trace 变量传给 remove 方法,再次输出一条日志,看看结果是怎样的。 控制台输出如下:

1
2
2019-10-13 23:18:26.469 | DEBUG    | __main__:<module>:4 - this is a debug message
2019-10-13 23:18:26.469 | DEBUG | __main__:<module>:6 - this is another debug message

日志文件 runtime.log 内容如下:

1
2019-10-13 23:18:26.469 | DEBUG    | __main__:<module>:4 - this is a debug message

可以发现,在调用 remove 方法之后,确实将历史 log 删除了。但实际上这并不是删除,只不过是将 sink 对象移除之后,在这之前的内容不会再输出到日志中。 这样我们就可以实现日志的刷新重新写入操作。

rotation 配置

用了 loguru 我们还可以非常方便地使用 rotation 配置,比如我们想一天输出一个日志文件,或者文件太大了自动分隔日志文件,我们可以直接使用 add 方法的 rotation 参数进行配置。 我们看看下面的例子:

1
logger.add('runtime_{time}.log', rotation="500 MB")

通过这样的配置我们就可以实现每 500MB 存储一个文件,每个 log 文件过大就会新创建一个 log 文件。我们在配置 log 名字时加上了一个 time 占位符,这样在生成时可以自动将时间替换进去,生成一个文件名包含时间的 log 文件。 另外我们也可以使用 rotation 参数实现定时创建 log 文件,例如:

1
logger.add('runtime_{time}.log', rotation='00:00')

这样就可以实现每天 0 点新创建一个 log 文件输出了。 另外我们也可以配置 log 文件的循环时间,比如每隔一周创建一个 log 文件,写法如下:

1
logger.add('runtime_{time}.log', rotation='1 week')

这样我们就可以实现一周创建一个 log 文件了。

retention 配置

很多情况下,一些非常久远的 log 对我们来说并没有什么用处了,它白白占据了一些存储空间,不清除掉就会非常浪费。retention 这个参数可以配置日志的最长保留时间。 比如我们想要设置日志文件最长保留 10 天,可以这么来配置:

1
logger.add('runtime.log', retention='10 days')

这样 log 文件里面就会保留最新 10 天的 log,妈妈再也不用担心 log 沉积的问题啦。

compression 配置

loguru 还可以配置文件的压缩格式,比如使用 zip 文件格式保存,示例如下:

1
logger.add('runtime.log', compression='zip')

这样可以更加节省存储空间。

字符串格式化

loguru 在输出 log 的时候还提供了非常友好的字符串格式化功能,像这样:

1
logger.info('If you are using Python {}, prefer {feature} of course!', 3.6, feature='f-strings')

这样在添加参数就非常方便了。

Traceback 记录

在很多情况下,如果遇到运行错误,而我们在打印输出 log 的时候万一不小心没有配置好 Traceback 的输出,很有可能我们就没法追踪错误所在了。 但用了 loguru 之后,我们用它提供的装饰器就可以直接进行 Traceback 的记录,类似这样的配置即可:

1
2
3
4
@logger.catch
def my_function(x, y, z):
# An error? It's caught anyway!
return 1 / (x + y + z)

我们做个测试,我们在调用时三个参数都传入 0,直接引发除以 0 的错误,看看会出现什么情况:

1
my_function(0, 0, 0)

运行完毕之后,可以发现 log 里面就出现了 Traceback 信息,而且给我们输出了当时的变量值,真的是不能再赞了!结果如下:

1
2
3
4
5
6
7
8
9
10
11
\> File "run.py", line 15, in <module>
my_function(0, 0, 0)
<function my_function at 0x1171dd510>

File "/private/var/py/logurutest/demo5.py", line 13, in my_function
return 1 / (x + y + z)
0
0
0

ZeroDivisionError: division by zero

因此,用 loguru 可以非常方便地实现日志追踪,debug 效率可能要高上十倍了? 另外 loguru 还有很多很多强大的功能,这里就不再一一展开讲解了,更多的内容大家可以看看 loguru 的官方文档详细了解一下:https://loguru.readthedocs.io/en/stable/index.html。 看完之后,是时候把自己的 logging 模块替换成 loguru 啦!

JavaScript

在夜幕读者群和算法反爬虫群的朋友都知道,我的新书《Python3 反爬虫原理与绕过实战》很快就要印刷出版了。 出版社的小姐姐们为本书设计了很多款封面

但目前暂未选定封面

之前我也有放出大章目录和配套代码,但详细目录和最新进展一直没机会公开。配套代码放在 GitHub 仓库,大章目录也在。 这次将详细目录呈现给大家。请大家先阅读《Python3 反爬虫原理与绕过实战》的内容提要

本书描述了爬虫技术与反爬虫技术的对抗过程,并详细介绍了这其中的原理和具体实现方法。首先讲 解开发环境的配置、Web 网站的构成、页面渲染以及动态网页和静态网页对爬虫造成的影响。然后介绍了 不同类型的反爬虫原理、具体实现和绕过方法,另外还涉及常见验证码的实现过程,并使用深度学习技术 完成了验证。最后介绍了常见的编码和加密原理、JavaScript 代码混淆知识、前端禁止事件以及与爬虫相 关的法律知识和风险点。 本书既适合需要储备反爬虫知识的前端工程师和后端工程师,也适合需要储备绕过知识的爬虫工程师、 爬虫爱好者以及 Python 程序员。

作者是谁

这本书谁写的?靠不靠谱呢? 这个靓仔就是我,韦世东。 作者韦世东是资深爬虫工程师,2019年华为云认证云享专家、掘金社区优秀作者、GitChat认证作者、搜狐产品技术约稿作者、夜幕团队成员。拥有七年互联网从业经验,擅长反爬虫的设计和绕过技巧。

详细目录

以下放出的章节目录为改版前的目录,大部分章和节都配套实战环节,实际上新版目录与这里的略有差异。

什么时候可以买到?

审核、校对和排版工作早已进行,按照正常流程来说月底送印,双十一之前会在各大在线书城(如京东、当当等)跟大家见面。 同时也会开启直播送书、抽奖送书等活动。想要参与活动的朋友可以添加我好友,微信号:Domfreez。加好友进群以获得书籍和活动的最新消息。欢迎大家保持对《Python3 反爬虫原理与绕过实战》的关注,新书发布后会有很多活动回馈给大家!

技术杂谈

大家有没有一种感觉,很多网站其实做得非常优秀,但是它们就是没有开发 PC (电脑)版的客户端,比如知乎、GitHub、微信公众号。 如果我们大多数时间都是使用 PC 开发或者办公的,每次开始时我们都需要打开浏览器输入它们的网址,进入对应的页面。另外一个浏览器中我们可能会开各种各样的选项卡,少则两三个,多则一二十个,这就导致某些我们常用的甚至重度依赖的网站在切换的时候就会不怎么方便。 比如挤在一堆浏览器里面的 GitHub,选项卡已经被挤得看不全了: image-20191009212626789 这时候,如果我们能有一个客户端,即 Window 上的 exe 程序或 Mac 上的 app 应用程序,它们的名字就叫做 GitHub、微信公众平台等等,打开之后只单独负责呈现 GitHub、微信公众号的内容,我们就可以免去在浏览器中来回寻找站点和切换站点的麻烦。 甚至说,在 Windows 上我们可以直接把这个应用放在桌面或把它 Pin 到任务栏上, Mac 上我们可以直接将它固定到 Dock 栏上,这样一键就打开了,省时省力。如果使用了快捷启动软件,比如 Wox (Windows)或 Alfred(Mac),直接输入 GitHub 或者微信公众平台,那就更方便唤出了,简直不要太方便。 而且,我个人感觉,用客户端软件比用网页更有一种「踏实感」,不知道大家会不会也有这种感觉。 所以,如果能将这些常用的或者重度依赖的网站转成客户端软件,那就再方便不过了。 比如我用的是 Mac,把 GitHub 转成客户端软件之后,我习惯性用 Alfred 呼出: image-20191009213959316 然后就打开了一个 GitHub.app: image-20191009214125953 然后把它固定到 Dock 栏上: image-20191009214254670 就仿佛拥有了一个 GitHub 的客户端,功能与网页一模一样,再也不用在浏览器里面切来切去。而且也不用担心版本更新的问题,因为它就是开了一个独立的网页,网页改版或者更新,内容就随着更新。 是不是很方便呢? 如果你觉得是,那就随着我来了解一下怎样实现吧。

nativefier

这里需要用到的一个工具,名字叫做 nativefier,是基于 electron 开发的,它的功能就是把任意的网页转成一个电脑客户端,即 Desktop Application, 有了这个软件,把网页转成电脑客户端只需要这么一条简单的命令:

1
nativefier <website>

比如把 Whatsapp 的网站打包成一个客户端就只需要执行这样的命令:

1
nativefier web.whatsapp.com

示意如下: Walkthrough 怎样,不论是什么网页,就可以使用它来转换成一个客户端软件。 另外它支持三大操作系统,Windows、Linux、Mac,即用它可以将网页转成 .exe.app 等格式。

安装

那么这软件究竟具体怎么来使用呢,第一步当然就是安装了。 由于 nativefier 是基于 electron 开发的,而后者又是基于 Node.js 的,所以要使用它必须要安装 Node.js,建议安装 6.0 以上版本。 另外在 Linux 和 Mac 平台可能需要安装其他的依赖。

  • 在 Linux 上需要安装 Wine 并配置好环境变量。
  • 在 Mac 上需要安装 iconutil、imagemagick,这两个依赖是为了帮助程序处理 App 的 icon 的。

具体的安装说明可以参见:https://github.com/jiahaog/nativefier#optional-dependencies。 以上步骤完成之后,使用 npm 安装 nativefier 即可:

1
npm install nativefier -g

安装完毕之后便可以使用 nativefier 命令了。

使用

下面我在 Mac 下以 GitHub 为例来介绍下怎样将 GitHub 打包成一个客户端软件。 像刚才介绍的一样,最简单直接的,运行下面的命令就好了:

1
nativefier https://github.com

它会尝试用 GitHub 主页的 title 来命名这个客户端,而 GitHub 的 title 比较长,叫做:

1
The worlds leading software development platform  GitHub

所以它会生成这样的一个客户端软件: image-20191009220450996 这个名字有点奇怪,我们可以使用命令的一个选项即可控制生成的客户端的名称,添加一个 name 参数即可:

1
nativefier --name GitHub https://github.com

这样便会生成一个名为 GitHub 的客户端: image-20191009220717549 另外我们可以看到客户端的图标也自动生成了,这个图标怎么来的呢?这个是用的 nativefier 维护的 icons,恰好 GitHub 在它们的收录范围内,所以就用上了。这些 icons 也是一个公开的 Repository,链接为: https://github.com/jiahaog/nativefier-icons,大家可以到这里搜集或者贡献图标。 如果我们觉得 nativefier 官方提供的图标不好看,想要自定义图标的话,也是可以的,只需要添加一个 icon 参数即可,这样便可以指定本地图片作为图标来生成了。 但值得注意的是,不同平台上要求的图标格式不一样。

  • Windows 上需要 ico 格式。
  • Linux 上需要 png 格式。
  • Mac 上需要 icns 格式,如果安装了上文所需要的依赖,使用 png 格式也是可以的。

具体的参数用法说明可以看:https://github.com/jiahaog/nativefier/blob/master/docs/api.md#icon。 好,那么在 Mac 上我安装了依赖,那就直接用 png 格式的图标了。 在这里我自己做了一个圆形的图标如下,命名为 github.png: 2019-10-09-141852 然后把图片使用下面的命令就可以自定义图标了:

1
nativefier --name GitHub --icon ./github.png https://github.com

这样就能生成自定义图标的客户端软件了。 打开之后,登录,我们就拥有了一个 GitHub 客户端了,界面和网页一模一样,但是已经摆脱了混杂选项卡的干扰,示意如下: image-20191009223006991 好了,这就是基本的用法,其实大部分情况只需要这几个参数就够了,如果想了解功能大家可以参考官方的 API 文档:https://github.com/jiahaog/nativefier/blob/master/docs/api.md#api。 如果想要生成其他的客户端,如微信公众平台、知乎等等都是可以的。 如微信公众平台就是这样的: image-20191009222257275

注意

在使用过程中我发现 name 参数对中文的支持并不好,总会生成一个 APP 的客户端,在这里推荐 name 使用英文名称,比如知乎用 Zhihu,微信平台用 WXMP 等等。 例如命令:

1
nativefier --name 知乎 --icon ./zhihu.png https://www.zhihu.com

可以用下面的命令代替:

1
nativefier --name Zhihu --icon ./zhihu.png https://www.zhihu.com

生成客户端软件知乎再手动修改下图标的名称即可。 另外生成的客户端软件是不支持插件的,如果你的站点对某些插件的依赖比较强,那就不建议使用 nativefier 转成的客户端了。 好了,这就是 nativefier 的基本用法,有了它我们就可以随意地将网页转成客户端软件了,快来试试吧!

技术杂谈

趁着周末,搭建了一下 NightTeam 的官方博客和官方主页,耗时数个小时,两个站点终于完工了。 由于 NightTeam 的域名是 nightteam.cn,所以这里官方博客使用了二级域名 blog.nightteam.cn,官方主页使用了根域名 nightteam.cn,现在两个站点都已经稳定运行在 GitHub Pages 上面了,大家如果感兴趣可以去看一下。

这里的主页就是用一个基本的静态页面搭建了,没有什么技术含量。博客相对复杂一点,使用了 Hexo 框架,采用了 Next 主题,在搭建的过程中我就顺手把搭建的流程大致记录下来了,在这里扩充一下形成一篇记录,毕竟好记性不如烂笔头。 于是,这篇《利用 GitHub 从零开始搭建一个博客》的文章就诞生了。

准备条件

在这里先跟大家说一些准备条件,有些同学可能一听到搭建博客就望而却步。弄个博客网站,不得有台服务器吗?不得搞数据库吗?不得注册域名吗?没事,如果都没有,那照样是能搭建一个博客的。 GitHub 是个好东西啊,它提供了 GitHub Pages 帮助我们来架设一个静态网站,这就解决了服务器的问题。 Hexo 这个博客框架没有那么重量级,它是 MarkDown 直接写文章的,然后 Hexo 可以直接将文章编译成静态网页文件并发布,所以这样文章的内容、标题、标签等信息就没必要存数据库里面了,是直接纯静态页面了,这就解决了数据库的问题。 GitHub Pages 允许每个账户创建一个名为 {username}.github.io 的仓库,另外它还会自动为这个仓库分配一个 github.io 的二级域名,这就解决了域名的问题,当然如果想要自定义域名的话,也可以支持。 所以说,基本上,先注册个 GitHub 账号就能搞了,下面我们来正式开始吧。

新建项目

首先在 GitHub 新建一个仓库(Repository),名称为 {username}.github.io,注意这个名比较特殊,必须要是 github.io 为后缀结尾的。比如 NightTeam 的 GitHub 用户名就叫 NightTeam,那我就新建一个 nightteam.github.io,新建完成之后就可以进行后续操作了。 另外如果 GitHub 没有配置 SSH 连接的建议配置一下,这样后面在部署博客的时候会更方便。

安装环境

安装 Node.js

首先在自己的电脑上安装 Node.js,下载地址:https://nodejs.org/zh-cn/download/,可以安装 Stable 版本。 安装完毕之后,确保环境变量配置好,能正常使用 npm 命令。

安装 Hexo

接下来就需要安装 Hexo 了,这是一个博客框架,Hexo 官方还提供了一个命令行工具,用于快速创建项目、页面、编译、部署 Hexo 博客,所以在这之前我们需要先安装 Hexo 的命令行工具。 命令如下:

1
npm install -g hexo-cli

安装完毕之后,确保环境变量配置好,能正常使用 hexo 命令。

初始化项目

接下来我们使用 Hexo 的命令行创建一个项目,并将其在本地跑起来,整体跑通看看。 首先使用如下命令创建项目:

1
hexo init {name}

这里的 name 就是项目名,我这里要创建 NightTeam 的博客,我就把项目取名为 nightteam 了,用了纯小写,命令如下:

1
hexo init nightteam

这样 nightteam 文件夹下就会出现 Hexo 的初始化文件,包括 themes、scaffolds、source 等文件夹,这些内容暂且先不用管是做什么的,我们先知道有什么,然后一步步走下去看看都发生了什么变化。 接下来我们首先进入新生成的文件夹里面,然后调用 Hexo 的 generate 命令,将 Hexo 编译生成 HTML 代码,命令如下:

1
hexo generate

可以看到输出结果里面包含了 js、css、font 等内容,并发现他们都处在了项目根目录下的 public 文件夹下面了。 然后我们利用 Hexo 提供的 server 命令把博客在本地运行起来,命令如下:

1
hexo server

运行之后命令行输出如下:

1
2
INFO  Start processing
INFO Hexo is running at http://localhost:4000 . Press Ctrl+C to stop.

它告诉我们在本地 4000 端口上就可以查看博客站点了,如图所示: 这样一个博客的架子就出来了,我们只用了三个命令就完成了。

部署

接下来我们来将这个初始化的博客进行一下部署,放到 GitHub Pages 上面验证一下其可用性。成功之后我们可以再进行后续的修改,比如修改主题、修改页面配置等等。 那么怎么把这个页面部署到 GitHub Pages 上面呢,其实 Hexo 已经给我们提供一个命令,利用它我们可以直接将博客一键部署,不需要手动去配置服务器或进行其他的各项配置。 部署命令如下:

1
hexo deploy

在部署之前,我们需要先知道博客的部署地址,它需要对应 GitHub 的一个 Repository 的地址,这个信息需要我们来配置一下。 打开根目录下的 _config.yml 文件,找到 Deployment 这个地方,把刚才新建的 Repository 的地址贴过来,然后指定分支为 master 分支,最终修改为如下内容:

1
2
3
4
5
6
# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
type: git
repo: {git repo ssh address}
branch: master

我的就修改为如下内容:

1
2
3
4
5
6
# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
type: git
repo: git@github.com:NightTeam/nightteam.github.io.git
branch: master

另外我们还需要额外安装一个支持 Git 的部署插件,名字叫做 hexo-deployer-git,有了它我们才可以顺利将其部署到 GitHub 上面,如果不安装的话,在执行部署命令时会报如下错误:

1
Deployer not found: git

好,那就让我们安装下这个插件,在项目目录下执行安装命令如下:

1
npm install hexo-deployer-git --save

安装成功之后,执行部署命令:

1
hexo deploy

运行结果类似如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
INFO  Deploying: git
INFO Clearing .deploy_git folder...
INFO Copying files from public folder...
INFO Copying files from extend dirs...
On branch master
nothing to commit, working directory clean
Counting objects: 46, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (36/36), done.
Writing objects: 100% (46/46), 507.66 KiB | 0 bytes/s, done.
Total 46 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), done.
To git@github.com:NightTeam/nightteam.github.io.git
* [new branch] HEAD -> master
Branch master set up to track remote branch master from git@github.com:NightTeam/nightteam.github.io.git.
INFO Deploy done: git

如果出现类似上面的内容,就证明我们的博客已经成功部署到 GitHub Pages 上面了,这时候我们访问一下 GitHub Repository 同名的链接,比如我的 NightTeam 博客的 Repository 名称取的是 nightteam.github.io,那我就访问 http://nightteam.github.io,这时候我们就可以看到跟本地一模一样的博客内容了。 这时候我们去 GitHub 上面看看 Hexo 上传了什么内容,打开之后可以看到 master 分支有了这样的内容: 仔细看看,这实际上是博客文件夹下面的 public 文件夹下的所有内容,Hexo 把编译之后的静态页面内容上传到 GitHub 的 master 分支上面去了。 这时候可能就有人有疑问了,那我博客的源码也想放到 GitHub 上面怎么办呢?其实很简单,新建一个其他的分支就好了,比如我这边就新建了一个 source 分支,代表博客源码的意思。 具体的添加过程就很简单了,参加如下命令:

1
2
3
4
5
6
git init
git checkout -b source
git add -A
git commit -m "init blog"
git remote add origin git@github.com:{username}/{username}.github.io.git
git push origin source

成功之后,可以到 GitHub 上再切换下默认分支,比如我就把默认的分支设置为了 source,当然不换也可以。

配置站点信息

完成如上内容之后,实际上我们只完成了博客搭建的一小步,因为我们仅仅是把初始化的页面部署成功了,博客里面还没有设置任何有效的信息。下面就让我们来进行一下博客的基本配置,另外换一个好看的主题,配置一些其他的内容,让博客真正变成属于我们自己的博客吧。 下面我就以自己的站点 NightTeam 为例,修改一些基本的配置,比如站点名、站点描述等等。 修改根目录下的 _config.yml 文件,找到 Site 区域,这里面可以配置站点标题 title、副标题 subtitle 等内容、关键字 keywords 等内容,比如我的就修改为如下内容:

1
2
3
4
5
6
# Site
title: NightTeam
subtitle: 一个专注技术的组织
description: 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。
keywords: "Python, Rust, C++, Go, 爬虫, 深度学习, 服务研发, 对象存储"
author: NightTeam

这里大家可以参照格式把内容改成自己的。 另外还可以设置一下语言,如果要设置为汉语的话可以将 language 的字段设置为 zh-CN,修改如下:

1
language: zh-CN

这样就完成了站点基本信息的配置,完成之后可以看到一些基本信息就修改过来了,页面效果如下:

修改主题

目前来看,整个页面的样式个人感觉并不是那么好看,想换一个风格,这就涉及到主题的配置了。目前 Hexo 里面应用最多的主题基本就是 Next 主题了,个人感觉这个主题还是挺好看的,另外它支持的插件和功能也极为丰富,配置了这个主题,我们的博客可以支持更多的扩展功能,比如阅览进度条、中英文空格排版、图片懒加载等等。 那么首先就让我们来安装下 Next 这个主题吧,目前 Next 主题已经更新到 7.x 版本了,我们可以直接到 Next 主题的 GitHub Repository 上把这个主题下载下来。 主题的 GitHub 地址是:https://github.com/theme-next/hexo-theme-next,我们可以直接把 master 分支 Clone 下来。 首先命令行进入到项目的根目录,执行如下命令即可:

1
git clone https://github.com/theme-next/hexo-theme-next themes/next

执行完毕之后 Next 主题的源码就会出现在项目的 themes/next 文件夹下。 然后我们需要修改下博客所用的主题名称,修改项目根目录下的 _config.yml 文件,找到 theme 字段,修改为 next 即可,修改如下:

1
theme: next

然后本地重新开启服务,访问刷新下页面,就可以看到 next 主题就切换成功了,预览效果如下:

主题配置

现在我们已经成功切换到 next 主题上面了,接下来我们就对主题进行进一步地详细配置吧,比如修改样式、增加其他各项功能的支持,下面逐项道来。 Next 主题内部也提供了一个配置文件,名字同样叫做 _config.yml,只不过位置不一样,它在 themes/next 文件夹下,Next 主题里面所有的功能都可以通过这个配置文件来控制,下文所述的内容都是修改的 themes/next/_config.yml 文件。

样式

Next 主题还提供了多种样式,风格都是类似黑白的搭配,但整个布局位置不太一样,通过修改配置文件的 scheme 字段即可,我选了 Pisces 样式,修改 _config.yml (注意是 themes/next/_config.yml 文件)如下:

1
scheme: Pisces

刷新页面之后就会变成这种样式,如图所示: 另外还有几个可选项,比如:

1
2
3
4
# scheme: Muse
#scheme: Mist
scheme: Pisces
#scheme: Gemini

大家可以自行根据喜好选择。

favicon

favicon 就是站点标签栏的小图标,默认是用的 Hexo 的小图标,如果我们有站点 Logo 的图片的话,我们可以自己定制小图标。 但这并不意味着我们需要自己用 PS 自己来设计,已经有一个网站可以直接将图片转化为站点小图标,站点链接为:https://realfavicongenerator.net,到这里上传一张图,便可以直接打包下载各种尺寸和适配不同设备的小图标。 图标下载下来之后把它放在 themes/next/source/images 目录下面。 然后在配置文件里面找到 favicon 配置项,把一些相关路径配置进去即可,示例如下:

1
2
3
4
5
favicon:
small: /images/favicon-16x16.png
medium: /images/favicon-32x32.png
apple_touch_icon: /images/apple-touch-icon.png
safari_pinned_tab: /images/safari-pinned-tab.svg

配置完成之后刷新页面,整个页面的标签图标就被更新了。

avatar

avatar 这个就类似站点的头像,如果设置了这个,会在站点的作者信息旁边额外显示一个头像,比如我这边有一张 avatar.png 图片: 将其放置到 themes/next/source/images/avatar.png 路径,然后在主题 _config.yml 文件下编辑 avatar 的配置,修改为正确的路径即可。

1
2
3
4
5
6
7
8
9
10
# Sidebar Avatar
avatar:
# In theme directory (source/images): /images/avatar.gif
# In site directory (source/uploads): /uploads/avatar.gif
# You can also use other linking images.
url: /images/avatar.png
# If true, the avatar would be dispalyed in circle.
rounded: true
# If true, the avatar would be rotated with the cursor.
rotated: true

这里有 rounded 选项是是否显示圆形,rotated 是是否带有旋转效果,大家可以根据喜好选择是否开启。 效果如下: 配置完成之后就会显示头像。

rss

博客一般是需要 RSS 订阅的,如果要开启 RSS 订阅,这里需要安装一个插件,叫做 hexo-generator-feed,安装完成之后,站点会自动生成 RSS Feed 文件,安装命令如下:

1
npm install hexo-generator-feed --save

在项目根目录下运行这个命令,安装完成之后不需要其他的配置,以后每次编译生成站点的时候就会自动生成 RSS Feed 文件了。

code

作为程序猿,代码块的显示还是需要很讲究的,默认的代码块我个人不是特别喜欢,因此我把代码的颜色修改为黑色,并把复制按钮的样式修改为类似 Mac 的样式,修改 _config.yml 文件的 codeblock 区块如下:

1
2
3
4
5
6
7
8
9
10
11
12
codeblock:
# Code Highlight theme
# Available values: normal | night | night eighties | night blue | night bright
# See: https://github.com/chriskempson/tomorrow-theme
highlight_theme: night bright
# Add copy button on codeblock
copy_button:
enable: true
# Show text copy result.
show_result: true
# Available values: default | flat | mac
style: mac

修改前的代码样式: 修改后的代码样式: 嗯,个人觉得整体看起来逼格高了不少。

top

我们在浏览网页的时候,如果已经看完了想快速返回到网站的上端,一般都是有一个按钮来辅助的,这里也支持它的配置,修改 _config.yml 的 back2top 字段即可,我的设置如下:

1
2
3
4
5
6
back2top:
enable: true
# Back to top in sidebar.
sidebar: false
# Scroll percent label in b2t button.
scrollpercent: true

enable 默认为 true,即默认显示。sidebar 如果设置为 true,按钮会出现在侧栏下方,个人觉得并不是很好看,就取消了,scrollpercent 就是显示阅读百分比,个人觉得还不错,就将其设置为 true。 具体的效果大家可以设置后根据喜好选择。

reading_process

reading_process,阅读进度。大家可能注意到有些站点的最上侧会出现一个细细的进度条,代表页面加载进度和阅读进度,如果大家想设置的话也可以试试,我将其打开了,修改 _config.yml 如下:

1
2
3
4
5
6
reading_progress:
enable: true
# Available values: top | bottom
position: top
color: "#222"
height: 2px

设置之后显示效果如下:

bookmark

书签,可以根据阅读历史记录,在下次打开页面的时候快速帮助我们定位到上次的位置,大家可以根据喜好开启和关闭,我的配置如下:

1
2
3
4
5
6
7
bookmark:
enable: false
# Customize the color of the bookmark.
color: "#222"
# If auto, save the reading progress when closing the page or clicking the bookmark-icon.
# If manual, only save it by clicking the bookmark-icon.
save: auto

github_banner

在一些技术博客上,大家可能注意到在页面的右上角有个 GitHub 图标,点击之后可以跳转到其源码页面,可以为 GitHub Repository 引流,大家如果想显示的话可以自行选择打开,我的配置如下:

1
2
3
4
5
# `Follow me on GitHub` banner in the top-right corner.
github_banner:
enable: true
permalink: https://github.com/NightTeam/nightteam.github.io
title: NightTeam GitHub

记得修改下链接 permalink 和标题 title,显示效果如下: 可以看到在页面右上角显示了 GitHub 的图标,点击可以进去到 Repository 页面。

gitalk

由于 Hexo 的博客是静态博客,而且也没有连接数据库的功能,所以它的评论功能是不能自行集成的,但可以集成第三方的服务。 Next 主题里面提供了多种评论插件的集成,有 changyan | disqus | disqusjs | facebook_comments_plugin | gitalk | livere | valine | vkontakte 这些。 作为一名程序员,我个人比较喜欢 gitalk,它是利用 GitHub 的 Issue 来当评论,样式也比较不错。 首先需要在 GitHub 上面注册一个 OAuth Application,链接为:https://github.com/settings/applications/new,注册完毕之后拿到 Client ID、Client Secret 就可以了。 首先需要在 _config.yml 文件的 comments 区域配置使用 gitalk:

1
2
3
4
5
6
7
# Multiple Comment System Support
comments:
# Available values: tabs | buttons
style: tabs
# Choose a comment system to be displayed by default.
# Available values: changyan | disqus | disqusjs | facebook_comments_plugin | gitalk | livere | valine | vkontakte
active: gitalk

主要是 comments.active 字段选择对应的名称即可。 然后找打 gitalk 配置,添加它的各项配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Gitalk
# Demo: https://gitalk.github.io
# For more information: https://github.com/gitalk/gitalk
gitalk:
enable: true
github_id: NightTeam
repo: nightteam.github.io # Repository name to store issues
client_id: {your client id} # GitHub Application Client ID
client_secret: {your client secret} # GitHub Application Client Secret
admin_user: germey # GitHub repo owner and collaborators, only these guys can initialize gitHub issues
distraction_free_mode: true # Facebook-like distraction free mode
# Gitalk's display language depends on user's browser or system environment
# If you want everyone visiting your site to see a uniform language, you can set a force language value
# Available values: en | es-ES | fr | ru | zh-CN | zh-TW
language: zh-CN

配置完成之后 gitalk 就可以使用了,点击进入文章页面,就会出现如下页面: GitHub 授权登录之后就可以使用了,评论的内容会自动出现在 Issue 里面。

pangu

我个人有个强迫症,那就是写中文和英文的时候中间必须要留有间距,一个简单直接的方法就是中间加个空格,但某些情况下可能习惯性不加或者忘记加了,这就导致中英文混排并不是那么美观。 pangu 就是来解决这个问题的,我们只需要在主题里面开启这个选项,在编译生成页面的时候,中英文之间就会自动添加空格,看起来更加美观。 具体的修改如下:

1
pangu: true

math

可能在一些情况下我们需要写一个公式,比如演示一个算法推导过程,MarkDown 是支持公式显示的,Hexo 的 Next 主题同样是支持的。 Next 主题提供了两个渲染引擎,分别是 mathjax 和 katex,后者相对前者来说渲染速度更快,而且不需要 JavaScript 的额外支持,但后者支持的功能现在还不如前者丰富,具体的对比可以看官方文档:https://theme-next.org/docs/third-party-services/math-equations。 所以我这里选择了 mathjax,通过修改配置即可启用:

1
2
3
4
5
6
7
8
9
10
11
12
13
math:
enable: true

# Default (true) will load mathjax / katex script on demand.
# That is it only render those page which has `mathjax: true` in Front-matter.
# If you set it to false, it will load mathjax / katex srcipt EVERY PAGE.
per_page: true

# hexo-renderer-pandoc (or hexo-renderer-kramed) required for full MathJax support.
mathjax:
enable: true
# See: https://mhchem.github.io/MathJax-mhchem/
mhchem: true

mathjax 的使用需要我们额外安装一个插件,叫做 hexo-renderer-kramed,另外也可以安装 hexo-renderer-pandoc,命令如下:

1
2
npm un hexo-renderer-marked --save
npm i hexo-renderer-kramed --save

另外还有其他的插件支持,大家可以到官方文档查看。

pjax

可能大家听说过 Ajax,没听说过 pjax,这个技术实际上就是利用 Ajax 技术实现了局部页面刷新,既可以实现 URL 的更换,有可以做到无刷新加载。 要开启这个功能需要先将 pjax 功能开启,然后安装对应的 pjax 依赖库,首先修改 _config.yml 修改如下:

1
pjax: true

然后安装依赖库,切换到 next 主题下,然后安装依赖库:

1
2
$ cd themes/next
$ git clone https://github.com/theme-next/theme-next-pjax source/lib/pjax

这样 pjax 就开启了,页面就可以实现无刷新加载了。 另外关于 Next 主题的设置还有挺多的,这里就介绍到这里了,更多的主题设置大家可以参考官方文档:https://theme-next.org/docs/

文章

现在整个站点只有一篇文章,那么我们怎样来增加其他的文章呢? 这个很简单,只需要调用 Hexo 提供的命令即可,比如我们要新建一篇「HelloWorld」的文章,命令如下:

1
hexo new hello-world

创建的文章会出现在 source/_posts 文件夹下,是 MarkDown 格式。 在文章开头通过如下格式添加必要信息:

1
2
3
4
5
6
7
8
9
10
11
\---
title: 标题 # 自动创建,如 hello-world
date: 日期 # 自动创建,如 2019-09-22 01:47:21
tags:
- 标签1
- 标签2
- 标签3
categories:
- 分类1
- 分类2
---

开头下方撰写正文,MarkDown 格式书写即可。 这样在下次编译的时候就会自动识别标题、时间、类别等等,另外还有其他的一些参数设置,可以参考文档:https://hexo.io/zh-cn/docs/writing.html

标签页

现在我们的博客只有首页、文章页,如果我们想要增加标签页,可以自行添加,这里 Hexo 也给我们提供了这个功能,在根目录执行命令如下:

1
hexo new page tags

执行这个命令之后会自动帮我们生成一个 source/tags/index.md 文件,内容就只有这样子的:

1
2
3
4
\---
title: tags
date: 2019-09-26 16:44:17
---

我们可以自行添加一个 type 字段来指定页面的类型:

1
2
type: tags
comments: false

然后再在主题的 _config.yml 文件将这个页面的链接添加到主菜单里面,修改 menu 字段如下:

1
2
3
4
5
6
7
8
9
menu:
home: / || home
#about: /about/ || user
tags: /tags/ || tags
#categories: /categories/ || th
archives: /archives/ || archive
#schedule: /schedule/ || calendar
#sitemap: /sitemap.xml || sitemap
#commonweal: /404/ || heartbeat

这样重新本地启动看下页面状态,效果如下: 可以看到左侧导航也出现了标签,点击之后右侧会显示标签的列表。

分类页

分类功能和标签类似,一个文章可以对应某个分类,如果要增加分类页面可以使用如下命令创建:

1
hexo new page categories

然后同样地,会生成一个 source/categories/index.md 文件。 我们可以自行添加一个 type 字段来指定页面的类型:

1
2
type: categories
comments: false

然后再在主题的 _config.yml 文件将这个页面的链接添加到主菜单里面,修改 menu 字段如下:

1
2
3
4
5
6
7
8
9
menu:
home: / || home
#about: /about/ || user
tags: /tags/ || tags
categories: /categories/ || th
archives: /archives/ || archive
#schedule: /schedule/ || calendar
#sitemap: /sitemap.xml || sitemap
#commonweal: /404/ || heartbeat

这样页面就会增加分类的支持,效果如下:

搜索页

很多情况下我们需要搜索全站的内容,所以一个搜索功能的支持也是很有必要的。 如果要添加搜索的支持,需要先安装一个插件,叫做 hexo-generator-searchdb,命令如下:

1
npm install hexo-generator-searchdb --save

然后在项目的 _config.yml 里面添加搜索设置如下:

1
2
3
4
5
search:
path: search.xml
field: post
format: html
limit: 10000

然后在主题的 _config.yml 里面修改如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
# Local search
# Dependencies: https://github.com/wzpan/hexo-generator-search
local_search:
enable: true
# If auto, trigger search by changing input.
# If manual, trigger search by pressing enter key or search button.
trigger: auto
# Show top n results per article, show all results by setting to -1
top_n_per_article: 5
# Unescape html strings to the readable one.
unescape: false
# Preload the search data when the page loads.
preload: false

这里用的是 Local Search,如果想启用其他是 Search Service 的话可以参考官方文档:https://theme-next.org/docs/third-party-services/search-services

404 页面

另外还需要添加一个 404 页面,直接在根目录 source 文件夹新建一个 404.md 文件即可,内容可以仿照如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
\---
title: 404 Not Found
date: 2019-09-22 10:41:27
---

<center>
对不起,您所访问的页面不存在或者已删除。
您可以<a href="https://blog.nightteam.cn>">点击此处</a>返回首页。
</center>

<blockquote class="blockquote-center">
NightTeam
</blockquote>

这里面的一些相关信息和链接可以替换成自己的。 增加了这个 404 页面之后就可以 完成了上面的配置基本就完成了大半了,其实 Hexo 还有很多很多功能,这里就介绍不过来了,大家可以直接参考官方文档:https://hexo.io/zh-cn/docs/ 查看更多的配置。

部署脚本

最后我这边还增加了一个简易版的部署脚本,其实就是重新 gererate 下文件,然后重新部署。在根目录下新建一个 deploy.sh 的脚本文件,内容如下:

1
2
3
hexo clean
hexo generate
hexo deploy

这样我们在部署发布的时候只需要执行:

1
sh deploy.sh

就可以完成博客的更新了,非常简单。

自定义域名

将页面修改之后可以用上面的脚本重新部署下博客,其内容便会跟着更新。 另外我们也可以在 GitHub 的 Repository 里面设置域名,找到 Settings,拉到下面,可以看到有个 GitHub Pages 的配置项,如图所示: 下面有个 custom domain 的选项,输入你想自定义的域名地址,然后添加 CNAME 解析就好了。 另外下面还有一个 Enforce HTTPS 的选项,GitHub Pages 会在我们配置自定义域名之后自动帮我们配置 HTTPS 服务。刚配置完自定义域名的时候可能这个选项是不可用的,一段时间后等到其可以勾选了,直接勾选即可,这样整个博客就会变成 HTTPS 的协议的了。 另外有一个值得注意的地方,如果配置了自定义域名,在目前的情况下,每次部署的时候这个自定义域名的设置是会被自动清除的。所以为了避免这个情况,我们需要在项目目录下面新建一个 CNAME 文件,路径为 source/CNAME,内容就是自定义域名。 比如我就在 source 目录下新建了一个 CNAME 文件,内容为:

1
blog.nightteam.cn

这样避免了每次部署的时候自定义域名被清除的情况了。 以上就是从零搭建一个 Hexo 博客的流程,希望对大家有帮助。

技术杂谈

so 文件调用

随着 Android 移动安全的高速发展,不管是为了执行效率还是程序的安全性等,关键代码下沉 native 层已成为基本操作。 native 层的开发就是通指的 JNI/NDK 开发,通过 JNI 可以实现 java 层和 native 层(主要是 C/C++ )的相互调用,native 层经编译后产生 so 动态链接库,so 文件具有可移植性广,执行效率高,保密性强等优点。 那么问题来了,如何调用 so 文件显得异常重要,当然你也可以直接分析 so 文件的伪代码,利用强悍的编程功底直接模拟关键操作,但是我想对于普通人来说头发还是比较重要的。 当前调用 so 文件的主流操作应该是: 1,基于 Unicorn 的各种实现(还在学习中,暂且不表) 2,Android 服务器的搭建,在 App 内起 http 服务完成调用 so 的需求(当然前提是过了 so 的效验等操作) 至于为什么选用 AndServer,好吧,不为什么,只是因为搜索到了它 为什么结合 Service,在学习 Android 开发的时候了解到了 Service 的生命周期,个人理解用 Service 去创建 Http 服务比较好。 当然也有 Application 的简单使用,因为在正式环境中,大多数 so 文件的逻辑中都有 context 的一些包名了,签名了的效验等,自定义 Application 的话获取 context 传参就好了。

libyemu.so 简介

这是我编译好的一个 so 文件,就是根据入参做下简单的字符串拼接(以下是 native 层编译前的 c 代码)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
extern "C"
JNIEXPORT jstring JNICALL
Java_com_fw_myapplication_ndktest_NdkTest_stringFromUTF(JNIEnv *env, jobject instance, jstring str_) {
jclass String_clazz = env->FindClass("java/lang/String");

jmethodID concat_methodID = env->GetMethodID(String_clazz, "concat", "(Ljava/lang/String;)Ljava/lang/String;");

jstring str = env->NewStringUTF(" from so --[NightTeam夜幕]");

jobject str1 = env->CallObjectMethod(str_, concat_methodID, str);

const char *chars = env->GetStringUTFChars((jstring)str1, 0);

return env->NewStringUTF(chars);
}

这部分代码还是有必要贴一下的,简单的静态注册使用了反射的思想,反射在逆向中至关重要 接下来是 java 代码,定义了 native 函数

1
2
3
4
5
6
7
8
9
package com.fw.myapplication.ndktest;

public class NdkTest {
public static native String stringFromUTF(String str);

static {
System.loadLibrary("yemu");
}
}

如果到这里有点懵逼的同学可能需要去补下 Android 开发基础了

Android 项目测试 so

先说下我的环境,因为这个环境影响太大了 1,AndroidStudio 3.4 2,手机 Android 6 架构 armeabi-v7a 打开 AndroidStudio 新建 project 在 module 的 build 中加这么一句,然后 sync 把编译好的 so 文件复制到 libs 文件夹下(和刚才的 jniLibs.srcDirs 对应) 把 so 对应的 java 代码也 copy 过来,注意包名类名的一致性 打开 activity_main.xml 文件为 TextView 添加 id 打开 MainActiviy.java 开始编码 这两行的意思就是,先从布局中找到对应 id 的 TextView,然后为其设置 Text(调用 native 函数的返回值) 下面测试一下咱们的 so 调用情况 可以看到咱们的 so 文件调用成功(这里咱们的 so 没有效验,只是测试 app 是否可以正常调用)

AndServer 代码编写

AndServer 官方文档:https://yanzhenjie.com/AndServer/ 打开官方文档,看看人家的入门介绍,新建 java 文件 如图经典 MVC 的 C 就写好了,定义了一个 nightteam_sign 接口,请求方式为 get,请求参数为 sign,调用 native 函数,然后返回 json,但是这里我想利用 Application 获取下 context 对象,取下包名,接下来自定义 Applictaion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.nightteam.httpso;

import android.app.Application;

public class MyApp extends Application {
private static MyApp myApp;
public static MyApp getInstance() {
return myApp;
}

@Override
public void onCreate() {
super.onCreate();
myApp = this;
}
}

然后在 manifest 文件中指定要启动的 Application 然后修改 MyController.java 的代码 接下来把官方文档-服务器的代码 copy 下来 导入一些包,修改部分代码如下 新版本的 AndServer.serverBuilder 已经需要传递 context 了,这里把网络地址和端口号也修改为从构造参数中获取,到这里 AndServer 的东西基本完了,实际上咱们就搭建一个调 so 的接口,并没有过多的业务逻辑,所以代码就是使用的最简单的

Service 代码编写

咱们这里用按钮的点击事件启动 Service,故在 activity_main.xml 中添加一个 button 并指定点击事件 接下来编写自定义 Service 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.nightteam.httpso.Service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

import com.nightteam.httpso.ServerManager;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class MyService extends Service {
private static final String TAG = "NigthTeam";

@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate: MyService");
new Thread() {
@Override
public void run() {
super.run();
InetAddress inetAddress = null;
try {
inetAddress = InetAddress.getByName("0.0.0.0");
Log.d(TAG, "onCreate: " + inetAddress.getHostAddress());
ServerManager serverManager = new ServerManager(getApplicationContext(), inetAddress, 8005);
serverManager.startServer();
} catch (UnknownHostException e) {
e.printStackTrace();
}

}
}.start();
}

@Override
public IBinder onBind(Intent intent) {
return null;
}

}

打上了几个 log,在子线程中启动 AndServer 的服务(何时使用 UI 线程和子线程是 Android 基础,这里就不赘述了) 注意一下,这里从 0.0.0.0 获取 inetAddress,可不要写错了,localhost 和 0.0.0.0 的区别请移步搜索引擎 然后就是向 ServerManager 的构造函数传递 context,inetAddress,port 用来 new 对象,随后开启服务 最后注意检查下 manifest 文件中 Service 的声明

开启 Service,并获取本机 ip

回到我们的 MainActivity.java 的 operate( button 的点击事件)编写启动 Service 代码

1
2
3
4
5
6
7
8
9
10
11
12
public void operate(View view) {
switch (view.getId()){
case R.id.id_bt_index:
//启动服务:创建-->启动-->销毁
//如果服务已经创建了,后续重复启动,操作的都是同一个服务,不会再重新创建了,除非你先销毁它
Intent it1 = new Intent(this, MyService.class);
Log.d(TAG, "operate: button");
startService(it1);
((Button) view).setText("服务已开启");
break;
}
}

到这里我们的服务基本搭建好了,但是为了方便起见,我想把咱们的本机 ip 显示在 App 上,这样我们就不用去设置再查看了 我在网上找到了一个获取 ip 地址的一个工具类,源码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.nightteam.httpso;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.regex.Pattern;

public class NetUtils {

private static final Pattern IPV4_PATTERN = Pattern.compile("^(" +

"([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}" +

"([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");

private static boolean isIPv4Address(String input) {

return IPV4_PATTERN.matcher(input).matches();

}

//获取本机IP地址

public static InetAddress getLocalIPAddress() {

Enumeration<NetworkInterface> enumeration = null;

try {

enumeration = NetworkInterface.getNetworkInterfaces();

} catch (SocketException e) {

e.printStackTrace();

}

if (enumeration != null) {

while (enumeration.hasMoreElements()) {

NetworkInterface nif = enumeration.nextElement();

Enumeration<InetAddress> inetAddresses = nif.getInetAddresses();

if (inetAddresses != null)

while (inetAddresses.hasMoreElements()) {

InetAddress inetAddress = inetAddresses.nextElement();

if (!inetAddress.isLoopbackAddress() && isIPv4Address(inetAddress.getHostAddress())) {

return inetAddress;

}

}
}

}

return null;

}
}

把工具类 copy 到我们的 Android 项目中,继续在 MainActivity.java 中编码 获取了一下本机地址和 Android SDK 版本( Android 8 之后启动 Service 方式不一样)

申请权限,启动 App

最后一步就是为 app 申请网络权限了 随后连接我们的手机,运行项目,测试一下,点击开启服务 看下 AndroidStudio 日志 好像一切正常,在浏览器访问下试试( ip 就是 App 中显示的 ip 地址) 如图正常访问到了我们想要的内容 回过头来说下 Service,打开我们手机的设置,找到应用程序管理-运行中的服务(手机不同,方式不同) 可以看到我们的程序,运行了一个服务,这个服务就是咱们编码的 MyService 接下来杀掉该 App进程,再次查看运行中的服务 我这里在权限管理设置了自动运行,可以保持服务的运行。(这个地方还是根据系统有大小差异) 至此使用 App 起 http 服务调 so 就完成了


好了,上面就是利用 AndServer 打造 Android 服务器调 so 文件的整体思路和流程,如果你懒得看的话,直接用我写好的 App 修修补补也是可以的,只需要发送消息【AndServer搭建Web服务调so】到公众号【NightTeam】即可。


文章作者:「夜幕团队 NightTeam 」- 妄为 夜幕团队成立于 2019 年,团队成员包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

这是系列文章的第一篇,也是非常重要的一篇,希望大家能读懂我想要表达的意思。

系列文章开篇概述

相对于其他编程语言来说,Python 生态中最突出的就是第三方库。任何一个及格的 Python 开发者都使用过至少 5 款第三方库。 就爬虫领域而言,必将用到的例如网络请求库 Requests、网页解析库 Parsel 或 BeautifulSoup、数据库对象关系映射 Motor 或 SQLAlchemy、定时任务 Apscheduler、爬虫框架 Scrapy 等。 这些开源库的使用方法想必大家已经非常熟练了,甚至还修炼出了自己的一套技巧,日常工作中敲起键盘肯定也是哒哒哒的响。 但是你有没有想过:

  • 那个神奇的功能是如何实现的?
  • 这个功能背后的逻辑是什么?
  • 为什么要这样做而不是选择另一种写法?
  • 编写这样的库需要用到哪些知识?
  • 这个论点是否有明确的依据?

如果你从未这样想过,那说明你还没到达应该「渡劫」的时机;如果你曾提出过 3 个以上的疑问,那说明你即将到达那个重要的关口;如果你常常这么想,而且也尝试着寻找对应的答案,那么恭喜你,你现在正处于「渡劫」的关口之上。 偶有群友会抛出这样的问题:初级工程师、中级工程师、高级工程师如何界定? 这个问题有两种不同的观点,第一个是看工作职级,第二个则是看个人能力。工作职级是一个浮动很大的参照物,例如阿里巴巴的高级研发和我司的高级研发,职级名称都是「高级研发」,但能力可能会有很大的差距。 个人能力又如何评定呢? 难不成看代码写的快还是写的慢吗? 当然不是! 个人能力应当从广度和深度两个方面进行考量,这并没有一个明确的标准。当两人能力差异很大的时候,外人可以轻松的分辨孰强孰弱。 自己怎样分辨个人能力的进与退呢? 这就回到了上面提到的那些问题:WHO WHAT WHERE WHY WHEN HOW? 我想通过这篇文章告诉你,不要做那个用库用得很熟练的人,要做那个创造库的人。计算机世界如此吸引人,就是因为我们可以在这个世界里尽情创造。 你想做一个创造者吗? 如果不想,那现在你就可以关掉浏览器窗口,回到 Hub 的世界里。

内容介绍

这是一套系列文章,这个系列将为大家解读常见库(例如 WebSocket、HTTP、ASCII、Base64、MD5、AES、RSA)的协议规范和对应的代码实现,帮助大家「知其然,知其所以然」。

目标

这次我们要学习的是 WebSocket 协议规范和代码实现,也可以理解为从 0 开始编写 aiowebsocket 库。至于为什么选择它,那大概是因为全世界没有比我更熟悉的它的人了。 我是 aiowebsocket 库的作者,我花了 7 天编写这个库。写库的过程,让我深刻体会到造轮子和驾驶的区别,也让我有了飞速的进步。我希望用连载系列文章的形式帮助大家从驾驶者转换到创造者,拥有「编程思考」。

前置条件

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议,它的出现使客户端和服务器之间的数据交换变得更加简单。下图描述了双端交互的流程: WebSocket 通常被应用在实时性要求较高的场景,例如赛事数据、股票证券、网页聊天和在线绘图等。WebSocket 与 HTTP 协议完全不同,但同样被广泛应用。 无论是后端开发者、前端开发者、爬虫工程师或者信息安全工作者,都应该掌握 WebSocket 协议的知识。 我曾经发表过几篇关于 WebSocket 的文章:

其中,《【严选-高质量文章】开发者必知必会的 WebSocket 协议》介绍了协议规范的相关知识。这篇文章的内容大体如下:

  • WebSocket 协议来源
  • WebSocket 协议的优点
  • WebSocket 协议规范
  • 一些实际代码演示

如果没有掌握 WebSocket 协议的朋友,我建议先去阅读这篇文章,尤其是对 WebSocket 协议规范介绍的那部分。 要想将协议规范 RFC6455 变成开源库,第一步就是要熟悉整个协议规范,所以你需要阅读【严选-高质量文章】开发者必知必会的 WebSocket 协议。当然,有能力的同学直接阅读 RFC6455 也未尝不可。 接着还需要了解编程语言中内置库 Socket 的基础用法,例如 Python 中的 socket 或者更高级更潮的 StreamsTransports and Protocols。如果你是 Go 开发者、Rust 开发者,请查找对应语言的内置库。 假设你已经熟悉了 RFC6455,你应该知道 Frame 打包和解包的时候需要用到位运算,正好我之前写过位运算相关的文章 7分钟全面了解位运算。 至于其它的,现用现学吧!

Python 网络通信之 Streams

WebSocket,也可以理解为在 WEB 应用中使用的 Socket,这意味着本篇将会涉及到 Socket 编程。上面提到,Python 中与 Socket 相关的有 socket、Streams、Transports and Protocols。其中 socket 是同步的,而另外两个是异步的,这俩属于你常听到的 asyncio。

Socket 通信过程

Socket 是端到端的通信,所以我们要搞清楚消息是怎么从一台机器发送到另一台机器的,这很重要。假设通信的两台机器为 Client 和 Server,Client 向 Server 发送消息的过程如下图所示:

Client 通过文件描述符的读写 API read & write 来访问操作系统内核中的网络模块为当前套接字分配的发送 send buffer 和接收 recv buffer 缓存。 Client 进程写消息到内核的发送缓存中,内核将发送缓存中的数据传送到物理硬件 NIC,也就是网络接口芯片 (Network Interface Circuit)。 NIC 负责将翻译出来的模拟信号通过网络硬件传递到服务器硬件的 NIC。 服务器的 NIC 再将模拟信号转成字节数据存放到内核为套接字分配的接收缓存中,最终服务器进程从接收缓存中读取数据即为源客户端进程传递过来的 消息。

上述通信过程的描述和图片均出自钱文品的深入理解 RPC 交互流程。 我尝试寻找通信过程中每个步骤的依据(尤其是 send buffer to NIC to recv buffer),(我翻阅了 TCP 的 RFC 和 Kernel.org)但遗憾的是并未找到有力的证明(一定是我太菜了),如果有朋友知道,可以评论告诉我或发邮件 zenrusts@sina.com 告诉我,我可以扩展出另一篇文章。

创建 Streams

那么问题来了:在 Python 中,我们如何实现端到端的消息发送呢? 答:Python 提供了一些对象帮助我们实现这个需求,其中相对简单易用的是 Streams。 Streams 是 Python Asynchronous I/O 中提供的 High-level APIs。Python 官方文档对 Streams 的介绍如下:

Streams are high-level async/await-ready primitives to work with network connections. Streams allow sending and receiving data without using callbacks or low-level protocols and transports.

我尬译一下:Streams 是用于网络连接的 high-level async/await-ready 原语。Streams 允许在不使用回调或 low-level protocols and transports 的情况下发送和接收数据。 Python 提供了 asyncio.open_connection() 让开发者创建 Streams,asyncio.open_connection() 将建立网络连接并返回 reader 和 writer 对象,这两个对象其实是 StreamReader 和 StreamWriter 类的实例。 开发者可以通过 StreamReader 从 IO 流中读取数据,通过 StreamWriter 将数据写入 IO 流。虽然文档并没有给出 IO 流的明确定义,但我猜它跟 buffer (也就是 send buffer to NIC to recv buffer 中的 buffer)有关,你也可以抽象的认为它就是 buffer。 有了 Streams,就有了端到端消息发送的完整实现。下面将通过一个例子来熟悉 Streams 的用法和用途。这是 Python 官方文档给出的双端示例,首先是 Server 端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# TCP echo server using streams
# 本文出自「夜幕团队 NightTeam」 转载请联系并取得授权
import asyncio

async def handle_echo(reader, writer):
data = await reader.read(100)
message = data.decode()
addr = writer.get_extra_info('peername')

print(f"Received {message!r} from {addr!r}")

print(f"Send: {message!r}")
writer.write(data)
await writer.drain()

print("Close the connection")
writer.close()

async def main():
server = await asyncio.start_server(
handle_echo, '127.0.0.1', 8888)

addr = server.sockets[0].getsockname()
print(f'Serving on {addr}')

async with server:
await server.serve_forever()

asyncio.run(main())

接着是 Client 端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# TCP echo client using streams
# 本文出自「夜幕团队 NightTeam」 转载请联系并取得授权
import asyncio

async def tcp_echo_client(message):
reader, writer = await asyncio.open_connection(
'127.0.0.1', 8888)

print(f'Send: {message!r}')
writer.write(message.encode())

data = await reader.read(100)
print(f'Received: {data.decode()!r}')

print('Close the connection')
writer.close()

asyncio.run(tcp_echo_client('Hello World!'))

将示例分别写入到 server.py 和 client.py 中,然后按序运行。此时 server.py 的窗口会输出如下内容:

1
2
3
4
Serving on ('127.0.0.1', 8888)
Received 'Hello World!' from ('127.0.0.1', 59534)
Send: 'Hello World!'
Close the connection

从输出中得知,服务启动的 address 和 port 为 ('127.0.0.1', 8888),从 ('127.0.0.1', 59534) 读取到内容为 Hello World! 的消息,接着将 Hello World! 返回给 ('127.0.0.1', 59534) ,最后关闭连接。 client.py 的窗口输出内容如下:

1
2
3
Send: 'Hello World!'
Received: 'Hello World!'
Close the connection

在创建连接后,Client 向指定的端发送了内容为 Hello World! 的消息,接着从指定的端接收到内容为 Hello World! 的消息,最后关闭连接。 有些读者可能不太理解,为什么 Client Send Hello World! ,而 Server 接收到之后也向 Client Send Hello World! 。双端的 Send 和 Received 都是 Hello World! ,这很容易让新手懵逼。实际上这就是一个普通的回显服务器示例,也就是说当 Server 收到消息时,将消息内容原封不动的返回给 Client。 这样只是为了演示,并无它意,但这样的示例却会给新手带来困扰。 以上是一个简单的 Socket 编程示例,整体思路理解起来还是很轻松的,接下来我们将逐步解读示例中的代码:

1
2
3
* client.py 中用 `asyncio.open_connection()` 连接指定的端,并获得 reader 和 writer 这两个对象。
* 然后使用 writer 对象中的 `write()` 方法将 `Hello World!` 写入到 IO 流中,该消息会被发送到 Server。
* 接着使用 reader 对象中的 `read()` 方法从 IO 流中读取消息,并将消息打印到终端。

看到这里,你或许会有另一个疑问:write() 只是将消息写入到 IO 流,并没有发送行为,那消息是如何传输到 Server 的呢? 由于无法直接跟进 CPython 源代码,所以我们无法得到确切的结果。但我们可以跟进 Python 代码,得知消息最后传输到 transport.write() ,如果你想知道更多,可以去看 Transports and Protocols 的介绍。你可以将这个过程抽象为上图的 Client to send buffer to NIC to recv buffer to Server。

功能模块设计

通过上面的学习,现在你已经掌握了 WebSocket 协议规范和 Python Streams 的基本用法,接下来就可以设计一个 WebSocket 客户端库了。 根据 RFC6455 的约定,WebSocket 之前是 HTTP,通过「握手」来升级协议。协议升级后进入真正的 WebSocket 通信,通信包含发送(Send)和接收(Recv)。文本消息要在传输过程前转换为 Frames,而接受端读取到消息后要将 Frames 转换成文本。当然,期间会有一些异常产生,我们可能需要自定义异常,以快速定位问题所在。现在我们得出了几个模块:

1
2
3
4
5
6
7
* 握手 - ShakeHands

* 传输 - Transports

* 帧处理 - Frames

* 异常 - Exceptions

一切准备就绪后,就可以进入真正的编码环节了。 由于实战编码篇幅太长,我决定放到下一期,这期的内容,读者们可能需要花费一些时间吸收。

小结

开篇我强调了「创造能力」有多么重要,甚至抛出了一些不是很贴切的例子,但我就是想告诉你,不要做调参?。 然后我告诉你,本篇文章要讲解的是 WebSocket。 接着又跟你说,要掌握 WebSocket 协议,如果你无法独立啃完 RFC6455,还可以看我写过的几篇关于 WebSocket 文章和位运算文章。 过了几分钟,给你展示了 Socket 的通信过程,虽然没有强有力的依据,但你可以假设这是对的。 喝了一杯白开水之后,我向你展示了 Streams 的具体用法并为你解读代码的作用,重要的是将 Streams 与 Socket 通信过程进行了抽象。 这些前置条件都确定后,我又带着你草草地设计了 WebSocket 客户端的功能模块。 下一篇文章将进入代码实战环节,请做好环境(Python 3.6+)准备。

总之,要想越过前面这座山,就请跟我来!


文章作者:「夜幕团队 NightTeam 」- 韦世东 夜幕团队成立于 2019 年,团队成员包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的主要编程语言为 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

时间过得真快,距离这个系列的上一篇文章《商业级4G代理搭建指南【准备篇】》发布的时间已经过了两个星期了,上个星期由于各种琐事缠身,周二开始就没空写文章了,所以就咕咕咕了。 那么在准备篇中,我们了解了一下搭建 4G 代理所需要的软硬件,也知道了各种选择的优劣势。现在,我们就可以开始实际搭建了,相信大家也是期待已久了。


基本思路

从这篇文章的标题中我们可以看出,这一次的搭建方案主要用到的是 Docker,你可能会很好奇,Docker 跟搭建 4G 代理有什么关系吗? 嗯,关系很大,我们把整件事情梳理一下,先来看看搭建 4G 代理时的基本流程:

  1. 调用网卡拨号,拨号成功后会创建一个虚拟网卡。(正常情况下使用这个虚拟网卡就能上网了)
  2. 在多网卡的情况下,重复第一步,会得到多个虚拟网卡。
  3. 启动代理服务器,使其使用虚拟网卡作为出网网卡,并使用接入内网的实体网卡作为入网网卡。 使用起来差不多是这样的

但是呢,有个问题,根据我之前的测试结果来看,目前在 Linux 环境下还没有一个 HTTP 代理服务器是可以做到分别指定出网网卡和入网网卡的,嗯…这就很麻烦了,因为如果我们无法这么做的话,就会出现类似于下面这样的问题:

  1. 出网和入网都在虚拟网卡上,使用代理服务器必须要走公网访问。
  2. 入网为实体网卡,但出网被代理服务器锁定为了某一个,无法利用到多网卡。

嗯…那么不用 HTTP 代理服务器,用那些经常被用来做一些骚操作的 Socks5 代理服务器呢?如果可以指定网卡的话,再用像 Privoxy 之类的工具把 Socks5 代理转成 HTTP 代理就好了。(某知名扶墙软件的 Windows 版本就是这么转的 HTTP 代理) 在经过一番尝试后,我发现虽然有些 Socks5 代理服务器的文档中是说可以指定网卡,但按照说明操作后,似乎并不能直接做到我想要的效果(要么还是锁定在某一个上面、要么上不了网),所以还是存在一些问题的。可能是需要配合路由表设置来进行操作吧,不过我对网络工程的了解不怎么深,搞了几天也没搞出来,于是乎还得想想别的办法。 这时候,我想到了一个东西——Docker,它可以用来解决这个问题! 因为 Docker 容器被创建后,不管外界的网卡有多少个,容器内部的网卡都只会有一个Docker自己的虚拟网卡(容器间通信用的)和一个本地环回接口(不用管它),而且我们在容器内进行拨号操作时,产生的那个新的虚拟网卡也不会影响到外界或其他容器,这样的话,代理服务器就不需要指定网卡了,直接启动就能跑! 那么现在整个流程就跑通了,进入实际操作环节看看吧!


系统方面

这个 Docker 版的搭建方式,系统方面的选择很多,由于我使用的样例设备是树莓派,所以这里就选择使用了 Raspbian(树莓派专属版 Debian)。如果你使用的是其他设备的话,直接选择一个自己常用的系统就好。 那么准备好之后的第一步当然是先下载并安装 Docker,这里我直接使用 Docker 官方提供的一键安装脚本来进行安装:

1
2
3
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
# 出自官方文档:https://docs.docker.com/install/linux/docker-ce/debian/#install-using-the-convenience-script

这个一键安装脚本理论上来讲所有 Linux 发行版都可以使用,毕竟已经出来很长时间了,如果不行的话请自行使用搜索引擎查找相关资料。 装好 Docker 之后,你有两个选择:

  1. 进入体验模式,了解一下具体操作细节是怎么样的。
  2. 不看这一段,翻到本文最下方直接使用我写好的轮子。

启动容器

体验的话,我们就直接这么启动一个 Docker 容器吧,执行以下命令:

1
sudo docker run -it --rm --privileged -p 3128:3128 ubuntu:18.04 bash

上面这条命令的意思是,启动一个内部系统为 Ubuntu18.04 的容器,并进入容器内部的 Shell 执行 bash 命令,如果退出 bash 就自动销毁容器;然后映射容器内的端口3128到外界,映射出来的外界端口也是3128;最后 privileged 参数是开启特权模式,用于将网卡设备映射进容器内。 如果下载镜像很慢的话,可以搜一下“Docker 加速器”,也可以直接扶墙。

测试一下网卡是否正常

进入容器内部后,我们可以执行一下 ls /dev/ttyUSB* 看一下网卡有没有正常被识别出来(在容器外也是一样的,因为开了特权模式),如果是和我买的同一款 4G 网卡的话,在只插入一张网卡的情况下你会看到4个 ttyUSB 设备。 插入了三张网卡的样子,一共12个 ttyUSB 设备

不同 4G 网卡和硬件组合可能会有差异,请以实际情况为准。

如果你可以看到4✖4G网卡个数个 ttyUSB 设备的话,就说明没有问题,可以开始下一步了。

拨号上网

接下来要做的就是拨号了,拨号方面可以选择使用 Wvdial 这种工具,也可以选择使用像 Fanconn 这样的商家提供的拨号脚本(直接调用 PPPD),使用起来的效果会有一些区别。如果商家没有提供拨号脚本的话,就用 Wvdial 吧,它能自动生成配置,上手即用。 我这边的话,由于 Fanconn 的技术人员直接提供了个拨号脚本,那我就用这个脚本了,Wvdial 的文档网上有很多很详尽的,这里就不再多提,需要的朋友自行搜索即可。 如果你用的是 Fanconn 的这个拨号脚本(怎么弄进容器内就不用我说了吧?),那么直接在 apt install ppp 安装好拨号工具之后,用 chmod +x quectel-pppd.sh 给拨号脚本加个运行权限,然后 ./quectel-pppd.sh /dev/ttyUSB3 即可。

拨号时使用的 /dev/ttyUSB3 是指 4G 网卡的第四个通信端口,文档中的解释为:ttyUSB3→For PPP connections or AT command communication,翻译一下就是用于 PPP 连接或 AT 命令通信。

拨号之后用 ifconfig 之类的工具即可看到类似下图中的状态: 可以看到,如前文所述,现在有三个网卡,一个是 Docker 自己的、一个是本地环回接口(这个不用管)、一个是拨号产生的虚拟网卡。

如果不是在 Docker 容器内使用的话,还会有个 wwan0(或其他名字),那个是 4G 网卡本体。

测试是否能正常上网

现在如果你用 curl 的 \--interface 参数指定虚拟网卡进行请求的话(如:curl --interface ppp0 https://ip.cn),是已经可以请求成功的了,IP 也会是你所使用的 SIM 卡对应的运营商分配的。

由于 Docker 的镜像通常都是极度精简的,所以 Ubuntu 镜像里并没有预装像 net-tools、iputils-ping、vim、curl 之类的这些包,需要自行安装。所以如果你发现 ifconfig、ping、curl、vim 用不了,不要惊慌,这是正常现象,执行 apt install 包名 命令安装即可。

如果你无法直接请求成功的话,就可能是 DNS 解析出问题了,可以尝试 ping 一个公网 IP(如:ping 1.1.1.1)和一个域名(如:ping ip.cn),如果 IP 能 ping 通但域名会报 DNS 解析失败的话,就可以确认是 DNS 设置问题了。 4G 拨号时如果出现 DNS 设置问题,通常是因为拨号工具没有正常地将运营商返回的 DNS 服务器设置写入到配置中,我们可以手动配置一下(你要强制指定某一个 DNS 也可以):

1
2
3
# 以下为阿里云的公共DNS
echo 'nameserver 223.5.5.5' >> /etc/resolv.conf
echo 'nameserver 223.6.6.6' >> /etc/resolv.conf

在 Docker 容器中,这个 /etc/resolv.conf 文件可能还会有两条内容,是容器本身所需要的,建议不要删除/覆盖,否则会出现容器间无法使用容器名互相通信的情况。

启动代理服务器

那么在测试拨号后确实可以通过 4G 网卡上网了之后,我们就可以把代理服务器启动了,这里我使用的是 TinyProxy。

测试发现,Squid 对资源的占用更大一些,不利于多网卡情况下的使用,会影响到 4G 网卡的数量上限。

apt install tinyproxy 一波,然后 vim /etc/tinyproxy/tinyproxy.conf 修改一下配置。 要修改的配置主要有:

  • Port 配置项改为3128,因为我们前面映射出来的端口是3128。
  • Listen 配置项改为0.0.0.0,因为我们需要在其他设备上使用这个代理服务器。
  • Allow 配置项注释掉或改为0.0.0.0/0,默认的127.0.0.1会导致其他设备无法访问。

改完之后保存一波,然后就可以直接执行 tinyproxy 启动了…吗? 等等,还有一个操作要做!那就是将默认路由指向到虚拟网卡上,很简单,执行以下命令即可:

1
2
route del -net 0.0.0.0 eth0
route add -net 0.0.0.0 ppp0

这两条命令的意思是:先将默认的、指向 eth0 这个网卡的上网路由删除,然后添加一个同样的、指向 ppp0 这个网卡的路由。 改完默认路由后的效果就是,即使你不使用 curl 的 \--interface 参数,也能直接使用 4G 网卡上网了。

如果没有改默认路由的话,在不指定网卡的情况下,4G 网卡并不会被使用到,因为默认路由指向的是 Docker 自身的虚拟网卡,那个网卡通向你原本的内网环境。也就是说,IP 不会变!

那么现在,你可以执行 tinyproxy 启动代理服务器了。

测试代理服务器

好了,代理服务器应该已经正常启动了,现在我们可以在另一个设备上尝试连接那个容器中的代理服务器,看看是否能正常通过它使用 4G 网卡上网。 例如我这里树莓派分配到的IP是:192.168.137.66,那么我就可以用这样的 curl 命令或 Python 代码进行测试: curl:

1
2
curl "https://ip.cn"
curl -x "192.168.137.66:3128" "https://ip.cn"

Python:

1
2
3
4
5
import requests
resp = requests.get("https://ip.cn", proxies={"https": "http://192.168.137.66:3128"})
no_proxy_resp = requests.get("https://ip.cn")
print(resp.text)
print(no_proxy_resp.text)

测试出来的结果应该与前面在容器内部测试时的一致,在使用代理后 IP 就变成了运营商分配的基站 IP。

更换 IP

那么最核心的问题来了,怎么更换 IP 呢? 其实和使用那些拨号 VPS 架设代理服务器一样,我们只需要重新拨个号就能换 IP 了,直接 kill 掉 pppd 进程就可以让它断开拨号,断开后重新执行一遍拨号脚本就是重新拨号了。

断开拨号方面 Fanconn 的技术人员也提供了一个脚本,同样在 chmod +x quectel-ppp-kill 赋予运行权限之后,执行 ./quectel-ppp-kill 就可以了。

但需要注意的是,蜂窝网络的拨号在断开后,IP 仍然会保留一段时间(具体多久不清楚,可能跟连接的基站也有关系),所以我们需要强制性地让网卡重新搜网。

冷门小知识:手机上开启关闭飞行模式的效果就是重新搜网,通常只是关闭“移动数据”的话,效果是与断开拨号一致的。

怎么做呢?很简单,就两行命令:

1
2
AT+CFUN=0
AT+CFUN=1

但注意哦,这是 AT 命令,不是 Linux 下的 Shell 命令,AT 命令是一种调制解调器命令语言,我们如果需要将它执行起来,需要这么做:

1
2
3
echo "AT+CFUN=0" > /dev/ttyUSB2
# 中间间隔1秒左右
echo "AT+CFUN=1" > /dev/ttyUSB2

这里使用的 /dev/ttyUSB2 是指 4G 网卡的第三个通信端口,文档中的解释为:ttyUSB2→For AT command communication,与第四个通信端口类似,只是它不能用于 PPP 连接、只能用于 AT 命令通信而已。 不同样使用第四个通信端口的原因是那个端口有被占用的可能性,直接区分开最稳妥,本来网卡也就是提供了两个 AT 命令通信渠道的。

在使网卡重新搜网后的几秒至十几/几十秒内的时间里,你无法正常拨号,需要等待它初始化完成后才可以拨号成功,具体等待时间以信号强度为准,我测试的时候通常5秒以内就可以了。 所以如果你在断开后一直拨号失败,不妨过一会儿再试。


总结

那么现在操作流程也跑通了,我们也了解到了整个的内部细节,最后要做的就是把每个网卡都分别分配一个容器,这样我们就能实现文章开头所提到的——“使用虚拟网卡作为出网网卡,并使用接入内网的实体网卡作为入网网卡”的效果了。 实际操作起来的话,就是把指定网卡的部分给配置化,然后在启动容器的时候传入就好了,使用 Docker 的容器环境变量相关设置可以很轻松地实现这个功能。 最后,我们可以以这个思路,构建一个 docker-compose 模板,模板的核心内容一是做个简易的4G网卡容器集群,二是启动个 Squid,用来聚合代理服务器,这样我们使用的时候只需要指定一个代理服务器就能随机更换了,操作起来更加方便。


好了,上面就是 Docker 版搭建方式的思路和整个的搭建流程,如果你懒得看的话,直接用我写好的轮子也是可以的,只需要发送消息【Docker版4G代理】到公众号【NightTeam】即可。

评价

最后的最后,我给这个搭建方式打个评价吧。 这个搭建方式并不完美,因为变量太多,而且很多地方肯定不如系统级原生支持的那么稳定,长期使用可能会出现各种奇奇怪怪的问题。 然后 Docker 的资源占用其实挺高的,会浪费相当多的内存在启动容器上,如果只是两三个网卡还好,如果数量大一点的话,像树莓派2B 这种小内存的设备根本就扛不住。 另外代理服务器本身对资源的消耗也是比较高的,高频调用下对树莓派2B 的小 CPU 压力还是蛮大的,即使我对它的 CPU 进行了超频,在并发测试时也还是会出现轻松打满 CPU 的情况。 但是!截止目前,我还有两种基于路由器系统的搭建方案没写出来!所以…敬请期待后续的其他搭建方案(斜眼笑)。


文章作者:「夜幕团队 NightTeam」 - Loco 夜幕团队成立于 2019 年,团队包括崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 涉猎的编程语言包括但不限于 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发、对象存储等。团队非正亦非邪,只做认为对的事情,请大家小心。

技术杂谈

在这个互联网时代,拥有流量就仿佛于拥有了一切。 我大约在 2014 年底开了自己的个人博客,当时就是想自己记录点学习总结,一个是方便查阅,二是锻炼一下自己写总结或者文章的能力,最初就是记录一些日常生活、编程学习的小知识点什么的。 一次偶然的机会我接触了爬虫,当时用 Python 写爬虫的仿佛也不多,正好有一位学长有研究,我也就跟着他学了起来,学的时候也是自己总结,然后把一些文章发表到博客上,累积了十几篇左右。不知道是什么原因,渐渐地好像爬虫火了起来,Python 也火了起来,不知不觉地我发现我的博客慢慢地流量涨起来了,一天几百、几千一直到现在上万的浏览量,SEO 也逐渐好了起来,说实话我当时都没有想到,感觉还是不少运气成分在里面的。 两年前左右我开了一个公众号,开始在公众号上面发一些文章,自己也逐渐从博客转战到公众号上面了,因为公众号的环境总体来说还是很不错的,尤其是对原创作者来说非常友好,非常尊重原创。转载文章需要开白、原创命中和保护机制、洗稿检测、及时的投诉处理让越来越多的技术人员也转到公众号上来了。所以越来越多的技术开发者都拥有了自己的公众号,变成了一个人人公号的时代。这导致了一个什么结果?竞争日益激烈,读者的可选择范围太多了,大家的涨粉之路也走得越来越艰辛了。 同样地我也遭受着同样的苦恼,这时候我突然想起来,我似乎还有个博客呢?最近写文都专注于公众号,没太有心思打理自己博客了。我在想要是能够把我的博客流量转换到我的公众号上来该多好呢?一来我的博客读者可以关注到我的公号平时发的文章或通知,二来也着实能为自己的公号涨一点粉丝,这样该多好啊? 思来想去我想到了一个法子,就是在浏览博客文章的时候,把后续内容的隐藏,留一个二维码,可以通过关注公众号解锁。 当时设想效果图就是这样子的: image-20190914224503383 文章在某个位置会渐变隐藏,同时浮现一个公众号的样子,需要扫码才能解锁。这时候读者扫码自动关注了公号,博客文章也自然而然地解锁,这样博客的读者就自然关注到公号上面来了。

功能要点

一听到这样的法子,大家肯定就骂起来了,文章还要解锁来看?每篇文章都要解锁一遍吗?以后如果再打开还需要次次解锁吗? 如果真的是这样,那我情愿不做这个功能,因为这太损伤「用户体验」了。为了尽量减少用户体验的损失,这个功能必须要满足以下几点:

  • 不要添加用户登录注册机制,一旦增加了这个机制,流程可能会大大复杂化,导致用户体验急剧下降。
  • 不能每打开一个页面都要解锁一次,读者访问了我的博客,只需要一次解锁,即可全面解锁博客所有文章。
  • 读者在关闭浏览器再重新打开浏览器浏览博客的时候,同样不能让读者再解锁一遍,要直接可看。
  • 读者在手机或其他移动设备上不方便操作,手机站点禁止启用本功能。

如果满足了这些条件,读者在一篇文章里面只要扫码解锁了一次,那么就可以永久解锁全站文章了,没有繁琐的登录注册功能,也不需要次次频繁解锁,这样用户体验就非常好了。 为了达成这个目的,我就开始开发这个功能了。

识别用户

那么怎么来实现呢?要实现上面的功能,其实最重要的就是来识别是哪一个用户,也就是说,我怎么知道到底是谁在浏览我的博客呢?我怎么来专门针对这个用户解锁呢? 有的同学可能说那就用 IP 地址呗,技术角度是可以实现的,但是其实仔细想想,用 IP 地址是很不友好的。一来是很多用户可能都是内网的 IP 地址,多个公户共享一个公网 IP 地址,所以假如两台设备接入了同一个公网 IP,我是无法判断到底解锁哪一台设备的。二来是,如果一个用户换了其他的地方或者用了 VPN,IP 地址变了,原本解锁的设备又变成非解锁状态了。这样也不好。 那么最方便简单的用来标识一个浏览设备的东西是什么?当然是 Cookies。Cookies 里面保存了浏览网页时自动生成的 Session ID,而且每一个用户都是不一样的,这样不就可以来唯一标识一台浏览设备了吗?

解锁逻辑

好,那有了用户的 ID,我怎么才能把用户 ID 和我的公众号关联起来呢?当然是把这个 ID 发到公众号后台,我来存起来就好了。然后博客这边定时检测我这边有没有把这个 ID 保存,如果保存了,那就呈现解锁状态,如果没有保存,那就呈现非解锁状态。 最开始我就设想,既然公众号要扫码关注,那么我能不能把这个 ID 也糅到二维码里面呢?这样关注公众号的时候既能查询到公众号,有传递过来一个 ID 作为参数,然后后台处理一下存起来就好了。 你别说还真有这个功能,我在微信平台官方文档里面查询到了一个「生成带参数的公众号二维码」,生成的二维码里面可以指定任意的参数,然后生成的二维码图案就是公众号的二维码,然后处理一下关注公众号的回调函数就可以执行某一些操作了。看到之后我就想起来了很多关注公众号自动登录的功能就是这么做的。 但是经过一系列操作,发现了一个很悲伤的事情,只有服务号才有这个功能,我一小小的订阅号,是没有这个权限的,不能生产带参数的二维码。哎,难道凉了吗? 不,没有,既然这个参数不能通过二维码传递,那就只好麻烦读者手动把这 ID 输入到我的公众号了,我的小小的订阅号还是有处理消息的功能的。我的公众号后台接收到消息,然后处理下这个消息 ID,然后存起来,那不就好了吗? 说干就干!

隐藏文章

怎么开始做呢?那就从隐藏文章开始做吧。首先这个隐藏不能是真正的后台的隐藏,需要在前台隐藏。如果是后台隐藏的话,搜索引擎所能爬到的我的网站内容就会缺失了,会影响 SEO 的。所以只需要前台 CSS 隐藏一下就好了。 怎样看起来隐藏得比较自然呢?就取文章的的一半的地方,把文章的下面部分用 CSS 藏起来,然后加个渐变效果就好了。 比如要隐藏一半的内容吧,首先可以获取文章区块的高度,然后把文章页面高度用 CSS 强制设置为原来的一半就好了,这个很好操作,然后再在最底下加个渐变的样子,仿佛底下还有文字的样子。 这个 CSS 用 background 属性就能实现了,参考代码如下:

1
2
3
4
5
#locker {
height: 240px;
width: 100%;
background: -webkit-gradient(linear, 0 top, 0 bottom, from(rgba(255, 255, 255, 0)), to(#fff));
}

这里就是设置个 240 像素的区块,然后从上面到下面是透明度渐变颜色就好了,整体效果是下面这个样子: image-20190914231647956 好,既然隐藏了,那么下面就加个提示吧,把公众号的二维码先放上,然后把那个 Session ID 放上,提示用户关注公众号后发送这个 ID 就能解锁了,但这个 ID 又不能太长,多少呢?六位吧那就。 类似做成这样的样子: image-20190914231805506 好,那么这个 ID 怎么获取的呢? 刚才说了,从 Cookies 里面获取就行了,找那个能够标识 Session ID 的一个 Cookies 字段,然后摘取其值的其中几位就行了,摘取的位置也有讲究,前几位仿佛重复率很高的样子,后面几位几乎不重复,那就截取最后六位数字吧。 好,然后我就在博客里面加了这么一点 JavaScript 代码来实现这个 ID 的提取:

1
2
3
4
5
6
7
8
9
10
11
12
13
function getCookie(name) {
var value = "; " + document.cookie;
var parts = value.split("; " + name + "=");
if (parts.length == 2) return parts.pop().split(";").shift();
}

function getToken() {
let value = getCookie('UM_distinctid')
if (!value) {
return defaultToken
}
return value.substring(value.length - 6).toUpperCase()
}

这里 getCookie 方法是用某个名字获取一个 Cookies 字段,getToken 方法是截取了 Cookies 这个字段值的后六位并做了大写处理。 这里我的一个可以用来标识 Session ID 的 Cookies 字段叫做 UM_distinctid,就用它了。 这样一来,每个用户浏览的时候就能生成这样的一个 ID 了,六位的。 胜利似乎越来越近了。

持久化存储

这里就又遇到一个问题,刚才不是说还要在用户关闭浏览器之后再重新打开,依然能保持解锁状态吗?这就要求这个 ID 在用户关闭又打开浏览器的时候是不变的。 这个怎么解?很简单,反正已经是从 Cookies 里面读了,这个 Cookies 持久化就行了,只要不在浏览器关闭后清除就行了,怎么办?设置个过期时间就好。 由于我的站点是 WordPress 做的,所以这个功能自动有了,如果没有的话用一些插件也能实现的。

公众号处理

好,现在 ID 也有了,用户扫码把这个 ID 发到公众号后台就行了吧,然后公众号对接开发者模式处理一下就好了。 这里就其实就很简单了,其实仅仅就是把用户的 OpenID 和这个码存到了一个数据库里面。我后台是用 Django 写的,所以用了 Django 里面的 Model,实现逻辑如下:

1
2
3
4
5
6
7
8
9
10
def unlock(source, target, content):
"""
解锁博客
:param target: 微信平台
:param source: 用户
:param content: 用户发来的码
:return:
"""
Unlock.objects.get_or_create(openid=source, token=content.upper())
return reply_text(source, target, '恭喜您已经解锁博客全部文章~')

就是这么两行,插入了一条数据,然后返回了一个信息提示。 插入之后怎么办呢?博客得知道我已经把这条数据插入进来了呀?那就再提供一个 API 查询吧,实现如下:

1
2
3
4
5
6
7
8
9
10
11
def is_locked(request):
"""
判断是否已经解锁
:param request: 包含token的请求
:return:
"""
token = request.GET.get('token')
result = Unlock.objects.filter(token=token.upper()).first()
return JsonResponse({
'locked': False if result else True
})

把这个方法对接一个 API 接口,比如 /api/locked?token=xxxxx,就可以知道是否解锁了。 所以,在公众号后台我就用开发者模式对接了这么两个功能,一个用来存,一个用来查。只要用户发送了这个能够用来表示自己浏览设备的码,我就存下来,然后博客定时请求这个 API 查询状态,如果返回结果是未解锁状态,那就继续锁住,如果是解锁状态。那就把博客解开。

博客端处理

那么博客端具体怎么来处理呢?就基本的轮询就好了,定时几秒查一次 API,然后把这个码当做参数传过去,然后根据查询结果执行解锁或非解锁操作就好了。 核心代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
(articleSelector).ready(function () {
var articleElement = $(articleSelector)[0]
if (articleElement) {
var height = articleElement.clientHeight
var halfHeight = height * 0.3
var token = getToken()
$('#locker').find('.token').text(token)
function detect() {
$.ajax({
url: 'https://weixin.cuiqingcai.com/api/locked/',
method: 'GET',
data: {
token: token
},
success: function (data) {
if (data.locked === true || data.locked === false) {
locked = data.locked
}
},
error: function (data) {
locked = false
}
})
}
}
})

这里就用基本的 jQuery 实现的,其实就是调了个 Ajax,也没啥高深的技巧。这里唯一值得注意的一点设计就是,如果 API 请求失败,这基本上证明我的 API 服务挂掉了,这里就需要把 locked 设置为 false,证明为解锁状态。这样,万一我的 API 后台挂了,博客会直接是解锁状态,这样就避免了读者永远无法解锁了。这是一个细节上的设计。 至此,一些技术上的问题就基本解决了。

手机端处理

最后回过头来看看,那个需求还没有满足? 读者在手机或其他移动设备上不方便操作,手机站点禁止启用本功能。那么怎么实现呢?很简单,判断一下浏览器的 User-Agent 就好了,这里实现了一个判断是否是 PC 的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var os = function () {
var ua = navigator.userAgent,
isWindowsPhone = /(?:Windows Phone)/.test(ua),
isSymbian = /(?:SymbianOS)/.test(ua) || isWindowsPhone,
isAndroid = /(?:Android)/.test(ua),
isFireFox = /(?:Firefox)/.test(ua),
isChrome = /(?:Chrome|CriOS)/.test(ua),
isTablet = /(?:iPad|PlayBook)/.test(ua) || (isAndroid && !/(?:Mobile)/.test(ua)) || (isFireFox && /(?:Tablet)/.test(ua)),
isPhone = /(?:iPhone)/.test(ua) && !isTablet,
isPc = !isPhone && !isAndroid && !isSymbian;
return {
isTablet: isTablet,
isPhone: isPhone,
isAndroid: isAndroid,
isPc: isPc
}
}()

这样一来,调用 os.isPC 就可以知道当前浏览器是不是手机浏览器了。 在处理的时候加上这个条件判断,就可以实现手机功能的解除了。

效果

可能大家想知道效果是如何的,这里就截图看看了,现在这个功能已经在我的博客 cuiqingcai.com 上线了,大家可以进去体验一下。 首先进去文章是这个样子的: image-20190914234237147 然后关注了公号,发送了代码: image-20190914234421831 发送完毕之后,大约一两秒之后,抬头看看博客,就是这个样子了: image-20190914234406442 这已经就完成了解锁和转化,读者可以全站永久解锁我的博客文章,我也增长了粉丝。 现在过一段时间就会有读者发来代码解锁,同时成为了我的粉丝,订阅号助手看到消息如下: image-20190914234720018 以上便是这个博客转化的思路分享和实现,大家也可以到我的博客体验一下,谢谢!

技术杂谈

今天这篇文章是要告诉你,业内多名实力强劲的开发者组建了一个服务于广大开发者的团队。现在,你可能会有下面这些疑问:

  • 为什么要组成团队呢?
  • 这个团队将会给广大开发者带来什么?
  • 团队成员有哪些?

好了,接下来用 3 分钟时间去了解这个团队吧!

夜幕团队简介

夜幕团队 NightTeam 于 2019 年 9 月 9 日正式成立,团队由爬虫领域中实力强劲的多名开发者组成:崔庆才、周子淇、陈祥安、唐轶飞、冯威、蔡晋、戴煌金、张冶青和韦世东。 NightTeam 涉猎的编程语言包括但不限于 Python、Rust、C++、Go,领域涵盖爬虫、深度学习、服务研发和对象存储等,团队技术实力十分雄厚。

为什么要组建一个团队?

据以往经验来看,产出一篇优质的技术文章所耗费的时间是相当长的,读者很难从单个作者那里获得成体系且覆盖面较广的知识。 对于作者而言,粉丝的积累、文章的持续编写都是一个慢跑的过程,很多优秀的作者会因为没有粉丝、投入产出比差距太大等因素暂停写作。 更有甚者,文章内容质量越来越低、标题越来越唬、广告越来越多,一门心思放在如何涨粉和变现上。如此循环,就会影响技术圈和技术生态的发展。 如果将那些优秀的作者联合起来(即合纵连横),共同运营一系列的技术媒体号,在不增加负担的情况下还能保证优质文章的产出,会怎么样呢?

我们也不知道,但是我们已经意识到了这个问题,也尝试着寻找答案。这就是夜幕团队 NightTeam 组建的大环境背景。

团队希望做什么事?

互联网是开放的,技术也是开放的。适当的共享可以加速我们的进步,无论是作者还是读者,都能够从分享的过程中获得一些东西。

在开发中,我们会用到一些库和框架。当我刚编程入门的时候,就想着有一天也要编写开源项目,为其他开发者提供帮助,这正是夜幕团队想要做的事。 当然,我们想要做的不仅仅是编写一个开源项目,我们更希望将知识分享出去,在技术圈中传播开来,让更多的人得到帮助。

团队能够为开发者带来什么?

读者的能力和阶段各不相同,每个人收获的内容也不同。宽泛来说,读者可以从夜幕团队 NightTeam 输出的内容中获得对待问题的处理方式、分析问题的思路、解决问题的技巧、问题背后的逻辑等。 假如你是一名中级爬虫工程师,那么夜幕团队 NightTeam 输出的内容可能会为你解决工作中遇到的一些反爬虫问题带来思路。

如果你是一名后端开发者,你也许会从我们发布的类似于【动图演示 - Redis 持久化 RDB/AOF 详解与实践】这样的文章中了解到 Redis 持久化的两种选择的差异和具体操作过程。

团队以什么形式输出内容?

大多数情况下,我们会用文章的形式输出内容。但有时候也会采用直播或者视频教程的方式,兴许还会有现场交流的机会。 为了增加传播广度和影响力,我们不仅仅在微信公众号上发布文章,还会将文章同步到业内著名的几个平台,例如掘金社区、CSDN、SF、V2EX、知乎、今日头条等。

团队成员介绍

团队的成员都是爬虫领域比较活跃的作者,同时也拥有非常强的实力,不会是那些只负责回答小白问题骗钱的盗名之辈。以下将不分先后的列出团队成员姓名、昵称和各自的介绍。 周子淇

昵称 Loco 前微信公众号「小周码字」号主、知乎专栏「手把手教你写爬虫」作者,幂度爬虫工程师。啥方向都搞,除了爬虫相关的文章以外还会写一些灰黑产操作研究、机器学习、造轮子、物联网设备研究、脑洞分享等各种奇奇怪怪的东西。

韦世东

昵称 Asyncins 图灵签约作者、电子工业出版社约稿作者、华为云认证云享专家、掘金社区优秀作者、GitChat 认证作者、搜狐产品技术约稿作者、开源项目 aiowebsocket 作者、微信公众号「Rust之禅」号主、「进击的Coder」运营者之一,有着丰富的爬虫经验,擅长反爬虫的绕过技巧。

崔庆才

昵称 静觅 畅销书《Python3网络爬虫开发实战》作者、微信公众号「进击的Coder」号主,微软中国工程师。主要研究网络爬虫、机器学习、Web 开发相关内容。

陈祥安

昵称 CXA 微信公众号「Python学习开发」号主、CSDN 线下沙龙特邀讲师、华为云享社区专家、阿里云栖社区专家、哔哩哔哩《陈祥安分析Python面试题》系列 UP 主、GitChat 热门文章《Python 常见的 170 道面试题全解析:2019 版》作者,马蜂窝高级爬虫工程师。

唐轶飞

昵称 大鱼 BruceDone 微信公众号「大鱼鱼塘」号主、「http://brucedone.com」站长,腾讯后端工程师。多年 Code 经验,擅长后端开发,语言了解但不限于 .NET、Python、Golang、SQL,兴趣包含但不限于爬虫,后端,数据库,深度学习。

冯 威

昵称 妄为 微信公众号「妄为写代码」号主,爬虫 Coder,佛系程序员。专注 JavaScript、Android 逆向以及验证码破解,对逆向有着丰富的经验。

蔡 晋

昵称 悦来客栈的老板 微信公众号「菜鸟学Python编程」号主,平时喜欢研究各大网站的反爬,熟悉常见网站的反爬操作,对反爬有着独到的见解。

戴煌金

昵称 咸鱼 微信公众号「咸鱼学Python」号主、华为云享专家。专注Python爬虫、JavaScript逆向,立志做一条最咸的咸鱼。

张冶青

昵称:MarvinZ 微信公众号「Crawlab漫游指南」号主、爬虫管理平台 Crawlab 作者、文章发布平台 ArtiPub 作者,知名外企前端开发工程师。专注前端、爬虫和数据分析。

如何与夜幕取得联系?

你可能想跟夜幕团队交流一些技术方面的问题,你可以发送消息“夜幕读者群”到我们的公众号「NightTeam」加入读者群,团队成员都在群里等你。 一些重要的事可以通过邮件与夜幕取得联系,夜幕团队的邮箱为 contact@nightteam.cn。 GitHub 也准备好了,我们会逐渐将开源项目迁移到团队的仓库中,地址为 https://github.com/nightteam

技术杂谈

舆情爬虫是网络爬虫一个比较重要的分支,舆情爬虫往往需要爬虫工程师爬取几百几千个新闻站点。比如一个新闻页面我们需要爬取其标题、正文、时间、作者等信息,如果用传统的方式来实现,每一个站点都要配置非常多的规则,如果要维护一个几百上千的站点,那人力成本简直太高了。 如果有一种方式可以在保证差不多的准确率的前提下,大幅提高提取效率的话,就需要用到智能文本提取了。 本文首先介绍一下智能文本提取的基本原理,让大家对智能提取有基本的了解。然后介绍几个比较基础的工具包,准确率并不是很高,可以尝试一用。最后再介绍几篇比较前沿的技术供大家参考。

智能文本提取

目前来说,智能文本提取可以分为三类:

  • 基于网页文档内容的提取方法
  • 基于 DOM 结构信息的提取方法
  • 基于视觉信息的提取方法

基于网页文档的提取方法将 HTML 文档视为文本进行处理,适用于处理含有大量文本信息且结构简单易于处理的单记录网页,或者具有实时要求的在线分析网页应用。 这种方式主要利用自然语言处理相关技术实现,通过理解 文本语义、分析上下文、设定提取规则等,实现对大段网页文档的快速处理。其中,较为知名的方法有TSIMMIS、Web-OQL、Serrano、FAR-SW 和 FOREST,但这些方法由于通常需要人工的参与,且存在耗时长、效率低的弊端。 基于 DOM 结构信息的方法将 HTML 文档解析为相应的 DOM 树,然后根据 DOM 树的语法结构创建提取规则, 相对于以前的方法而言有了更高的性能和准确率。 W4F 和 XWRAP 将 HTML 文档解析成 DOM 树,然后通过组件化引导用户通过人工选择或者标记生成目标包装器代码。Omini、IEPAD 和 ITE 提取 DOM 树上的关键路径, 获取其中存在的重复模式。MDR 和 DEPTA 挖掘了页面中的数据区域,得到数据记录的模式。CECWS 通过聚类算法从数据库中提取出自同一网站的一组页面,并进行 DOM 树结构的对比,删除其中的静态部分,保留动态内容作为信息提取的结果。虽然此类方法相对于上一类方法 具有较高的提取精度,且克服了对大段连续文本的依赖, 但由于网页的 DOM 树通常较深,含有大量 DOM 节点, 因此基于 DOM 结构信息的方法具有较高的时间和空间消耗。目前来说,大部分原理还是基于 DOM 节点的文本密度、标点符号密度等计算的,其准确率还是比较可观的。今天所介绍的 Readability 和 Newspaper 的库的实现原理就是类似。 目前比较先进的是基于视觉信息的网页信息提取方法,通过浏览器接口或者内核对目标网页预渲染,然后基于网页的视觉规律提取网页数据记录。经典的 VIPS 算法首先从 DOM 树中提取出所有合适的页面区域,然后根据这些页面和分割条重新构建 Web 页面的语义结构。作为对 VIPS 的拓展,ViNT、ViPER、ViDE 也成功利用了网页的视觉特征来实现数据提取。CMDR 为通过神经网络学习多记录型页面中的特征,结合基于 DOM 结构信息的 MDR 方法,挖掘社区论坛页面的数据区域。与上述方法不同,VIBS 将图像领域的 CNN 卷积神经网络运用于网页的截图,同时通过类 VIPS 算法生成视觉块,最后结合两个阶段的结果识别网页的正文区域。另外还有最新的国内提出的 VBIE 方法,基于网页视觉的基础上改进,可以实现无监督的网页信息提取。

以上内容主要参考自论文:《王卫红等:基于可视块的多记录型复杂网页信息提取算法》,算法可从该论文参考文献查阅。

下面我们来介绍两个比较基础的工具包 Readability 和 Newspaper 的用法,这两个包经我测试其实准确率并不是很好,主要是让大家大致对智能解析有初步的理解。后面还会介绍一些更加强大的智能化解析算法。

Readability

Readability 实际上是一个算法,并不是一个针对某个语言的库。其主要原理就是计算了 DOM 的文本密度,另外根据一些常见的 DOM 属性如 id、class 等计算了一些 DOM 的权重,最后分析得到了对应的 DOM 区块,进而提取出具体的文本内容。 现在搜索 Readability 其实已经找不到了,取而代之的是一个 JavaScript 工具包,叫做 mercury-parser,据我所知应该是 Readability 不维护了,换成了 mercury-parser。后者现在也做成了一个 Chrome 插件,大家可以下载使用一下。 回归正题,这次主要介绍的是 Python 的 Readability 实现,现在其实有很多开源版本,本文选取的是 https://github.com/buriy/python-readability,是基于最早的 Python 版本的 Readability 库 https://github.com/timbertson/python-readability 二次开发的,现在已经发布到了 PyPi,大家可以直接下载安装使用。 安装很简单,通过 pip 安装即可:

1
pip3 install readability-lxml

安装好了之后便可以通过导入 readability 使用了,下面我们随便从网上找一个新闻页面,比如:https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html,其页面截图如下页面示例 我们的目的就是它的正文、标题等内容。下面我们用 Readability 试一下,示例如下:

1
2
3
4
5
6
7
8
import requests
from readability import Document

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
html = requests.get(url).content
doc = Document(html)
print('title:', doc.title())
print('content:', doc.summary(html_partial=True))

在这里我们直接用 requests 库对网页进行了请求,获取了其 HTML 页面内容,赋值为 html。 然后引入了 readability 里的 Document 类,使用 html 变量对其进行初始化,然后我们分别调用了 title 方法和 summary 方法获得了其标题和正文内容。 这里 title 方法就是获取文章标题的,summary 就是获取文章正文的,但是它获取的正文可能包含一些 HTML 标签。这个 summary 方法可以接收一个 html_partial 参数,如果设置为 True,返回的结果则不会再带有 <html><body> 标签。 看下运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
title: 今年iPhone只有小改进?分析师:还有其他亮点_网易科技
content: <div><div class="post_text" id="endText">
<p class="otitle">
(原标题:Apple Bets More Cameras Can Keep iPhone Humming)
</p>
<p class="f_center"><img alt="今年iPhone只有小改进?分析师:还有其他亮点" src="http://cms-bucket.ws.126.net/2019/09/09/d65ba32672934045a5bfadd27f704bc1.jpeg"/><span>图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。</span></p><p>网易科技讯 9月9日消息,据国外媒体报道,和过去的12个年头一样,新款
... 中间省略 ...
<p>苹果还即将推出包括电视节目和视频游戏等内容的新订阅服务。分析师表示,该公司最早可能在本周宣布TV+和Arcade等服务的价格和上线时间。</p><p>Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示,可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说,上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)</p><p><b>相关报道:</b></p><p><a href="https://tech.163.com/19/0908/09/EOHS53RK000999LD.html" target="_self" urlmacroreplace="false">iPhone 11背部苹果Logo改为居中:为反向无线充电</a></p><p><a href="https://tech.163.com/19/0907/08/EOF60CBC00097U7S.html" target="_self" urlmacroreplace="false">2019年新iPhone传言汇总,你觉得哪些能成真</a>  </p><p/>
<p/>
<div class="ep-source cDGray">
<span class="left"><a href="http://tech.163.com/"><img src="https://static.ws.126.net/cnews/css13/img/end_tech.png" alt="王凤枝" class="icon"/></a> 本文来源:网易科技报道 </span>
<span class="ep-editor">责任编辑:王凤枝_NT2541</span>
</div>
</div>
</div>

可以看到,标题提取是正确的。正文其实也是正确的,不过这里还包含了一些 HTML 标签,比如 <img><p> 等,我们可以进一步通过一些解析库来解析。 看下源码吧,比如提取标题的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def normalize_entities(cur_title):
entities = {
u'u2014':'-',
u'u2013':'-',
u'&mdash;': '-',
u'&ndash;': '-',
u'u00A0': ' ',
u'u00AB': '"',
u'u00BB': '"',
u'&quot;': '"',
}
for c, r in entities.items():
if c in cur_title:
cur_title = cur_title.replace(c, r)

return cur_title

def norm_title(title):
return normalize_entities(normalize_spaces(title))

def get_title(doc):
title = doc.find('.//title')
if title is None or title.text is None or len(title.text) == 0:
return '[no-title]'

return norm_title(title.text)

def title(self):
"""Returns document title"""
return get_title(self._html(True))

title 方法实际上就是调用了一个 get_title 方法,它怎么做的?实际上就是用了一个 XPath 只解析了 <title> 标签里面的内容,别的没了。如果没有,那就返回 [no-title]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def summary(self, html_partial=False):
ruthless = True
while True:
self._html(True)
for i in self.tags(self.html, 'script', 'style'):
i.drop_tree()
for i in self.tags(self.html, 'body'):
i.set('id', 'readabilityBody')
if ruthless:
self.remove_unlikely_candidates()
self.transform_misused_divs_into_paragraphs()
candidates = self.score_paragraphs()

best_candidate = self.select_best_candidate(candidates)

if best_candidate:
article = self.get_article(candidates, best_candidate,
html_partial=html_partial)
else:
if ruthless:
ruthless = False
continue
else:
article = self.html.find('body')
if article is None:
article = self.html
cleaned_article = self.sanitize(article, candidates)
article_length = len(cleaned_article or '')
retry_length = self.retry_length
of_acceptable_length = article_length >= retry_length
if ruthless and not of_acceptable_length:
ruthless = False
continue
else:
return cleaned_article

这里我删除了一些冗余的调试的代码,只保留了核心的代码,其核心实现就是先去除一些干扰内容,然后找出一些疑似正文的 candidates,然后再去寻找最佳匹配的 candidates 最后提取其内容返回即可。 然后再找到获取 candidates 方法里面的 score_paragraphs 方法,又追踪到一个 score_node 方法,就是为每一个节点打分的,其实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def score_node(self, elem):
content_score = self.class_weight(elem)
name = elem.tag.lower()
if name in ["div", "article"]:
content_score += 5
elif name in ["pre", "td", "blockquote"]:
content_score += 3
elif name in ["address", "ol", "ul", "dl", "dd", "dt", "li", "form", "aside"]:
content_score -= 3
elif name in ["h1", "h2", "h3", "h4", "h5", "h6", "th", "header", "footer", "nav"]:
content_score -= 5
return {
'content_score': content_score,
'elem': elem
}

这什么意思呢?你看如果这个节点标签是 div 或者 article 等可能表征正文区块的话,就加 5 分,如果是 aside 等表示侧栏的内容就减 3 分。这些打分也没有什么非常标准的依据,可能是根据经验累积的规则。 另外还有一些方法里面引用了一些正则匹配来进行打分或者替换,其定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 REGEXES = {
'unlikelyCandidatesRe': re.compile('combx|comment|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter', re.I),
'okMaybeItsACandidateRe': re.compile('and|article|body|column|main|shadow', re.I),
'positiveRe': re.compile('article|body|content|entry|hentry|main|page|pagination|post|text|blog|story', re.I),
'negativeRe': re.compile('combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget', re.I),
'divToPElementsRe': re.compile('<(a|blockquote|dl|div|img|ol|p|pre|table|ul)', re.I),
#'replaceBrsRe': re.compile('(<br[^>]*>[ nrt]*){2,}',re.I),
#'replaceFontsRe': re.compile('<(/?)font[^>]*>',re.I),
#'trimRe': re.compile('^s+|s+$/'),
#'normalizeRe': re.compile('s{2,}/'),
#'killBreaksRe': re.compile('(<brs*/?>(s|&nbsp;?)*){1,}/'),
'videoRe': re.compile('https?://(www.)?(youtube|vimeo).com', re.I),
#skipFootnoteLink: /^s*([?[a-z0-9]{1,2}]?|^|edit|citation needed)s*$/i,
}

比如这里定义了 unlikelyCandidatesRe,就是不像 candidates 的 pattern,比如 foot、comment 等等,碰到这样的标签或 pattern 的话,在计算分数的时候都会减分,另外还有其他的 positiveRe、negativeRe 也是一样的原理,分别对匹配到的内容进行加分或者减分。 这就是 Readability 的原理,是基于一些规则匹配的打分模型,很多规则其实来源于经验的累积,分数的计算规则应该也是不断地调优得出来的。 另外其他的就没了,Readability 并没有提供提取时间、作者的方法,另外此种方法的准确率也是有限的,但多少还是省去了一些人工成本。

Newspaper

另外还有一个智能解析的库,叫做 Newspaper,提供的功能更强一些,但是准确率上个人感觉和 Readability 差不太多。 这个库分为 Python2 和 Python3 两个版本,Python2 下的版本叫做 newspaper,Python3 下的版本叫做 newspaper3k,这里我们使用 Python3 版本来进行测试。 其 GitHub 地址是:https://github.com/codelucas/newspaper,官方文档地址是:[https://newspaper.readthedocs.io](https://newspaper.readthedocs.io/)。 在安装之前需要安装一些依赖库,可以参考官方的说明:https://github.com/codelucas/newspaper#get-it-now。 安装好必要的依赖库之后,就可以使用 pip 安装了:

1
pip3 install newspaper3k

安装成功之后便可以导入使用了。 下面我们先用官方提供的实例来过一遍它的用法,官方提供的示例是使用了这个链接:https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/,其页面截图如下官方示例 下面用一个实例来感受一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from newspaper import Article

url = 'https://fox13now.com/2013/12/30/new-year-new-laws-obamacare-pot-guns-and-drones/'
article = Article(url)
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里从 newspaper 库里面先导入了 Article 这个类,然后直接传入 url 即可,首先需要调用它的 download 方法,将网页爬取下来,否则直接进行解析会抛出错误的。

但我总感觉这个设计挺不友好的,parse 方法不能判断下,如果没执行 download 就自动执行 download 方法吗?如果不 download 其他的不什么都干不了吗?

好的,然后我们再执行 parse 方法进行网页的智能解析,这个功能就比较全了,能解析 authors、publish_date、text 等等,除了正文还能解析作者、发布时间等等。 另外这个库还提供了一些 NLP 的方法,比如获取关键词、获取文本摘要等等,在使用前需要先执行以下 nlp 方法。 最后运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
authors: ['Cnn Wire']
date: 2013-12-30 00:00:00
text: By Leigh Ann Caldwell

WASHINGTON (CNN) — Not everyone subscribes to a New Year’s resolution, but Americans will be required to follow new laws in 2014.

Some 40,000 measures taking effect range from sweeping, national mandates under Obamacare to marijuana legalization in Colorado, drone prohibition in Illinois and transgender protections in California.

Although many new laws are controversial, they made it through legislatures, public referendum or city councils and represent the shifting composition of American beliefs.
...
...
Colorado: Marijuana becomes legal in the state for buyers over 21 at a licensed retail dispensary.

(Sourcing: much of this list was obtained from the National Conference of State Legislatures).
top image: https://localtvkstu.files.wordpress.com/2012/04/national-news-e1486938949489.jpg?quality=85&strip=all
movies: []
keywords: ['drones', 'national', 'guns', 'wage', 'law', 'pot', 'leave', 'family', 'states', 'state', 'latest', 'obamacare', 'minimum', 'laws']
summary: Oregon: Family leave in Oregon has been expanded to allow eligible employees two weeks of paid leave to handle the death of a family member.
Arkansas: The state becomes the latest state requiring voters show a picture ID at the voting booth.
Minimum wage and former felon employmentWorkers in 13 states and four cities will see increases to the minimum wage.
New Jersey residents voted to raise the state’s minimum wage by $1 to $8.25 per hour.
California is also raising its minimum wage to $9 per hour, but workers must wait until July to see the addition.

这里省略了一些输出结果。 可以看到作者、日期、正文、关键词、标签、缩略图等信息都被打印出来了,还算是不错的。 但这个毕竟是官方的实例,肯定是好的,我们再测试一下刚才的例子,看看效果如何,网址还是:https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html,改写代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from newspaper import Article

url = 'https://tech.163.com/19/0909/08/EOKA3CFB00097U7S.html'
article = Article(url, language='zh')
article.download()
# print('html:', article.html)

article.parse()
print('authors:', article.authors)
print('title:', article.title)
print('date:', article.publish_date)
print('text:', article.text)
print('top image:', article.top_image)
print('movies:', article.movies)

article.nlp()
print('keywords:', article.keywords)
print('summary:', article.summary)

这里我们将链接换成了新闻的链接,另外在 Article 初始化的时候还加了一个参数 language,其值为 zh,代表中文。 然后我们看下运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Building prefix dict from /usr/local/lib/python3.7/site-packages/jieba/dict.txt ...
Dumping model to file cache /var/folders/1g/l2xlw12x6rncs2p9kh5swpmw0000gn/T/jieba.cache
Loading model cost 1.7178938388824463 seconds.
Prefix dict has been built succesfully.
authors: []
title: 今年iPhone只有小改进?分析师:还有其他亮点
date: 2019-09-09 08:10:26+08:00
text: (原标题:Apple Bets More Cameras Can Keep iPhone Humming)

图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。

网易科技讯 99日消息,据国外媒体报道,和过去的12个年头一样,新款iPhone将成为苹果公司本周所举行年度宣传活动的主角。但人们的注意力正转向需要推动增长的其他苹果产品和服务。
...
...
Strategy Analytics的尼尔·莫斯顿(Neil Mawston)表示,可穿戴设备和服务的结合将是苹果业务超越iPhone的关键。他说,上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)

相关报道:

iPhone 11背部苹果Logo改为居中:为反向无线充电

2019年新iPhone传言汇总,你觉得哪些能成真
top image: https://www.163.com/favicon.ico
movies: []
keywords: ['trust高级投资组合经理丹摩根dan', 'iphone', 'mawston表示可穿戴设备和服务的结合将是苹果业务超越iphone的关键他说上一家手机巨头诺基亚公司在试图进行类似业务转型时就陷入了困境之中辰辰相关报道iphone', 'xs的销售疲软状况迫使苹果在1月份下调了业绩预期这是逾15年来的第一次据贸易公司susquehanna', 'xs机型发布后那种令人失望的业绩重演iphone', '今年iphone只有小改进分析师还有其他亮点', 'more', 'xr和iphone', 'morgan说他们现在没有任何真正深入的进展只是想继续让iphone这款业务继续转下去他乐观地认为今年发布的新款手机将有足够多的新功能为一个非常成熟的产品增加额外的功能让火车继续前进这种仅限于此的态度说明了苹果自2007年发布首款iphone以来所面临的挑战iphone销售占苹果公司总营收的一半以上这让苹果陷入了一个尴尬的境地既要维持核心产品的销量另一方面又需要减少对它的依赖瑞银ubs今年5月份对8000名智能手机用户进行了相关调查其发布的年度全球调查报告显示最近iphone在人脸识别技术等方面的进步并没有引起一些消费者的共鸣他们基本上都认为苹果产品没有过去几年那么独特或者惊艳品牌也没有过去几年那么有吸引力很多人使用老款手机的时间更长自己认为也没有必要升级到平均售价949美元的新款iphone苹果需要在明年销售足够多的iphone以避免像去年9月份iphone', 'keep', '原标题apple']
summary: (原标题:Apple Bets More Cameras Can Keep iPhone Humming)图示:苹果首席执行官蒂姆·库克(Tim Cook)在6月份举行的苹果全球开发者大会上。网易科技讯 99日消息,据国外媒体报道,和过去的12个年头一样,新款iPhone将成为苹果公司本周所举行...亚公司在试图进行类似业务转型时就陷入了困境之中。(辰辰)相关报道:iPhone 11背部苹果Logo改为居中:为反向无线充电2019年新iPhone传言汇总,你觉得哪些能成真

中间正文很长省略了一部分,可以看到运行时首先加载了一些中文的库包,比如 jieba 所依赖的词表等等。 解析结果中,日期的确是解析对了,因为这个日期格式的的确比较规整,但这里还自动给我们加了东八区的时区,贴心了。作者没有提取出来,可能是没匹配到 来源 两个字吧,或者词库里面没有,标题、正文的提取还算比较正确,也或许这个案例的确是比较简单。 另外对于 NLP 部分,获取的关键词比较迷,长度有点太长了。summary 也有点冗余。 另外 Newspaper 还提供了一个较为强大的功能,就是 build 构建信息源。官方的介绍其功能就是构建一个新闻源,可以根据传入的 URL 来提取相关文章、分类、RSS 订阅信息等等。 我们用实例感受一下:

1
2
3
4
5
6
7
8
9
10
11
12
import newspaper

source = newspaper.build('http://www.sina.com.cn/', language='zh')
for category in source.category_urls():
print(category)

for article in source.articles:
print(article.url)
print(article.title)

for feed_url in source.feed_urls():
print(feed_url)

在这里我们传入了新浪的官网,调用了 build 方法,构建了一个 source,然后输出了相关的分类、文章、RSS 订阅等内容,运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
http://cul.news.sina.com.cn
http://www.sina.com.cn/
http://sc.sina.com.cn
http://jiangsu.sina.com.cn
http://gif.sina.com.cn
....
http://tj.sina.com.cn
http://travel.sina.com.cn
http://jiaoyi.sina.com.cn
http://cul.sina.com.cn
https://finance.sina.com.cn/roll/2019-06-12/doc-ihvhiqay5022316.shtml
经参头版:激发微观主体活力加速国企改革
http://eladies.sina.com.cn/feel/xinli/2018-01-25/0722/doc-ifyqwiqk0463751.shtml
我们别再联系了
http://finance.sina.com.cn/roll/2018-05-13/doc-ihamfahx2958233.shtml
新违约时代到来!违约“常态化”下的市场出清与换血
http://sports.sina.com.cn/basketball/2019worldcup/2019-09-08/doc-iicezzrq4390554.shtml
罗健儿26分韩国收首胜
...
http://travel.sina.com.cn/outbound/pages/2019-09-05/detail-iicezzrq3622449.shtml
菲律宾海滨大道 夜晚让人迷离
http://travel.sina.com.cn/outbound/pages/2016-08-19/detail-ifxvcnrv0334779.shtml
关岛 用双脚尽情享受阳光与海滩
http://travel.sina.com.cn/domestic/pages/2019-09-04/detail-iicezzrq3325092.shtml
秋行查干浩特草原
http://travel.sina.com.cn/outbound/pages/2019-09-03/detail-iicezueu3050710.shtml
白羊座的土豪之城迪拜
http://travel.sina.com.cn/video/baidang/2019-08-29/detail-ihytcitn2747327.shtml
肯辛顿宫藏着维多利亚的秘密
http://cd.auto.sina.com.cn/bdcs/2017-08-15/detail-ifyixias1051586.shtml

可以看到它输出了非常多的类别链接,另外还有很多文章列表,由于没有 RSS 订阅内容,这里没有显示。 下面把站点换成我的博客:https://cuiqingcai.com,博客截图如下博客截图 看看运行结果:

1
2
https://cuiqingcai.com
https://cuiqingcai.com

似乎不太行啊,一篇文章都没有,RSS 也没有,可见其功能还有待优化。 Newspaper 的基本用法介绍到这里,更加详细的用法可以参考官方文档:https://newspaper.readthedocs.io。个人感觉其中的智能解析可以用用,不过据我的个人经验,感觉还是很多解析不对或者解析不全的, 以上便是 Readability 和 Newspaper 的介绍。

其他方案

另外除了这两个库其实还有一些比较优秀的算法,由于我们处理的大多为中文文档,所以一些在中文上面的研究是比较有效的,在这里列几个值得借鉴的中文论文供大家参考:

  • 洪鸿辉等,基于文本及符号密度的网页正文提取方法
  • 梁东等,基于支持向量机的网页正文内容提取方法
  • 王卫红等,基于可视块的多记录型复杂网页信息提取算法

今天还看到一位大佬「青南」根据上面第一篇论文所实现的 GeneralNewsExtractor,GitHub 地址为:https://github.com/kingname/GeneralNewsExtractor,经测试准确率还不错,比 Readability 和 Newspaper 的解析效果要好。我也跟作者进行了交流,后续可能还会基于其他的 Feature 或依赖于视觉化的方法进行优化,大家可以关注下,谢谢!