WebMagic官方文档

于 2022-12-03 00:39:37 发布
阅读量678 收藏 2
点赞数
分类专栏： python 爬虫 文章标签： python 爬虫 开发语言
原文链接：http://webmagic.io/docs/zh
版权

WebMagic in Action

Little book of WebMagic.

logo

WebMagic是我业余开发的一款简单灵活的爬虫框架。基于它你可以很容易的编写一个爬虫。

这本小书以WebMagic入手，一方面讲解WebMagic的使用方式，另一方面讲解爬虫开发的一些惯用方案。

文章预览请点http://webmagic.io/docs/，页面基于gitbook进行构建。

本文档遵循CC-BYNC协议。

1.WebMagic概览

WebMagic项目代码分为核心和扩展两部分。核心部分(webmagic-
core)是一个精简的、模块化的爬虫实现，而扩展部分则包括一些便利的、实用性的功能。WebMagic的架构设计参照了Scrapy，目标是尽量的模块化，并体现爬虫的功能特点。

这部分提供非常简单、灵活的API，在基本不改变开发模式的情况下，编写一个爬虫。

扩展部分(webmagic-extension)提供一些便捷的功能，例如注解模式编写爬虫等。同时内置了一些常用的组件，便于爬虫开发。

另外WebMagic还包括一些外围扩展和一个正在开发的产品化项目webmagic-avalon。

1.1 设计思想

logo

1. 一个框架，一个领域

一个好的框架必然凝聚了领域知识。WebMagic的设计参考了业界最优秀的爬虫Scrapy，而实现则应用了HttpClient、Jsoup等Java世界最成熟的工具，目标就是做一个Java语言Web爬虫的教科书般的实现。

如果你是爬虫开发老手，那么WebMagic会非常容易上手，它几乎使用Java原生的开发方式，只不过提供了一些模块化的约束，封装一些繁琐的操作，并且提供了一些便捷的功能。

如果你是爬虫开发新手，那么使用并了解WebMagic会让你了解爬虫开发的常用模式、工具链、以及一些问题的处理方式。熟练使用之后，相信自己从头开发一个爬虫也不是什么难事。

因为这个目标，WebMagic的核心非常简单——在这里，功能性是要给简单性让步的。

2. 微内核和高可扩展性

WebMagic由四个组件(Downloader、PageProcessor、Scheduler、Pipeline)构成，核心代码非常简单，主要是将这些组件结合并完成多线程的任务。这意味着，在WebMagic中，你基本上可以对爬虫的功能做任何定制。

WebMagic的核心在webmagic-core包中，其他的包你可以理解为对WebMagic的一个扩展——这和作为用户编写一个扩展是没有什么区别的。

3. 注重实用性

虽然核心需要足够简单，但是WebMagic也以扩展的方式，实现了很多可以帮助开发的便捷功能。例如基于注解模式的爬虫开发，以及扩展了XPath语法的Xsoup等。这些功能在WebMagic中是可选的，它们的开发目标，就是让使用者开发爬虫尽可能的简单，尽可能的易维护。

1.2 总体架构

WebMagic的结构分为Downloader、PageProcessor、Scheduler、Pipeline四大组件，并由Spider将它们彼此组织起来。这四大组件对应爬虫生命周期中的下载、处理、管理和持久化等功能。WebMagic的设计参考了Scapy，但是实现方式更Java化一些。

而Spider则将这几个组件组织起来，让它们可以互相交互，流程化的执行，可以认为Spider是一个大的容器，它也是WebMagic逻辑的核心。

WebMagic总体架构图如下：

image

1.2.1 WebMagic的四个组件

1.Downloader

Downloader负责从互联网上下载页面，以便后续处理。WebMagic默认使用了Apache
HttpClient作为下载工具。

2.PageProcessor

PageProcessor负责解析页面，抽取有用信息，以及发现新的链接。WebMagic使用Jsoup作为HTML解析工具，并基于其开发了解析XPath的工具Xsoup。

在这四个组件中，PageProcessor对于每个站点每个页面都不一样，是需要使用者定制的部分。

3.Scheduler

Scheduler负责管理待抓取的URL，以及一些去重的工作。WebMagic默认提供了JDK的内存队列来管理URL，并用集合来进行去重。也支持使用Redis进行分布式管理。

除非项目有一些特殊的分布式需求，否则无需自己定制Scheduler。

4.Pipeline

Pipeline负责抽取结果的处理，包括计算、持久化到文件、数据库等。WebMagic默认提供了“输出到控制台”和“保存到文件”两种结果处理方案。

Pipeline定义了结果保存的方式，如果你要保存到指定数据库，则需要编写对应的Pipeline。对于一类需求一般只需编写一个Pipeline。

1.2.2 用于数据流转的对象

1. Request

Request是对URL地址的一层封装，一个Request对应一个URL地址。

它是PageProcessor与Downloader交互的载体，也是PageProcessor控制Downloader唯一方式。

除了URL本身外，它还包含一个Key-
Value结构的字段extra。你可以在extra中保存一些特殊的属性，然后在其他地方读取，以完成不同的功能。例如附加上一个页面的一些信息等。

2. Page

Page代表了从Downloader下载到的一个页面——可能是HTML，也可能是JSON或者其他文本格式的内容。

Page是WebMagic抽取过程的核心对象，它提供一些方法可供抽取、结果保存等。在第四章的例子中，我们会详细介绍它的使用。

3. ResultItems

ResultItems相当于一个Map，它保存PageProcessor处理的结果，供Pipeline使用。它的API与Map很类似，值得注意的是它有一个字段skip，若设置为true，则不应被Pipeline处理。

1.2.3 控制爬虫运转的引擎–Spider

Spider是WebMagic内部流程的核心。Downloader、PageProcessor、Scheduler、Pipeline都是Spider的一个属性，这些属性是可以自由设置的，通过设置这个属性可以实现不同的功能。Spider也是WebMagic操作的入口，它封装了爬虫的创建、启动、停止、多线程等功能。下面是一个设置各个组件，并且设置多线程和启动的例子。详细的Spider设置请看第四章——[爬虫的配置、启动和终止](…/ch4-basic-
page-processor/spider-config.html)。

​

public static void main(String[] args) {
    Spider.create(new GithubRepoPageProcessor())
            //从https://github.com/code4craft开始抓 
            .addUrl("https://github.com/code4craft")
            //设置Scheduler，使用Redis来管理URL队列
            .setScheduler(new RedisScheduler("localhost"))
            //设置Pipeline，将结果以json方式保存到文件
            .addPipeline(new JsonFilePipeline("D:\\data\\webmagic"))
            //开启5个线程同时执行
            .thread(5)
            //启动爬虫
            .run();
}

1.2.4 快速上手

上面介绍了很多组件，但是其实使用者需要关心的没有那么多，因为大部分模块WebMagic已经提供了默认实现。

一般来说，对于编写一个爬虫，PageProcessor是需要编写的部分，而Spider则是创建和控制爬虫的入口。在第四章中，我们会介绍如何通过定制PageProcessor来编写一个爬虫，并通过Spider来启动。

1.3 项目组成

WebMagic项目代码包括几个部分，在根目录下以不同目录名分开。它们都是独立的Maven项目。

1.3.1 主要部分

WebMagic主要包括两个包，这两个包经过广泛实用，已经比较成熟：

webmagic-core

webmagic-core是WebMagic核心部分，只包含爬虫基本模块和基本抽取器。WebMagic-
core的目标是成为网页爬虫的一个教科书般的实现。

webmagic-extension

webmagic-extension是WebMagic的主要扩展模块，提供一些更方便的编写爬虫的工具。包括注解格式定义爬虫、JSON、分布式等支持。

1.3.2 外围功能

除此之外，WebMagic项目里还有几个包，这些都是一些实验性的功能，目的只是提供一些与外围工具整合的样例。因为精力有限，这些包没有经过广泛的使用和测试，推荐使用方式是自行下载源码，遇到问题后再修改。

webmagic-samples

