（10）Java爬虫框架webmagic学习笔记

红太狼 2022-04-04 05:58 605阅读 0赞

# Java爬虫框架webmagic学习笔记 #

参考自：[webmagic文档][webmagic]

## webmagic简介 ##

webmagic的github网址：[https://github.com/code4craft/webmagic][https_github.com_code4craft_webmagic]

**使用webmagic的原因：**

1.  webmagic是一个无须配置、便于二次开发的爬虫框架，它提供简单灵活的API，只需少量代码即可实现一个爬虫。
2.  webmagic采用完全模块化的设计，功能覆盖整个爬虫的生命周期(链接提取、页面下载、内容抽取、持久化)，支持多线程抓取，分布式抓取，url自动去重，并支持自动重试、自定义UA/cookie等功能。
3.  webmagic包含强大的页面抽取功能，开发者可以便捷的使用css selector、xpath和正则表达式进行链接和内容的提取，支持多个选择器链式调用。
4.  webmagic也可以很方便的作为一个模块，嵌入Java项目中运行。
5.  文档相对齐全。

**webmagic的主要特色：**

*  完全模块化的设计，强大的可扩展性。
 *  核心简单但是涵盖爬虫的全部流程，灵活而强大，也是学习爬虫入门的好材料。
 *  提供丰富的抽取页面API。
 *  无配置，但是可通过POJO+注解形式实现一个爬虫。
 *  支持多线程。
 *  支持分布式。
 *  支持爬取js动态渲染的页面。
 *  无框架依赖，可以灵活的嵌入到项目中去。

## 总体架构 ##

WebMagic的结构分为`Downloader`、`PageProcessor`、`Scheduler`、`Pipeline`四大组件，并由Spider将它们彼此组织起来，让它们可以互相交互，流程化地执行。这四大组件对应爬虫生命周期中的下载、处理、管理和持久化等功能。

WebMagic总体架构图如下：

![image][]

### 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. 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处理。

## 使用maven安装webmagic框架 ##

webmagic使用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>

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

## 项目结构 ##

webmagic主要包括两个包：

*  **webmagic-core**
    
    webmagic核心部分，只包含爬虫基本模块和基本抽取器。webmagic-core的目标是成为网页爬虫的一个教科书般的实现。
 *  **webmagic-extension**
    
    webmagic的扩展模块，提供一些更方便的编写爬虫的工具。包括注解格式定义爬虫、JSON、分布式等支持。

webmagic还包含两个可用的扩展包，因为这两个包都依赖了比较重量级的工具，所以从主要包中抽离出来，这些包需要下载源码后自己编译：：

*  **webmagic-saxon**
    
    webmagic与Saxon结合的模块。Saxon是一个XPath、XSLT的解析工具，webmagic依赖Saxon来进行XPath2.0语法解析支持。
 *  **webmagic-selenium**
    
    webmagic与Selenium结合的模块。Selenium是一个模拟浏览器进行页面渲染的工具，webmagic依赖Selenium进行动态页面的抓取。

在项目中，你可以根据需要依赖不同的包。

## 通过PageProcessor实现基本的爬虫 ##

PageProcessor的定制分为三个部分，分别是爬虫的配置、页面元素的抽取和链接的发现。

public class GithubRepoPageProcessor implements PageProcessor {
    
        // 部分一：抓取网站的相关配置，包括编码、抓取间隔、超时时间、重试次数等，也包括一些模拟的参数，例如User Agent、cookie，以及代理的设置
        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();
        }
    }

### **1. 配置Site** ###