这里是作者早期编写的一些爬虫的例子。因为时间有限，这些例子有些使用的仍然是老版本的API，也可能有一些因为目标页面的结构变化不再可用了。最新的、精选过的例子，请看webmaigc-
core的us.codecraft.webmagic.processor.example包和webmaigc-
core的us.codecraft.webmagic.example包。

webmagic-scripts

WebMagic对于爬虫规则脚本化的一些尝试，目标是让开发者脱离Java语言，来进行简单、快速的开发。同时强调脚本的共享。

目前项目因为感兴趣的用户不多，处于搁置状态，对脚本化感兴趣的可以看这里：[webmagic-
scripts简单文档](https://github.com/code4craft/webmagic/tree/master/webmagic-
scripts)

webmagic-selenium

WebmMgic与Selenium结合的模块。Selenium是一个模拟浏览器进行页面渲染的工具，WebMagic依赖Selenium进行动态页面的抓取。

webmagic-saxon

WebMagic与Saxon结合的模块。Saxon是一个XPath、XSLT的解析工具，webmagic依赖Saxon来进行XPath2.0语法解析支持。

1.3.3 webmagic-avalon

webmagic- avalon是一个特殊的项目，它想基于WebMagic实现一个产品化的工具，涵盖爬虫的创建、爬虫的管理等后台工具。Avalon是亚瑟王传说中的“理想之岛”，webmagic- avalon的目标是提供一个通用的爬虫产品，达到这个目标绝非易事，所以取名也有一点“理想”的意味，但是作者一直在朝这个目标努力。

对这个项目感兴趣的可以看这里WebMagic-
Avalon项目计划。

2. 快速开始

WebMagic主要包含两个jar包：webmagic-core-{version}.jar和webmagic- extension-{version}.jar。在项目中添加这两个包的依赖，即可使用WebMagic。

WebMagic默认使用Maven管理依赖，但是你也可以不依赖Maven进行使用。

2.1 使用Maven

WebMagic基于Maven进行构建，推荐使用Maven来安装WebMagic。在你自己的项目（已有项目或者新建一个）中添加以下坐标即可：

​

<dependency>
    <groupId>us.codecraft</groupId>
    <artifactId>webmagic-core</artifactId>
    <version>0.7.3</version>
</dependency>
<dependency>
    <groupId>us.codecraft</groupId>
    <artifactId>webmagic-extension</artifactId>
    <version>0.7.3</version>
</dependency>

如果你对Maven使用还不熟悉，推荐看看@黄勇的博客：《Maven
那点事儿》。

WebMagic使用slf4j-log4j12作为slf4j的实现.如果你自己定制了slf4j的实现，请在项目中去掉此依赖。

​

<dependency>
    <groupId>us.codecraft</groupId>
    <artifactId>webmagic-extension</artifactId>
    <version>0.7.3</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2.2 不使用Maven

不使用maven的用户，可以去http://webmagic.io中下载最新的jar包。我将所有依赖的jar都打包在了一起，点这里下载。

下载之后进行解压，然后在项目中import即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NssOHbPv-1669999079053)(http://webmagic.qiniudn.com/oscimages/102848_ETcU_190591.png)]

因为WebMagic提倡自己定制，所以项目的源码还是有必要看的。在http://webmagic.io上，你可以下载最新的webmagic- core-{version}-sources.jar和webmagic- extension-{version}-sources.jar，点击"Attach Source"即可。

http://webmagic.qiniudn.com/oscimages/111517_MD4e_190591.png

2.3 第一个爬虫项目

在你的项目中添加了WebMagic的依赖之后，即可开始第一个爬虫的开发了！我们这里拿一个抓取Github信息的例子：

​

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;

public class GithubRepoPageProcessor implements PageProcessor {

    private Site site = Site.me().setRetryTimes(3).setSleepTime(100);

    @Override
    public void process(Page page) {
        page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all());
        page.putField("author", page.getUrl().regex("https://github\\.com/(\\w+)/.*").toString());
        page.putField("name", page.getHtml().xpath("//h1[@class='entry-title public']/strong/a/text()").toString());
        if (page.getResultItems().get("name")==null){
            //skip this page
            page.setSkip(true);
        }
        page.putField("readme", page.getHtml().xpath("//div[@id='readme']/tidyText()"));
    }

    @Override
    public Site getSite() {
        return site;
    }

    public static void main(String[] args) {
        Spider.create(new GithubRepoPageProcessor()).addUrl("https://github.com/code4craft").thread(5).run();
    }
}

点击main方法，选择“运行”，你会发现爬虫已经可以正常工作了！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dLECUAHK-1669999079056)(http://webmagic.qiniudn.com/oscimages/103741_3Gf5_190591.png)]

3.下载和编译源码

如果你对WebMagic的源码感兴趣，那么可以选择源码下载和编译的方式来使用WebMagic。“非常简单的二次开发”也是WebMagic的目标之一。

WebMagic是一个纯Java项目，如果你熟悉Maven，那么下载并编译源码是非常简单的。如果不熟悉Maven也没关系，这部分会介绍如何在Eclipse里导入这个项目。

3.2 导入项目

Intellij Idea默认自带Maven支持，import项目时选择Maven项目即可。

3.2.1 使用m2e插件

使用Eclipse的用户，推荐安装m2e插件，安装地址：https://www.eclipse.org/m2e/download/[](https://www.eclipse.org/m2e/download/)

安装后，在File->Import中选择Maven->Existing Maven Projects即可导入项目。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hG9yjYIJ-1669999079057)(http://webmagic.qiniudn.com/oscimages/104427_eNuc_190591.png)]

导入后看到项目选择界面，点击finish即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KsZig8mP-1669999079058)(http://webmagic.qiniudn.com/oscimages/104735_6vwG_190591.png)]

3.2.2 使用Maven Eclipse插件

如果没有安装m2e插件，只要你安装了Maven，也是比较好办的。在项目根目录下使用命令：

​

mvn eclipse:eclipse

生成maven项目结构的eclipse配置文件，然后在File->Import中选择General->Existing Projects into
Workspace即可导入项目。

eclipse- import-1

导入后看到项目选择界面，点击finish即可。

eclipse- import-2

3.3 编译和执行源码

导入成功之后，应该就没有编译错误了！此时你可以运行一下webmagic-
core项目中自带的exmaple:“us.codecraft.webmagic.processor.example.GithubRepoPageProcessor”。

同样，看到控制台输出如下，则表示源码编译和执行成功了！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lAohSnSe-1669999079060)(http://webmagic.qiniudn.com/oscimages/103741_3Gf5_190591.png)]

4. 编写基本的爬虫

在WebMagic里，实现一个基本的爬虫只需要编写一个类，实现PageProcessor接口即可。这个类基本上包含了抓取一个网站，你需要写的所有代码。

同时这部分还会介绍如何使用WebMagic的抽取API，以及最常见的抓取结果保存的问题。

4.1 实现PageProcessor

这部分我们直接通过GithubRepoPageProcessor这个例子来介绍PageProcessor的编写方式。我将PageProcessor的定制分为三个部分，分别是爬虫的配置、页面元素的抽取和链接的发现。

​

public class GithubRepoPageProcessor implements PageProcessor {

    // 部分一：抓取网站的相关配置，包括编码、抓取间隔、重试次数等
    private Site site = Site.me().setRetryTimes(3).setSleepTime(1000);

    @Override
    // process是定制爬虫逻辑的核心接口，在这里编写抽取逻辑
    public void process(Page page) {
        // 部分二：定义如何抽取页面信息，并保存下来
        page.putField("author", page.getUrl().regex("https://github\\.com/(\\w+)/.*").toString());
        page.putField("name", page.getHtml().xpath("//h1[@class='entry-title public']/strong/a/text()").toString());
        if (page.getResultItems().get("name") == null) {
            //skip this page
            page.setSkip(true);
        }
        page.putField("readme", page.getHtml().xpath("//div[@id='readme']/tidyText()"));

        // 部分三：从页面发现后续的url地址来抓取
        page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/[\\w\\-]+/[\\w\\-]+)").all());
    }

    @Override
    public Site getSite() {
        return site;
    }

    public static void main(String[] args) {

        Spider.create(new GithubRepoPageProcessor())
                //从"https://github.com/code4craft"开始抓
                .addUrl("https://github.com/code4craft")
                //开启5个线程抓取
                .thread(5)
                //启动爬虫
                .run();
    }
}
4.1.1 爬虫的配置

第一部分关于爬虫的配置，包括编码、抓取间隔、超时时间、重试次数等，也包括一些模拟的参数，例如User
Agent、cookie，以及代理的设置，我们会在第5章-“爬虫的配置”里进行介绍。在这里我们先简单设置一下：重试次数为3次，抓取间隔为一秒。

4.1.2 页面元素的抽取

第二部分是爬虫的核心部分：对于下载到的Html页面，你如何从中抽取到你想要的信息？WebMagic里主要使用了三种抽取技术：XPath、正则表达式和CSS选择器。另外，对于JSON格式的内容，可使用JsonPath进行解析。

1. XPath

XPath本来是用于XML中获取元素的一种查询语言，但是用于Html也是比较方便的。例如：

     page.getHtml().xpath("//h1[@class='entry-title public']/strong/a/text()")

这段代码使用了XPath，它的意思是“查找所有class属性为’entry-title
public’的h1元素，并找到他的strong子节点的a子节点，并提取a节点的文本信息”。 对应的Html是这样子的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r8551h11-1669999079061)(http://webmagic.qiniudn.com/oscimages/104607_Aqq8_190591.png)]

2. CSS选择器

CSS选择器是与XPath类似的语言。如果大家做过前端开发，肯定知道$(‘h1.entry-
title’)这种写法的含义。客观的说，它比XPath写起来要简单一些，但是如果写复杂一点的抽取规则，就相对要麻烦一点。

3. 正则表达式

正则表达式则是一种通用的文本抽取语言。

     page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all());

这段代码就用到了正则表达式，它表示匹配所有"https://github.com/code4craft/webmagic"这样的链接。

4. JsonPath

JsonPath是于XPath很类似的一个语言，它用于从Json中快速定位一条内容。WebMagic中使用的JsonPath格式可以参考这里：<https://code.google.com/p/json-
path/>

4.1.3 链接的发现

有了处理页面的逻辑，我们的爬虫就接近完工了！

但是现在还有一个问题：一个站点的页面是很多的，一开始我们不可能全部列举出来，于是如何发现后续的链接，是一个爬虫不可缺少的一部分。

​

page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all());

这段代码的分为两部分，page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all()用于获取所有满足"(https:/
/github\.com/\w+/\w+)"这个正则表达式的链接，page.addTargetRequests()则将这些链接加入到待抓取的队列中去。

4.2 使用Selectable抽取元素

Selectable相关的抽取元素链式API是WebMagic的一个核心功能。使用Selectable接口，你可以直接完成页面元素的链式抽取，也无需去关心抽取的细节。

在刚才的例子中可以看到，page.getHtml()返回的是一个Html对象，它实现了Selectable接口。这个接口包含一些重要的方法，我将它分为两类：抽取部分和获取结果部分。