通过设置`Site`对象来配置爬虫的编码、抓取间隔、超时时间、重试次数等，以及一些模拟的参数，例如User Agent、cookie，和代理的设置等。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>setCharset(String)</td> 
   <td>设置编码</td> 
   <td>site.setCharset(“utf-8”)</td> 
  </tr> 
  <tr> 
   <td>setUserAgent(String)</td> 
   <td>设置UserAgent</td> 
   <td>site.setUserAgent(“Spider”)</td> 
  </tr> 
  <tr> 
   <td>setTimeOut(int)</td> 
   <td>设置超时时间，单位是毫秒</td> 
   <td>site.setTimeOut(3000)</td> 
  </tr> 
  <tr> 
   <td>setRetryTimes(int)</td> 
   <td>设置重试次数</td> 
   <td>site.setRetryTimes(3)</td> 
  </tr> 
  <tr> 
   <td>setCycleRetryTimes(int)</td> 
   <td>设置循环重试次数</td> 
   <td>site.setCycleRetryTimes(3)</td> 
  </tr> 
  <tr> 
   <td>addCookie(String,String)</td> 
   <td>添加一条cookie</td> 
   <td>site.addCookie(“dotcomt_user”,“code4craft”)</td> 
  </tr> 
  <tr> 
   <td>setDomain(String)</td> 
   <td>设置域名，需设置域名后，addCookie才可生效</td> 
   <td>site.setDomain(“<a href="http://github.com" rel="nofollow">github.com</a>”)</td> 
  </tr> 
  <tr> 
   <td>addHeader(String,String)</td> 
   <td>添加一条addHeader</td> 
   <td>site.addHeader(“Referer”,“<a href="https://github.com/" rel="nofollow">https://github.com</a>”)</td> 
  </tr> 
  <tr> 
   <td>setHttpProxy(HttpHost)</td> 
   <td>设置Http代理</td> 
   <td>site.setHttpProxy(new HttpHost(“127.0.0.1”,8080))</td> 
  </tr> 
 </tbody> 
</table>

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

### 2. 抽取页面元素 ###

WebMagic里主要使用了三种抽取技术：XPath、正则表达式和CSS选择器。另外，对于JSON格式的内容，可使用JsonPath进行解析。

page.getHtml()返回的是一个`Html`对象，它实现了`Selectable`接口。使用`Selectable`接口，你可以直接完成页面元素的链式抽取，而无需去关心抽取的细节。这个接口的方法可分为两类：抽取元素API和获取结果API。

#### 抽取元素API ####

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>xpath(String xpath)</td> 
   <td>使用XPath选择</td> 
   <td>html.xpath("//div[@class=‘title’]")</td> 
  </tr> 
  <tr> 
   <td>$(String selector)</td> 
   <td>使用Css选择器选择</td> 
   <td>html.$(“div.title”)</td> 
  </tr> 
  <tr> 
   <td>$(String selector,String attr)</td> 
   <td>使用Css选择器选择</td> 
   <td>html.$(“div.title”,“text”)</td> 
  </tr> 
  <tr> 
   <td>css(String selector)</td> 
   <td>功能同$()，使用Css选择器选择</td> 
   <td>html.css(“div.title”)</td> 
  </tr> 
  <tr> 
   <td>links()</td> 
   <td>选择所有链接</td> 
   <td>html.links()</td> 
  </tr> 
  <tr> 
   <td>regex(String regex)</td> 
   <td>使用正则表达式抽取</td> 
   <td>html.regex("&lt;div&gt;(.*?)")&lt;/div&gt;</td> 
  </tr> 
  <tr> 
   <td>regex(String regex,int group)</td> 
   <td>使用正则表达式抽取，并指定捕获组</td> 
   <td>html.regex("&lt;div&gt;(.*?)",1)&lt;/div&gt;</td> 
  </tr> 
  <tr> 
   <td>replace(String regex, String replacement)</td> 
   <td>替换内容</td> 
   <td>html.replace("","")</td> 
  </tr> 
 </tbody> 
</table>

抽取元素API返回的都是一个`Selectable`接口，意思是说，抽取是支持链式调用的。

#### 获取结果API ####

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

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

### 3. 链接的发现 ###

发现后续的链接，是一个爬虫不可缺少的一部分。

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

`page.addTargetRequests()`用于将新链接加入到待抓取的队列中去。

### 4. 启动爬虫Spider ###

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

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>create(PageProcessor)</td> 
   <td>创建Spider</td> 
   <td>Spider.create(new GithubRepoProcessor())</td> 
  </tr> 
  <tr> 
   <td>addUrl(String…)</td> 
   <td>添加初始的URL</td> 
   <td>spider .addUrl(“<a href="http://webmagic.io/docs/" rel="nofollow">http://webmagic.io/docs/</a>”)</td> 
  </tr> 
  <tr> 
   <td>addRequest(Request…)</td> 
   <td>添加初始的Request</td> 
   <td>spider .addRequest(“<a href="http://webmagic.io/docs/" rel="nofollow">http://webmagic.io/docs/</a>”)</td> 
  </tr> 
  <tr> 
   <td>thread(n)</td> 
   <td>开启n个线程</td> 
   <td>spider.thread(5)</td> 
  </tr> 
  <tr> 
   <td>run()</td> 
   <td>启动，会阻塞当前线程执行</td> 
   <td>spider.run()</td> 
  </tr> 
  <tr> 
   <td>start()/runAsync()</td> 
   <td>异步启动，当前线程继续执行</td> 
   <td>spider.start()</td> 
  </tr> 
  <tr> 
   <td>stop()</td> 
   <td>停止爬虫</td> 
   <td>spider.stop()</td> 
  </tr> 
  <tr> 
   <td>test(String)</td> 
   <td>抓取一个页面进行测试</td> 
   <td>spider .test(“<a href="http://webmagic.io/docs/" rel="nofollow">http://webmagic.io/docs/</a>”)</td> 
  </tr> 
  <tr> 
   <td>addPipeline(Pipeline)</td> 
   <td>添加一个Pipeline，一个Spider可以有多个Pipeline</td> 
   <td>spider .addPipeline(new ConsolePipeline())</td> 
  </tr> 
  <tr> 
   <td>setScheduler(Scheduler)</td> 
   <td>设置Scheduler，一个Spider只能有个一个Scheduler</td> 
   <td>spider.setScheduler(new RedisScheduler())</td> 
  </tr> 
  <tr> 
   <td>setDownloader(Downloader)</td> 
   <td>设置Downloader，一个Spider只能有个一个Downloader</td> 
   <td>spider .setDownloader(new SeleniumDownloader())</td> 
  </tr> 
  <tr> 
   <td>get(String)</td> 
   <td>同步调用，并直接取得结果</td> 
   <td>ResultItems result = spider .get(“<a href="http://webmagic.io/docs/" rel="nofollow">http://webmagic.io/docs/</a>”)</td> 
  </tr> 
  <tr> 
   <td>getAll(String…)</td> 
   <td>同步调用，并直接取得一堆结果</td> 
   <td>List results = spider .getAll(“<a href="http://webmagic.io/docs/" rel="nofollow">http://webmagic.io/docs/</a>”, “<a href="http://webmagic.io/xxx" rel="nofollow">http://webmagic.io/xxx</a>”)</td> 
  </tr> 
 </tbody> 
</table>

### 5. 使用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();
    }

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

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

### 6. 处理非HTTP GET请求 ###

采用在Request对象上添加Method和`requestBody`来实现POST请求。

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

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

<table> 
 <thead> 
  <tr> 
   <th>API</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HttpRequestBody.form(Map&lt;string,object&gt; params, String encoding)</td> 
   <td>使用表单提交的方式</td> 
  </tr> 
  <tr> 
   <td>HttpRequestBody.json(String json, String encoding)</td> 
   <td>使用JSON的方式，json是序列化后的结果</td> 
  </tr> 
  <tr> 
   <td>HttpRequestBody.xml(String xml, String encoding)</td> 
   <td>设置xml的方式，xml是序列化后的结果</td> 
  </tr> 
  <tr> 
   <td>HttpRequestBody.custom(byte[] body, String contentType, String encoding)</td> 
   <td>设置自定义的requestBody</td> 
  </tr> 
 </tbody> 
</table>

### 使用Scheduler ###

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

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

WebMagic内置了几个常用的Scheduler。

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>说明</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DuplicateRemovedScheduler</td> 
   <td>抽象基类，提供一些模板方法</td> 
   <td>继承它可以实现自己的功能</td> 
  </tr> 
  <tr> 
   <td>QueueScheduler</td> 
   <td>使用内存队列保存待抓取URL</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>PriorityScheduler</td> 
   <td>使用带有优先级的内存队列保存待抓取URL</td> 
   <td>耗费内存较QueueScheduler更大，但是当设置了request.priority之后，只能使用PriorityScheduler才可使优先级生效</td> 
  </tr> 
  <tr> 
   <td>FileCacheQueueScheduler</td> 
   <td>使用文件保存抓取URL，可以在关闭程序并下次启动时，从之前抓取到的URL继续抓取</td> 
   <td>需指定路径，会建立.urls.txt和.cursor.txt两个文件</td> 
  </tr> 
  <tr> 
   <td>RedisScheduler</td> 
   <td>使用Redis保存抓取队列，可进行多台机器同时合作抓取</td> 
   <td>需要安装并启动redis</td> 
  </tr> 
 </tbody> 
</table>

## 使用注解编写爬虫 ##

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

在注解模式下，使用一个简单对象加上注解，可以用极少的代码量就完成一个爬虫的编写。

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

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

### 定义Model类来实现爬虫 ###

定义一个Model类来抽取一个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();
        }
    }

#### 1. 定义抓取的Url ####

`HelpUrl/TargetUrl`是一个非常有效的爬虫开发模式，TargetUrl是我们最终要抓取的URL，最终想要的数据都来自这里；而HelpUrl则是为了发现这个最终URL，我们需要访问的页面。WebMagic定制了适合`HelpUrl/TargetUrl`的URL的正则表达式，主要有两点改动：

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

#### 2. 抽取页面元素 ####

`@ExtractBy`是一个用于抽取元素的注解，它描述了一种抽取规则。@ExtractBy注解主要作用于字段，它表示“使用这个抽取规则，将抽取到的结果保存到这个字段中”。

`@ExtractByUrl`是一个单独的注解，它的意思是“从URL中进行抽取”。它只支持正则表达式作为抽取规则。

#### 3. 爬虫的创建和启动 ####

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

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

#### 4. 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。

### Formatter类型转换 ###

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

自动转换支持所有基本类型和装箱类型。另外，还支持`java.util.Date`类型的转换。但是在转换时，需要指定Date的格式。格式按照JDK的标准来定义。

@Formatter("yyyy-MM-dd HH:mm")
    @ExtractBy("//div[@class='BlogStat']/regex('\\d+-\\d+-\\d+\\s+\\d+:\\d+')")
    private Date date;

#### 显式指定转换类型 ####

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

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

#### 自定义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;

### AfterExtractor ###

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

public interface AfterExtractor {
        public void afterProcess(Page page);
    }

`afterProcess`方法会在抽取结束，字段都初始化完毕之后被调用，可以处理一些特殊的逻辑。

//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]: http://webmagic.io/docs/zh/
[https_github.com_code4craft_webmagic]: https://github.com/code4craft/webmagic
[image]: /images/20220404/2f60ae0a74cc4ed3912d0317b2d72945.png
[Apache HttpClient]: http://hc.apache.org/index.html
[Jsoup]: http://jsoup.org/
[Xsoup]: https://github.com/code4craft/xsoup