4.2.1 抽取部分API：
方法说明示例
xpath(String xpath)使用XPath选择html.xpath(“//div[@class=‘title’]”)
$(String selector)使用Css选择器选择html.$(“div.title”)
$(String selector,String attr)使用Css选择器选择html.$(“div.title”,“text”)
css(String selector)功能同$()，使用Css选择器选择html.css(“div.title”)
links()选择所有链接html.links()
regex(String regex)使用正则表达式抽取html.regex(“\ (.\*?)”)
regex(String regex,int group)使用正则表达式抽取，并指定捕获组html.regex(“\ (.\*?)”,1)
replace(String regex, String replacement)替换内容html.replace(“”,“”)

这部分抽取API返回的都是一个Selectable接口，意思是说，抽取是支持链式调用的。下面我用一个实例来讲解链式API的使用。

例如，我现在要抓取github上所有的Java项目，这些项目可以在https://github.com/search?l=Java&p=1&q=stars%3A%3E1&s=stars&type=Repositories搜索结果中看到。

为了避免抓取范围太宽，我指定只从分页部分抓取链接。这个抓取规则是比较复杂的，我会要怎么写呢？

selectable-chain- ui

首先看到页面的html结构是这个样子的：

selectable- chain

那么我可以先用CSS选择器提取出这个div，然后在取到所有的链接。为了保险起见，我再使用正则表达式限定一下提取出的URL的格式，那么最终的写法是这样子的：

​

List<String> urls = page.getHtml().css("div.pagination").links().regex(".*/search/\?l=java.*").all();

然后，我们可以把这些URL加到抓取列表中去：

​

List<String> urls = page.getHtml().css("div.pagination").links().regex(".*/search/\?l=java.*").all();
page.addTargetRequests(urls);

是不是比较简单？除了发现链接，Selectable的链式抽取还可以完成很多工作。我们会在第9章示例中再讲到。

4.2.2 获取结果的API：

当链式调用结束时，我们一般都想要拿到一个字符串类型的结果。这时候就需要用到获取结果的API了。我们知道，一条抽取规则，无论是XPath、CSS选择器或者正则表达式，总有可能抽取到多条元素。WebMagic对这些进行了统一，你可以通过不同的API获取到一个或者多个元素。

方法说明示例
get()返回一条String类型的结果String link= html.links().get()
toString()功能同get()，返回一条String类型的结果String link= html.links().toString()
all()返回所有抽取结果List links= html.links().all()
match()是否有匹配结果if (html.links().match()){ xxx; }

例如，我们知道页面只会有一条结果，那么可以使用selectable.get()或者selectable.toString()拿到这条结果。

这里selectable.toString()采用了toString()这个接口，是为了在输出以及和一些框架结合的时候，更加方便。因为一般情况下，我们都只需要选择一个元素！

selectable.all()则会获取到所有元素。

好了，到现在为止，在回过头看看3.1中的GithubRepoPageProcessor，可能就觉得更加清晰了吧？指定main方法，已经可以看到抓取结果在控制台输出了。

4.3 使用Pipeline保存结果

好了，爬虫编写完成，现在我们可能还有一个问题：我如果想把抓取的结果保存下来，要怎么做呢？WebMagic用于保存结果的组件叫做Pipeline。例如我们通过“控制台输出结果”这件事也是通过一个内置的Pipeline完成的，它叫做ConsolePipeline。那么，我现在想要把结果用Json的格式保存下来，怎么做呢？我只需要将Pipeline的实现换成"JsonFilePipeline"就可以了。

​

public static void main(String[] args) {
    Spider.create(new GithubRepoPageProcessor())
            //从"https://github.com/code4craft"开始抓
            .addUrl("https://github.com/code4craft")
            .addPipeline(new JsonFilePipeline("D:\\webmagic\\"))
            //开启5个线程抓取
            .thread(5)
            //启动爬虫
            .run();
}

这样子下载下来的文件就会保存在D盘的webmagic目录中了。

通过定制Pipeline，我们还可以实现保存结果到文件、数据库等一系列功能。这个会在第7章“抽取结果的处理”中介绍。

至此为止，我们已经完成了一个基本爬虫的编写，也具有了一些定制功能。

4.4 爬虫的配置、启动和终止

4.4.1 Spider

Spider是爬虫启动的入口。在启动爬虫之前，我们需要使用一个PageProcessor创建一个Spider对象，然后使用run()进行启动。同时Spider的其他组件（Downloader、Scheduler、Pipeline）都可以通过set方法来进行设置。

方法说明示例
create(PageProcessor)创建SpiderSpider.create(new GithubRepoProcessor())
addUrl(String…)添加初始的URLspider .addUrl(“http://webmagic.io/docs/”)
addRequest(Request…)添加初始的Requestspider

.addRequest(“http://webmagic.io/docs/”)
thread(n) | 开启n个线程 | spider.thread(5)
run() | 启动，会阻塞当前线程执行 | spider.run()
start()/runAsync() | 异步启动，当前线程继续执行 | spider.start()
stop() | 停止爬虫 | spider.stop()
test(String) | 抓取一个页面进行测试 | spider .test(“http://webmagic.io/docs/”)
addPipeline(Pipeline) | 添加一个Pipeline，一个Spider可以有多个Pipeline | spider
.addPipeline(new ConsolePipeline())
setScheduler(Scheduler) | 设置Scheduler，一个Spider只能有个一个Scheduler |
spider.setScheduler(new RedisScheduler())
setDownloader(Downloader) | 设置Downloader，一个Spider只能有个一个Downloader | spider
.setDownloader(new SeleniumDownloader())
get(String) | 同步调用，并直接取得结果 | ResultItems result = spider
.get(“http://webmagic.io/docs/”)
getAll(String…) | 同步调用，并直接取得一堆结果 | List results = spider
.getAll(“http://webmagic.io/docs/”, “http://webmagic.io/xxx”)

4.4.2 Site

对站点本身的一些配置信息，例如编码、HTTP头、超时时间、重试策略等、代理等，都可以通过设置Site对象来进行配置。

方法说明示例
setCharset(String)设置编码site.setCharset(“utf-8”)
setUserAgent(String)设置UserAgentsite.setUserAgent(“Spider”)
setTimeOut(int)设置超时时间，单位是毫秒site.setTimeOut(3000)
setRetryTimes(int)设置重试次数site.setRetryTimes(3)
setCycleRetryTimes(int)设置循环重试次数site.setCycleRetryTimes(3)
addCookie(String,String)添加一条cookie

site.addCookie(“dotcomt_user”,“code4craft”)
setDomain(String) | 设置域名，需设置域名后，addCookie才可生效 | site.setDomain(“github.com”)
addHeader(String,String) | 添加一条addHeader |
site.addHeader(“Referer”,“https://github.com”)
setHttpProxy(HttpHost) | 设置Http代理 | site.setHttpProxy(new
HttpHost(“127.0.0.1”,8080))

其中循环重试cycleRetry是0.3.0版本加入的机制。

该机制会将下载失败的url重新放入队列尾部重试，直到达到重试次数，以保证不因为某些网络原因漏抓页面。

4.5 Jsoup和Xsoup

WebMagic的抽取主要用到了Jsoup和我自己开发的工具Xsoup。

4.5.1 Jsoup

Jsoup是一个简单的HTML解析器，同时它支持使用CSS选择器的方式查找元素。为了开发WebMagic，我对Jsoup的源码进行过详细的分析，具体文章参见[Jsoup学习笔记](https://github.com/code4craft/jsoup-
learning)。

4.5.2 Xsoup

Xsoup是我基于Jsoup开发的一款XPath解析器。

之前WebMagic使用的解析器是HtmlCleaner，使用过程存在一些问题。主要问题是XPath出错定位不准确，并且其不太合理的代码结构，也难以进行定制。最终我自己实现了Xsoup，使得更加符合爬虫开发的需要。令人欣喜的是，经过测试，Xsoup的性能比HtmlCleaner要快一倍以上。

Xsoup发展到现在，已经支持爬虫常用的语法，以下是一些已支持的语法对照表：

NameExpressionSupport
nodenamenodenameyes
immediate parent/yes
parent//yes
attribute[@key=value]yes
nth childtag[n]yes
attribute/@keyyes
wildcard in tagname/*yes
wildcard in attribute/[@*]yes
functionfunction()part
orab
parent in path. or …no
predicatesprice>35no
predicates logic@class=a or @class=byes since 0.2.0

另外我自己定义了几个对于爬虫来说，很方便的XPath函数。但是请注意，这些函数式标准XPath没有的。

ExpressionDescriptionXPath1.0
text(n)第n个直接文本子节点，为0表示所有text() only
allText()所有的直接和间接文本子节点not support
tidyText()所有的直接和间接文本子节点，并将一些标签替换为换行，使纯文本显示更整洁not support
html()内部html，不包括标签的html本身not support
outerHtml()内部html，包括标签的html本身not support
regex(@attr,expr,group)这里@attr和group均可选，默认是group0not support
4.5.3 Saxon

Saxon是一个强大的XPath解析器，支持XPath 2.0语法。webmagic-saxon是对Saxon尝试性的一个整合，但是目前看来，XPath
2.0的高级语法，似乎在爬虫开发中使用者并不多。

4.6 爬虫的监控

爬虫的监控是0.5.0新增的功能。利用这个功能，你可以查看爬虫的执行情况——已经下载了多少页面、还有多少页面、启动了多少线程等信息。该功能通过JMX实现，你可以使用Jconsole等JMX工具查看本地或者远程的爬虫信息。

如果你完全不会JMX也没关系，因为它的使用相对简单，本章会比较详细的讲解使用方法。如果要弄明白其中原理，你可能需要一些JMX的知识，推荐阅读：JMX整理。我很多部分也对这篇文章进行了参考。

注意:
如果你自己定义了Scheduler，那么需要用这个类实现MonitorableScheduler接口，才能查看“LeftPageCount”和“TotalPageCount”这两条信息。

4.6.1 为项目添加监控

添加监控非常简单，获取一个SpiderMonitor的单例SpiderMonitor.instance()，并将你想要监控的Spider注册进去即可。你可以注册多个Spider到SpiderMonitor中。

​

public class MonitorExample {

    public static void main(String[] args) throws Exception {

        Spider oschinaSpider = Spider.create(new OschinaBlogPageProcessor())
                .addUrl("http://my.oschina.net/flashsword/blog");
        Spider githubSpider = Spider.create(new GithubRepoPageProcessor())
                .addUrl("https://github.com/code4craft");

        SpiderMonitor.instance().register(oschinaSpider);
        SpiderMonitor.instance().register(githubSpider);
        oschinaSpider.start();
        githubSpider.start();
    }
}
4.6.2 查看监控信息

WebMagic的监控使用JMX提供控制，你可以使用任何支持JMX的客户端来进行连接。我们这里以JDK自带的JConsole为例。我们首先启动WebMagic的一个Spider，并添加监控代码。然后我们通过JConsole来进行查看。

我们按照4.6.1的例子启动程序，然后在命令行输入jconsole（windows下是在DOS下输入jconsole.exe）即可启动JConsole。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x5UZcVsc-1669999079062)(http://webmagic.qiniudn.com/oscimages/231513_lP2O_190591.png)]

这里我们选择启动WebMagic的本地进程，连接后选择“MBean”，点开“WebMagic”，就能看到所有已经监控的Spider信息了！

这里我们也可以选择“操作”，在操作里可以选择启动-start()和终止爬虫-
stop()，这会直接调用对应Spider的start()和stop()方法，来达到基本控制的目的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZbeQNzxt-1669999079063)(http://webmagic.qiniudn.com/oscimages/231652_B3Mt_190591.png)]

4.6.3 扩展监控接口

除了已有的一些监控信息，如果你有更多的信息需要监控，也可以通过扩展的方式来解决。你可以通过继承SpiderStatusMXBean来实现扩展，具体例子可以看这里：
[定制扩展demo](https://github.com/code4craft/webmagic/tree/master/webmagic-
extension/src/test/java/us/codecraft/webmagic/monitor)。

4.7 配置代理

从0.7.1版本开始，WebMagic开始使用了新的代理APIProxyProvider。因为相对于Site的“配置”，ProxyProvider定位更多是一个“组件”，所以代理不再从Site设置，而是由HttpClientDownloader设置。

API说明
HttpClientDownloader.setProxyProvider(ProxyProvider proxyProvider)设置代理

ProxyProvider有一个默认实现：SimpleProxyProvider。它是一个基于简单Round-
Robin的、没有失败检查的ProxyProvider。可以配置任意个候选代理，每次会按顺序挑选一个代理使用。它适合用在自己搭建的比较稳定的代理的场景。

代理示例：

1. 设置单一的普通HTTP代理为101.101.101.101的8888端口，并设置密码为"username","password"

​

    HttpClientDownloader httpClientDownloader = new HttpClientDownloader();
    httpClientDownloader.setProxyProvider(SimpleProxyProvider.from(new Proxy("101.101.101.101",8888,"username","password")));
    spider.setDownloader(httpClientDownloader);


1. 设置代理池，其中包括101.101.101.101和102.102.102.102两个IP，没有密码

​

    HttpClientDownloader httpClientDownloader = new HttpClientDownloader();
    httpClientDownloader.setProxyProvider(SimpleProxyProvider.from(
    new Proxy("101.101.101.101",8888)
    ,new Proxy("102.102.102.102",8888)));

如果对于代理部分有建议的，欢迎参与讨论#579
更多的代理ProxyProvider实现

4.8 处理非HTTP GET请求

一般来说，爬虫只会抓取信息展示类的页面，所以基本只会处理HTTP GET方法的数据。但是对于某些场景，模拟POST等方法也是需要的。

0.7.1版本之后，废弃了老的nameValuePair的写法，采用在Request对象上添加Method和requestBody来实现。

​

Request request = new Request("http://xxx/path");
request.setMethod(HttpConstant.Method.POST);
request.setRequestBody(HttpRequestBody.json("{'id':1}","utf-8"));

HttpRequestBody内置了几种初始化方式，支持最常见的表单提交、json提交等方式。

API说明
HttpRequestBody.form(Map\ params, String encoding)使用表单提交的方式
HttpRequestBody.json(String json, String encoding)使用JSON的方式，json是序列化后的结果
HttpRequestBody.xml(String xml, String encoding)设置xml的方式，xml是序列化后的结果
HttpRequestBody.custom(byte[] body, String contentType, String encoding)

设置自定义的requestBody

POST的去重：

从0.7.1版本开始，POST默认不会去重，详情见：Issue
484。如果想要去重可以自己继承DuplicateRemovedScheduler，重写push方法。

5.使用注解编写爬虫

WebMagic支持使用独有的注解风格编写一个爬虫，引入webmagic-extension包即可使用此功能。

在注解模式下，使用一个简单对象加上注解，可以用极少的代码量就完成一个爬虫的编写。对于简单的爬虫，这样写既简单又容易理解，并且管理起来也很方便。这也是WebMagic的一大特色，我戏称它为OEM(Object/Extraction
Mapping)。

注解模式的开发方式是这样的：

1. 首先定义你需要抽取的数据，并编写类。
2. 在类上写明`@TargetUrl`注解，定义对哪些URL进行下载和抽取。
3. 在类的字段上加上`@ExtractBy`注解，定义这个字段使用什么方式进行抽取。
4. 定义结果的存储方式。

下面我们仍然以第四章中github的例子，来编写一个同样功能的爬虫，来讲解注解功能的使用。最终编写好的爬虫是这样子的，是不是更加简单？

​

@TargetUrl("https://github.com/\\w+/\\w+")
@HelpUrl("https://github.com/\\w+")
public class GithubRepo {

    @ExtractBy(value = "//h1[@class='entry-title public']/strong/a/text()", notNull = true)
    private String name;

    @ExtractByUrl("https://github\\.com/(\\w+)/.*")
    private String author;

    @ExtractBy("//div[@id='readme']/tidyText()")
    private String readme;

    public static void main(String[] args) {
        OOSpider.create(Site.me().setSleepTime(1000)
                , new ConsolePageModelPipeline(), GithubRepo.class)
                .addUrl("https://github.com/code4craft").thread(5).run();
    }
}

5.1 编写Model类

同第四章的例子一样，我们这里抽取一个github项目的名称、作者和简介三个信息，所以我们定义了一个Model类。

​

public class GithubRepo {

    private String name;

    private String author;

    private String readme;

}

这里省略了getter和setter方法。

在抽取最后，我们会得到这个类的一个或者多个实例，这就是爬虫的结果。

5.2 TargetUrl与HelpUrl

在第二步，我们仍然要定义如何发现URL。这里我们要先引入两个概念：@TargetUrl和@HelpUrl。

5.2.1 TargetUrl与HelpUrl

HelpUrl/TargetUrl是一个非常有效的爬虫开发模式，TargetUrl是我们最终要抓取的URL，最终想要的数据都来自这里；而HelpUrl则是为了发现这个最终URL，我们需要访问的页面。几乎所有垂直爬虫的需求，都可以归结为对这两类URL的处理：

  • 对于博客页，HelpUrl是列表页，TargetUrl是文章页。
  • 对于论坛，HelpUrl是帖子列表，TargetUrl是帖子详情。
  • 对于电商网站，HelpUrl是分类列表，TargetUrl是商品详情。

在这个例子中，TargetUrl是最终的项目页，而HelpUrl则是项目搜索页，它会展示所有项目的链接。

有了这些知识，我们就为这个例子定义URL格式：

​

@TargetUrl("https://github.com/\\w+/\\w+")
@HelpUrl("https://github.com/\\w+")
public class GithubRepo {
    ……
}
TargetUrl中的自定义正则表达式

这里我们使用的是正则表达式来规定URL范围。可能细心的朋友，会知道.是正则表达式的保留字符，那么这里是不是写错了呢？其实是这里为了方便，WebMagic自己定制的适合URL的正则表达式，主要由两点改动：

  • 将URL中常用的字符.默认做了转义，变成了\.
  • 将"“替换成了”."，直接使用可表示通配符。

例如，https://github.com/*在这里是一个合法的表达式，它表示https://github.com/下的所有URL。

在WebMagic中，从TargetUrl页面得到的URL，只要符合TargetUrl的格式，也是会被下载的。所以即使不指定HelpUrl也是可以的——例如某些博客页总会有“下一篇”链接，这种情况下无需指定HelpUrl。

sourceRegion

TargetUrl还支持定义sourceRegion，这个参数是一个XPath表达式，指定了这个URL从哪里得到——不在sourceRegion的URL不会被抽取。

5.4 在类上使用ExtractBy

在之前的注解模式中，我们一个页面只对应一条结果。如果一个页面有多个抽取的记录呢？例如在“QQ美食”的列表页面http://meishi.qq.com/beijing/c/all，我想要抽取所有商户名和优惠信息，该怎么办呢？

在类上使用@ExtractBy注解可以解决这个问题。

在类上使用这个注解的意思很简单：使用这个结果抽取一个区域，让这块区域对应一个结果。

​

@ExtractBy(value = "//ul[@id=\"promos_list2\"]/li",multi = true)
public class QQMeishi {
    ……
}

对应的，在这个类中的字段上再使用@ExtractBy的话，则是从这个区域而不是整个页面进行抽取。如果这个时候仍想要从整个页面抽取，则可以设置source = RawHtml。

​

@TargetUrl("http://meishi.qq.com/beijing/c/all[\\-p2]*")
@ExtractBy(value = "//ul[@id=\"promos_list2\"]/li",multi = true)
public class QQMeishi {

    @ExtractBy("//div[@class=info]/a[@class=title]/h4/text()")
    private String shopName;

    @ExtractBy("//div[@class=info]/a[@class=title]/text()")
    private String promo;

    public static void main(String[] args) {
        OOSpider.create(Site.me(), new ConsolePageModelPipeline(), QQMeishi.class).addUrl("http://meishi.qq.com/beijing/c/all").thread(4).run();
    }

}

5.5 结果的类型转换

类型转换（Formatter机制）是WebMagic
0.3.2增加的功能。因为抽取到的内容总是String，而我们想要的内容则可能是其他类型。Formatter可以将抽取到的内容，自动转换成一些基本类型，而无需手动使用代码进行转换。

例如：

​

@ExtractBy("//ul[@class='pagehead-actions']/li[1]//a[@class='social-count js-social-count']/text()")
private int star;
5.5.1 自动转换支持的类型

自动转换支持所有基本类型和装箱类型。

基本类型装箱类型
intInteger
longLong
doubleDouble
floatFloat
shortShort
charCharacter
byteByte
booleanBoolean

另外，还支持java.util.Date类型的转换。但是在转换时，需要指定Date的格式。格式按照JDK的标准来定义，具体规范可以看这里：http://java.sun.com/docs/books/tutorial/i18n/format/simpleDateFormat.html

​

@Formatter("yyyy-MM-dd HH:mm")
@ExtractBy("//div[@class='BlogStat']/regex('\\d+-\\d+-\\d+\\s+\\d+:\\d+')")
private Date date;
5.5.2 显式指定转换类型

一般情况下，Formatter会根据字段类型进行转换，但是特殊情况下，我们会需要手动指定类型。这主要发生在字段是List类型的时候。

​

@Formatter(value = "",subClazz = Integer.class)
@ExtractBy(value = "//div[@class='id']/text()", multi = true)
private List<Integer> ids;
5.5.3 自定义Formatter（TODO）

实际上，除了自动类型转换之外，Formatter还可以做一些结果的后处理的事情。例如，我们有一种需求场景，需要将抽取的结果作为结果的一部分，拼接上一部分字符串来使用。在这里，我们定义了一个StringTemplateFormatter。

​

public class StringTemplateFormatter implements ObjectFormatter<String> {

    private String template;

    @Override
    public String format(String raw) throws Exception {
        return String.format(template, raw);
    }

    @Override
    public Class<String> clazz() {
        return String.class;
    }

    @Override
    public void initParam(String[] extra) {
        template = extra[0];
    }
}

那么，我们就能在抽取之后，做一些简单的操作了！

​

@Formatter(value = "author is %s",formatter = StringTemplateFormatter.class)
@ExtractByUrl("https://github\\.com/(\\w+)/.*")
private String author;

此功能在0.4.3版本有BUG，将会在0.5.0中修复并开放。

5.6 一个完整的流程

到之前为止，我们了解了URL和抽取相关API，一个爬虫已经基本编写完成了。

​

@TargetUrl("https://github.com/\\w+/\\w+")
@HelpUrl("https://github.com/\\w+")
public class GithubRepo {

    @ExtractBy(value = "//h1[@class='entry-title public']/strong/a/text()", notNull = true)
    private String name;

    @ExtractByUrl("https://github\\.com/(\\w+)/.*")
    private String author;

    @ExtractBy("//div[@id='readme']/tidyText()")
    private String readme;
}
5.6.1 爬虫的创建和启动

注解模式的入口是OOSpider，它继承了Spider类，提供了特殊的创建方法，其他的方法是类似的。创建一个注解模式的爬虫需要一个或者多个Model类，以及一个或者多个PageModelPipeline——定义处理结果的方式。

​

public static OOSpider create(Site site, PageModelPipeline pageModelPipeline, Class... pageModels);
5.6.2 PageModelPipeline

注解模式下，处理结果的类叫做PageModelPipeline，通过实现它，你可以自定义自己的结果处理方式。

​

public interface PageModelPipeline<T> {

    public void process(T t, Task task);

}

PageModelPipeline与Model类是对应的，多个Model可以对应一个PageModelPipeline。除了创建时，你还可以通过

​

public OOSpider addPageModel(PageModelPipeline pageModelPipeline, Class... pageModels)

方法，在添加一个Model的同时，可以添加一个PageModelPipeline。

5.6.3 结语

好了，现在我们来完成这个例子：

​

@TargetUrl("https://github.com/\\w+/\\w+")
@HelpUrl("https://github.com/\\w+")
public class GithubRepo {

    @ExtractBy(value = "//h1[@class='entry-title public']/strong/a/text()", notNull = true)
    private String name;

    @ExtractByUrl("https://github\\.com/(\\w+)/.*")
    private String author;

    @ExtractBy("//div[@id='readme']/tidyText()")
    private String readme;

    public static void main(String[] args) {
        OOSpider.create(Site.me().setSleepTime(1000)
                , new ConsolePageModelPipeline(), GithubRepo.class)
                .addUrl("https://github.com/code4craft").thread(5).run();
    }
}

5.7 AfterExtractor

有的时候，注解模式无法满足所有需求，我们可能还需要写代码完成一些事情，这个时候就要用到AfterExtractor接口了。

​

public interface AfterExtractor {

    public void afterProcess(Page page);
}

afterProcess方法会在抽取结束，字段都初始化完毕之后被调用，可以处理一些特殊的逻辑。例如这个例子使用Jfinal
ActiveRecord持久化webmagic爬到的博客：

​

//TargetUrl的意思是只有以下格式的URL才会被抽取出生成model对象
//这里对正则做了一点改动，'.'默认是不需要转义的，而'*'则会自动被替换成'.*'，因为这样描述URL看着舒服一点...
//继承jfinal中的Model
//实现AfterExtractor接口可以在填充属性后进行其他操作
@TargetUrl("http://my.oschina.net/flashsword/blog/*")
public class OschinaBlog extends Model<OschinaBlog> implements AfterExtractor {

    //用ExtractBy注解的字段会被自动抽取并填充
    //默认是xpath语法
    @ExtractBy("//title")
    private String title;

    //可以定义抽取语法为Css、Regex等
    @ExtractBy(value = "div.BlogContent", type = ExtractBy.Type.Css)
    private String content;

    //multi标注的抽取结果可以是一个List
    @ExtractBy(value = "//div[@class='BlogTags']/a/text()", multi = true)
    private List<String> tags;

    @Override
    public void afterProcess(Page page) {
        //jfinal的属性其实是一个Map而不是字段，没关系，填充进去就是了
        this.set("title", title);
        this.set("content", content);
        this.set("tags", StringUtils.join(tags, ","));
        //保存
        save();
    }

    public static void main(String[] args) {
        C3p0Plugin c3p0Plugin = new C3p0Plugin("jdbc:mysql://127.0.0.1/blog?characterEncoding=utf-8", "blog", "password");
        c3p0Plugin.start();
        ActiveRecordPlugin activeRecordPlugin = new ActiveRecordPlugin(c3p0Plugin);
        activeRecordPlugin.addMapping("blog", OschinaBlog.class);
        activeRecordPlugin.start();
        //启动webmagic
        OOSpider.create(Site.me().addStartUrl("http://my.oschina.net/flashsword/blog/145796"), OschinaBlog.class).run();
    }
}
结语

注解模式现在算是介绍结束了，在WebMagic里，注解模式其实是完全基于webmagic- core中的PageProcessor和Pipeline扩展实现的，有兴趣的朋友可以去看看代码。

这部分实现其实还是比较复杂的，如果发现一些细节的代码存在问题，欢迎向我反馈。

6. 组件的使用和定制

在第一章里，我们提到了WebMagic的组件。WebMagic的一大特色就是可以灵活的定制组件功能，实现你自己想要的功能。

在Spider类里，PageProcessor、Downloader、Scheduler和Pipeline四个组件都是Spider的字段。除了PageProcessor是在Spider创建的时候已经指定，Downloader、Scheduler和Pipeline都可以通过Spider的setter方法来进行配置和更改。

方法说明示例
setScheduler()设置Schedulerspipder.setScheduler(new

FileCacheQueueScheduler(“D:\data\webmagic”))
setDownloader() | 设置Downloader | spipder.setDownloader(new
SeleniumDownloader()))
addPipeline() | 设置Pipeline，一个Spider可以有多个Pipeline | spipder.addPipeline(new
FilePipeline())

在这一章，我们会讲到如何定制这些组件，完成我们想要的功能。

6.1 使用和定制Pipeline

Pileline是抽取结束后，进行处理的部分，它主要用于抽取结果的保存，也可以定制Pileline可以实现一些通用的功能。在这一节中，我们会对Pipeline进行介绍，并用两个例子来讲解如何定制Pipeline。

6.1.1 Pipeline介绍

Pipeline的接口定义如下：

​

public interface Pipeline {

    // ResultItems保存了抽取结果，它是一个Map结构，
    // 在page.putField(key,value)中保存的数据，可以通过ResultItems.get(key)获取
    public void process(ResultItems resultItems, Task task);

}

可以看到，Pipeline其实就是将PageProcessor抽取的结果，继续进行了处理的，其实在Pipeline中完成的功能，你基本上也可以直接在PageProcessor实现，那么为什么会有Pipeline？有几个原因：

1. 为了模块分离。“页面抽取”和“后处理、持久化”是爬虫的两个阶段，将其分离开来，一个是代码结构比较清晰，另一个是以后也可能将其处理过程分开，分开在独立的线程以至于不同的机器执行。
2. Pipeline的功能比较固定，更容易做成通用组件。每个页面的抽取方式千变万化，但是后续处理方式则比较固定，例如保存到文件、保存到数据库这种操作，这些对所有页面都是通用的。WebMagic中就已经提供了控制台输出、保存到文件、保存为JSON格式的文件几种通用的Pipeline。

在WebMagic里，一个Spider可以有多个Pipeline，使用Spider.addPipeline()即可增加一个Pipeline。这些Pipeline都会得到处理，例如你可以使用

​

spider.addPipeline(new ConsolePipeline()).addPipeline(new FilePipeline())

实现输出结果到控制台，并且保存到文件的目标。

6.1.2 将结果输出到控制台

在介绍PageProcessor时，我们使用了[GithubRepoPageProcessor](https://github.com/code4craft/webmagic/blob/master/webmagic-
core/src/main/java/us/codecraft/webmagic/processor/example/GithubRepoPageProcessor.java)作为例子，其中某一段代码中，我们将结果进行了保存：

​

public void process(Page page) {
    page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all());
    page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+)").all());
    //保存结果author，这个结果会最终保存到ResultItems中
    page.putField("author", page.getUrl().regex("https://github\\.com/(\\w+)/.*").toString());
    page.putField("name", page.getHtml().xpath("//h1[@class='entry-title public']/strong/a/text()").toString());
    if (page.getResultItems().get("name")==null){
        //设置skip之后，这个页面的结果不会被Pipeline处理
        page.setSkip(true);
    }
    page.putField("readme", page.getHtml().xpath("//div[@id='readme']/tidyText()"));
}

现在我们想将结果保存到控制台，要怎么做呢？[ConsolePipeline](https://github.com/code4craft/webmagic/blob/master/webmagic-
core/src/main/java/us/codecraft/webmagic/pipeline/ConsolePipeline.java)可以完成这个工作：

​

public class ConsolePipeline implements Pipeline {

    @Override
    public void process(ResultItems resultItems, Task task) {
        System.out.println("get page: " + resultItems.getRequest().getUrl());
        //遍历所有结果，输出到控制台，上面例子中的"author"、"name"、"readme"都是一个key，其结果则是对应的value
        for (Map.Entry<String, Object> entry : resultItems.getAll().entrySet()) {
            System.out.println(entry.getKey() + ":\t" + entry.getValue());
        }
    }
}

参考这个例子，你就可以定制自己的Pipeline了——从ResultItems中取出数据，再按照你希望的方式处理即可。

6.1.3 将结果保存到MySQL

这里先介绍一个demo项目：[jobhunter](https://github.com/webmagic-
io/jobhunter)。它是一个集成了Spring，使用WebMagic抓取招聘信息，并且使用Mybatis持久化到Mysql的例子。我们会用这个项目来介绍如果持久化到Mysql。

在Java里，我们有很多方式将数据保存到MySQL，例如jdbc、dbutils、spring-
jdbc、MyBatis等工具。这些工具都可以完成同样的事情，只不过功能和使用复杂程度不一样。如果使用jdbc，那么我们只需要从ResultItems取出数据，进行保存即可。

如果我们会使用ORM框架来完成持久化到MySQL的工作，就会面临一个问题：这些框架一般都要求保存的内容是一个定义好结构的对象，而不是一个key-
value形式的ResultItems。以MyBatis为例，我们使用MyBatis-
Spring可以定义这样一个DAO：

​

public interface JobInfoDAO {

    @Insert("insert into JobInfo (`title`,`salary`,`company`,`description`,`requirement`,`source`,`url`,`urlMd5`) values (#{title},#{salary},#{company},#{description},#{requirement},#{source},#{url},#{urlMd5})")
    public int add(LieTouJobInfo jobInfo);
}

我们要做的，就是实现一个Pipeline，将ResultItems和LieTouJobInfo对象结合起来。

注解模式

注解模式下，WebMagic内置了一个[PageModelPipeline](https://github.com/code4craft/webmagic/blob/master/webmagic-
extension/src/main/java/us/codecraft/webmagic/pipeline/PageModelPipeline.java)：

​

public interface PageModelPipeline<T> {

    //这里传入的是处理好的对象
    public void process(T t, Task task);

}

这时，我们可以很优雅的定义一个[JobInfoDaoPipeline](https://github.com/webmagic-
io/jobhunter/blob/master/src/main/java/us/codecraft/jobhunter/pipeline/JobInfoDaoPipeline.java)，来实现这个功能：

​

@Component("JobInfoDaoPipeline")
public class JobInfoDaoPipeline implements PageModelPipeline<LieTouJobInfo> {

    @Resource
    private JobInfoDAO jobInfoDAO;

    @Override
    public void process(LieTouJobInfo lieTouJobInfo, Task task) {
        //调用MyBatis DAO保存结果
        jobInfoDAO.add(lieTouJobInfo);
    }
}
基本Pipeline模式

至此，结果保存就已经完成了！那么如果我们使用原始的Pipeline接口，要怎么完成呢？其实答案也很简单，如果你要保存一个对象，那么就需要在抽取的时候，将它保存为一个对象：

​

public void process(Page page) {
    page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+/\\w+)").all());
    page.addTargetRequests(page.getHtml().links().regex("(https://github\\.com/\\w+)").all());
    GithubRepo githubRepo = new GithubRepo();
    githubRepo.setAuthor(page.getUrl().regex("https://github\\.com/(\\w+)/.*").toString());
    githubRepo.setName(page.getHtml().xpath("//h1[@class='entry-title public']/strong/a/text()").toString());
    githubRepo.setReadme(page.getHtml().xpath("//div[@id='readme']/tidyText()").toString());
    if (githubRepo.getName() == null) {
        //skip this page
        page.setSkip(true);
    } else {
        page.putField("repo", githubRepo);
    }
}

在Pipeline中，只要使用

​

GithubRepo githubRepo = (GithubRepo)resultItems.get("repo");

就可以获取这个对象了。

PageModelPipeline实际上也是通过原始的Pipeline来实现的，它将与PageProcessor进行了整合，在保存时，使用类名作为key，而对象则是value，具体实现见：[ModelPipeline](https://github.com/code4craft/webmagic/blob/master/webmagic-
extension/src/main/java/us/codecraft/webmagic/model/ModelPipeline.java)。

6.1.4 WebMagic已经提供的几个Pipeline

WebMagic中已经提供了将结果输出到控制台、保存到文件和JSON格式保存的几个Pipeline：

类说明备注
ConsolePipeline输出结果到控制台抽取结果需要实现toString方法
FilePipeline保存结果到文件抽取结果需要实现toString方法
JsonFilePipelineJSON格式保存结果到文件
ConsolePageModelPipeline(注解模式)输出结果到控制台
FilePageModelPipeline(注解模式)保存结果到文件
JsonFilePageModelPipeline(注解模式)JSON格式保存结果到文件想要持久化的字段需要有getter方法

6.2 使用和定制Scheduler

Scheduler是WebMagic中进行URL管理的组件。一般来说，Scheduler包括两个作用：

1. 对待抓取的URL队列进行管理。
2. 对已抓取的URL进行去重。

WebMagic内置了几个常用的Scheduler。如果你只是在本地执行规模比较小的爬虫，那么基本无需定制Scheduler，但是了解一下已经提供的几个Scheduler还是有意义的。

类说明备注
DuplicateRemovedScheduler抽象基类，提供一些模板方法继承它可以实现自己的功能
QueueScheduler使用内存队列保存待抓取URL
PriorityScheduler使用带有优先级的内存队列保存待抓取URL

耗费内存较QueueScheduler更大，但是当设置了request.priority之后，只能使用PriorityScheduler才可使优先级生效
FileCacheQueueScheduler | 使用文件保存抓取URL，可以在关闭程序并下次启动时，从之前抓取到的URL继续抓取 |
需指定路径，会建立.urls.txt和.cursor.txt两个文件
RedisScheduler | 使用Redis保存抓取队列，可进行多台机器同时合作抓取 | 需要安装并启动redis

在0.5.1版本里，我对Scheduler的内部实现进行了重构，去重部分被单独抽象成了一个接口：DuplicateRemover，从而可以为同一个Scheduler选择不同的去重方式，以适应不同的需要，目前提供了两种去重方式。

类说明
HashSetDuplicateRemover使用HashSet来进行去重，占用内存较大
BloomFilterDuplicateRemover使用BloomFilter来进行去重，占用内存较小，但是可能漏抓页面

所有默认的Scheduler都使用HashSetDuplicateRemover来进行去重，（除开RedisScheduler是使用Redis的set进行去重）。如果你的URL较多，使用HashSetDuplicateRemover会比较占用内存，所以也可以尝试以下BloomFilterDuplicateRemover1，使用方式：

​

spider.setScheduler(new QueueScheduler()
.setDuplicateRemover(new BloomFilterDuplicateRemover(10000000)) //10000000是估计的页面数量
)
  1. 0.6.0版本后，如果使用BloomFilterDuplicateRemover，需要单独引入Guava依赖包。 ↩

6.3 使用和定制Downloader

WebMagic的默认Downloader基于HttpClient。一般来说，你无须自己实现Downloader，不过HttpClientDownloader也预留了几个扩展点，以满足不同场景的需求。

另外，你可能希望通过其他方式来实现页面下载，例如使用SeleniumDownloader来渲染动态页面。

附录：实例分析

即使你对WebMagic的框架已经很熟练了，也会对有些爬虫的编写有些迷茫。比如如何定期抓取并更新、如何抓取动态渲染的页面等。

这一节我会整理一些常见案例，希望对读者有帮助。

狴犴ys
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java爬虫框架WebMagic的使用总结
爱分享的淘金达人
02-27 2万+
最近，项目做一个公司新闻网站，分为PC&移动端(h5)，数据来源是从HSZX与huanqiu2个网站爬取，主要使用Java编写的WebMagic作为爬虫框架，数据分为批量抓取、增量抓取，批量抓当前所有历史数据，增量需要每10分钟定时抓取一次，由于从2个网站抓取，并且频道很多，数据量大，更新频繁；开发过程中遇到很多的坑，今天腾出时间，感觉有必要做以总结。 工具说明： 1
WebMagic快速入门
weixin_45829957的博客
01-09 3943
一、WebMagic介绍 WebMagic的结构分为Downloader、PageProcessor、Scheduler、Pipeline四大组件，并由Spider将它们彼此组织起来。这四大组件对应爬虫生命周期中的下载、处理、管理和持久化等功能。WebMagic的设计参考了Scapy，但是实现方式更Java化一些。 而Spider则将这几个组件组织起来，让它们可以互相交互，流程化的执行，可以认为Spider是一个大的容器，它也是WebMagic逻辑的核心。 1.1 WebMagic的四个组件 1
WebMagic介绍
尚凯辉的博客
03-22 2176
文章目录WebMagic是什么?架构介绍WebMagic的四个组件DownloaderPageProcessorSchedulerPipeline用于数据流转的对象#RequestRequestPageResultItems如何使用引入pom依赖demo案例实现WebMagicAPI介绍实现PageProcessor接口抽取元素SelectableAPI抽取元素API获取结果API获取链接使用Pi...
webmagic的所有jar包
11-26
webmagic的所需要的所有jar包，最新的，0.6.0版本的。
webmagic全套资料(包含最新版 jar包，源代码，中文文档)
11-11
是webmagic爬虫框架的最新全套资料，学习java爬虫必备资料。（包括jar包，源代码，源代码中有样例，中文文档说明等）
webmagic 中文开发文档
12-10
webmagic的中文文档，里面详细的介绍了webmagic的各个模块的知识点和简单的例子
爬虫webmagic中文资料
08-12
爬虫webmagic中文资料
webmagic入门demo
11-21
WebMagic是一个强大的、Java编写的网页抓取框架，它的设计目标是使网页抓取变得简单。...如果你遇到任何问题，可以参考官方文档或者社区资源，如提到的博客链接，那里有更多关于WebMagic的详细教程和解决方案。
webmagic0.5.2.rar
04-11
要深入了解WebMagic，可以参考其官方文档、GitHub上的源码以及相关的技术博客和教程。此外，参与社区讨论和实践项目也是快速提升的好方法。 8. **扩展性** WebMagic的模块化设计使其易于扩展，可以添加自定义的...
【web指纹识别】whatweb简介、使用方法、命令选项
05-16 6073
【web指纹识别工具】whatweb
webmagic中文教程（在线教程word版）
01-12
java爬虫webmagic的word版教程最新版（2016-1-12），来自其中文网站：http://webmagic.io/docs/zh
WebMagic爬虫技术
04-26
简单的通过webMagic技术来进行数据的爬取，通过服务端请求数据，后台进行爬取别的网站上数据返回并显示
基于webmagic的爬虫小应用--爬取知乎用户信息
热门推荐
码蚁君
05-03 1万+
最近跟舍友@小疯一起研究爬虫 他写了个小应用-CSDN博客爬虫 有兴趣的朋友可以点进去看看哦~ 一起学习。 一起进步。 想要源代码的朋友点击这里下载哦~ 听到“爬虫”，是不是第一时间想到python/php ？ 多少想玩爬虫的java学习者就因为语言不通而止步。Java是真的不能做爬虫吗？ 当然不是。 只不过python的3行代码能解决的问题，而Java要30行。
java网络爬虫框架:Webmagic学习总结
lilei的博客
05-04 2403
网络爬虫常用的技术(Java) 底层实现Jsoup+HttpClient 开源框架Webmagic Webmagic是一个开源的爬虫框架,用于简化爬虫的开发流程,使开发者更专注与业务逻辑的开发. 主要特色: 完全模块化的设计,强大的扩展性. 核心简单但是涵盖爬虫的全部流程,灵活而强大 提供丰富的抽取页面API 无配置,但是可通过POJO+注解形式实现一个爬虫 支持多线程 支持分布式 支持爬虫...
WebMagic(二)----抓取CSDN博客、并打印
tony的专栏
03-12 2492
新建一个Maven项目、在pom文件中加入WebMagic必须的一些jar包. 测试类: [html] view plain copy public class App implements PageProcessor   {       private Site site = Site.me().setSlee
Java利用springboot+WebMagic爬取招聘网信息并保存到mysql案例
Mark的博客
05-18 1714
Java利用springboot+WebMagic爬取招聘网信息并保存到mysql中案例 WebMagic 简介： webmagic是一个开源的Java垂直爬虫框架，目标是简化爬虫的开发流程，让开发者专注于逻辑功能的开发。webmagic主要由Downloader（下载器）、PageProcesser（解析器）、Schedule（调度器）和Pipeline（管道）四部分组成。 该案例的工程目录结构...
分布式爬虫（Zookeeper+Redis+Spring+WebMgic+Dubbo）
qq_35362055的博客
04-09 755
Dpider 参考网上大佬的一张分布式爬虫的架构图，对其的一个实现。因为时间比较急，所以在某些地方跟原架构图不一样（有的省去了，有的用的其他技术），但总体架构是按照这个来的。文章很棒，推荐大家看一看！ 文章如下： 分布式爬虫系统设计、实现与实战：爬取京东、苏宁易购全网手机商品数据+MySQL、HBase存储 项目地址： GitHub/gasoliner/dpider 架构图如下: ...
webmagic
qq 117791303
01-19 468
http://webmagic.io/http://webmagic.io/docs/zh/
webmagic java
最新发布
09-26
WebMagic是一个简单灵活的Java爬虫框架，可以帮助开发者快速开发高效且易于维护的爬虫。通过WebMagic，你可以通过编写Java代码来定义爬取的规则，并提取出所需的数据。它支持多种爬取方式，包括使用HttpClient和Jsoup等工具进行数据获取和解析。你可以在WebMagic的官网（http://webmagic.io/）上找到详细的文档（http://webmagic.io/docs/zh/）和案例，这些资源可以帮助你更好地了解和使用WebMagic。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值