使用手册

一、Gecco是什么

Gecco是一款用java语言开发的轻量化的易用的网络爬虫，不同于Nutch这样的面向搜索引擎的通用爬虫，Gecco是面向主题的爬虫。

通用爬虫一般关注三个主要的问题：下载、排序、索引。
主题爬虫一般关注的是：下载、内容抽取、灵活的业务逻辑处理。

Gecco的目标是提供一个完善的主题爬虫框架，简化下载和内容抽取的开发，利用管道过滤器模式，提供灵活的内容清洗和持久化处理模式，让开发人员把更多的精力投入到与业务主题相关的内容处理上。

主要特征

简单易用，使用jquery的selector风格抽取元素
支持页面中的异步ajax请求
支持页面中的javascript变量抽取
利用Redis实现分布式抓取,参考gecco-redis
支持下载时UserAgent随机选取
支持下载代理服务器随机选取
支持结合Spring开发业务逻辑,参考gecco-spring
支持htmlunit扩展,参考gecco-htmlunit
支持插件扩展机制

二、一分钟你就可以写一个简单爬虫

示例代码

这里用抓取gecco这个项目的首页为例。我们希望得到项目的作者名称，项目名称，项目的star和fork数量，以及项目的介绍。如果你稍有java基础，会写jquery的css selector我相信下面的代码我不需要解释你也能轻松的看明白。

    @Gecco(matchUrl="https://github.com/{user}/{project}", pipelines="consolePipeline")
    public class MyGithub implements HtmlBean {

        private static final long serialVersionUID = -7127412585200687225L;

        @RequestParameter("user")
        private String user;

        @RequestParameter("project")
        private String project;

        @Text
        @HtmlField(cssPath=".repository-meta-content")
        private String title;

        @Text
        @HtmlField(cssPath=".pagehead-actions li:nth-child(2) .social-count")
        private int star;

        @Text
        @HtmlField(cssPath=".pagehead-actions li:nth-child(3) .social-count")
        private int fork;

        @Html
        @HtmlField(cssPath=".entry-content")
        private String readme;

        public String getReadme() {
            return readme;
        }

        public void setReadme(String readme) {
            this.readme = readme;
        }

        public String getUser() {
            return user;
        }

        public void setUser(String user) {
            this.user = user;
        }

        public String getProject() {
            return project;
        }

        public void setProject(String project) {
            this.project = project;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public int getStar() {
            return star;
        }

        public void setStar(int star) {
            this.star = star;
        }

        public int getFork() {
            return fork;
        }

        public void setFork(int fork) {
            this.fork = fork;
        }

        public static void main(String[] args) {
            GeccoEngine.create()
            //Gecco搜索的包路径
            .classpath("com.geccocrawler.gecco.demo")
            //开始抓取的页面地址
            .start("https://github.com/xtuhcy/gecco")
            //开启几个爬虫线程
            .thread(1)
            //单个爬虫每次抓取完一个请求后的间隔时间
            .interval(2000)
            .start();
        }
    }

代码说明

接口HtmlBean说明该爬虫是一个解析html页面的爬虫（gecco还支持json格式的解析）
注解@Gecco告知该爬虫匹配的url格式(matchUrl)和内容抽取后的bean处理类（pipelines处理类采用管道过滤器模式，可以定义多个处理类）。
注解@RequestParameter可以注入url中的请求参数，如@RequestParameter("user")表示匹配url中的{user}
注解@HtmlField表示抽取html中的元素，cssPath采用类似jquery的css selector选取元素
注解@Text表示获取@HtmlField抽取出来的元素的text内容
注解@Html表示获取@HtmlField抽取出来的元素的html内容（如果不指定默认为@Html）
GeccoEngine表示爬虫引擎，通过create()初始化，通过start()/run()运行。可以配置一些启动参数如：扫描@Gecco注解的包名classpath；开始抓取的url地址star；抓取线程数thread；抓取完一个页面后的间隔时间interval(ms)等

三、软件总体结构

基本构件介绍

GeccoEngine

GeccoEngine是爬虫引擎，每个爬虫引擎最好是一个独立进程，在分布式爬虫场景下，建议每台爬虫服务器（物理机或者虚机）运行一个GeccoEngine。爬虫引擎包括主要Scheduler、Downloader、Spider、SpiderBeanFactory、PipelineFactory5个主要模块。

Scheduler

Downloader

Downloader负责从Scheduler中获取需要下载的请求，gecco默认采用httpclient4.x作为下载引擎。通过实现Downloader接口可以自定义自己的下载引擎。你也可以对每个请求定义BeforeDownload和AfterDownload，实现不同的请求下载的个性需求。

SpiderBeanFactory

Gecco将下载下来的内容渲染为SpiderBean，所有爬虫渲染的JavaBean都统一继承SpiderBean，SpiderBean又分为HtmlBean和JsonBean分别对应html页面的渲染和json数据的渲染。SpiderBeanFactroy会根据请求的url地址，匹配相应的SpiderBean，同时生成该SpiderBean的上下文SpiderBeanContext。上下文SpiderBeanContext会告知这个SpiderBean采用什么渲染器，采用那个下载器，渲染完成后采用哪些pipeline处理等相关上下文信息。

PipelineFactory

pipeline是SpiderBean渲染完成的后续业务处理单元，PipelineFactory是pipeline的工厂类，负责pipeline实例化。通过扩展PipelineFactory就可以实现和Spring等业务处理框架的整合。

Spider

Gecco框架最核心的类应该是Spider线程，一个爬虫引擎可以同时运行多个Spider线程。Spider描绘了这个框架运行的基本骨架，先从Scheduler获取请求，再通过SpiderBeanFactory匹配SpiderBeanClass，再通过SpiderBeanClass找到SpiderBean的上下文，下载网页并对SpiderBean做渲染，将渲染后的SpiderBean交个pipeline处理。

四、GeccoEngine

Gecco如何运行

Gecco的初始化和启动通过GeccoEngine完成，GeccoEngine主要负责初始化配置、开始请求的配置和启动爬虫运行，最基本的启动方法：

GeccoEngine.create()
    .classpath("com.geccocrawler.gecco.demo")
    .start("https://github.com/xtuhcy/gecco")
    .start();

classpath是必填项，指定扫描@Gecco的包路径。start是初始请求地址。start()表示采用非阻塞方式运行爬虫。

GeccoEngine基本配置项

loop(true)：表示是否循环抓取，默认为false
thread(2)：表示开启的爬虫线程数量，默认是1，需要注意的是线程数量要小于或者等于start请求的数量
interval(2000)：表示某个线程在抓取完成一个请求后的间隔时间，单位是毫秒，系统会在左右1秒时间内随机。如果为2000，系统会在1000～3000之间随机选取。
mobile(false)：表示使用移动端还是pc端的UserAgent。默认为false使用pc端的UserAgent。
debug(true)：是否开启debug模式，如果开启debug模式，会在控制台输出jsoup元素抽取的日志。
pipelineFactory(PipelineFactory)：自定义Pipeline工厂类
scheduler(Scheduler)：自定义请求队列管理器

非阻塞启动和阻塞启动

start()：非阻塞启动，GeccoEngine会单独启动线程运行，推荐以该方式运行。线程模型如下：

Main Thread-->GeccoEngine Thread-->Spider Thread

run()：阻塞启动，GeccoEngine在主线程中启动运行，非循环模式GeccoEngine需要等待其他爬虫线程运行完毕后才会退出。线程模型r如下：

Main Thread-->Spider Thread

Gecco如何匹配URL

匹配URL的作用

匹配URL是告知Gecco，这种格式的url对应的网页会被渲染成当前的SpiderBean。

matchUrl如何写

完全匹配：@Gecco(matchUrl="https://github.com/"),完全匹配https://github.com/这个url

模糊匹配：@Gecco(matchUrl="https://github.com/{user}/{project}")，会匹配所有类似格式的url，https://github.com/xtuhcy/gecco、https://github.com/xtuhcy/gecco-spring。模糊匹配的{}可以匹配任意非空白字符串但是不包含斜杠(/

任意匹配：@Gecco，如果你不写matchUrl，任何格式的url都会被匹配，这种方式一般用作通用爬虫，例如：

@Gecco(pipelines="consolePipeline")
public class CommonCrawler implements HtmlBean {

    private static final long serialVersionUID = -8870768223740844229L;

    @Request
    private HttpRequest request;

    @HtmlField(cssPath="body")
    private String body;

    public HttpRequest getRequest() {
        return request;
    }

    public void setRequest(HttpRequest request) {
        this.request = request;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public static void main(String[] args) {
        GeccoEngine.create()
        .classpath("com.geccocrawler.gecco.demo")
        .start("https://www.baidu.com/")
        .interval(2000)
        .start();
    }
}

五、从下载说起

一、下载引擎

爬虫最基本的能力就是发起http请求，下载网页，gecco默认采用httpclient4作为下载引擎。通过实现Downloader接口可以自定义自己的下载引擎，在启动GeccoEngine时需要设置自己的下载引擎。下面的代码不是使用默认的httpclient作为下载引擎，而是使用htmlUnit作为下载引擎。

@Gecco(matchUrl="https://github.com/{user}/{project}", pipelines="consolePipeline", downloader="htmlUnitDownloder")

二、HttpRequest和HttpResponse

HttpRequest表示下载请求，HttpResponse表示下载响应。爬虫下载网页都会模拟浏览器包装成GET或者POST请求，HttpGetRequest和HttpPostRequest分别对应GET和POST请求。

gecco的请求支持模拟userAgent，并且支持userAgent的随机轮询，在calsspath的根目录下定义userAgents文件，每行表示一个UserAgent； - gecco支持cookie定义，request.addCookie()，可以模拟用户登录; - gecco支持代理服务器的随机轮询，在classpath的根目录下定义proxys文件，每行表示一个代理服务器的主机和端口，如127.0.0.1:8888；

三、下载地址管理

通常爬虫需要一个有效管理下载地址的角色，Scheduler负责下载地址的管理。gecco对初始地址的管理使用StartScheduler，StartScheduler内部采用一个阻塞的FIFO的队列。初始地址通常会派生出很多其他待抓取的地址，派生出来的其他地址采用SpiderScheduler进行管理，SpiderScheduler内部采用线程安全的非阻塞FIFO队列。这种设计使的gecco对初始地址采用了深度遍历的策略，即一个线程抓取完一个初始地址后才会去抓取另外一个初始地址；对初始地址派生出来的地址，采用广度优先策略，派生地址的获取会在下面详细说明。另外，gecco的分布式抓取也是通过Scheduler来完成了，准确的说是通过实现不同的StartScheduler来将初始地址分配到不同的服务器中来完成的。gecco的分布式抓取默认采用redis来实现，具体可以参考gecco-redis项目。

GeccoEngine.create().scheduler(new RedisStartScheduler("127.0.0.1:6379"))

四、初始地址和派生地址

爬虫通常会从若干个初始地址开始爬取网页，爬取下来的网页可能包含其他需要继续抓取的页面，典型的例子是列表页和详情页。列表页作为初始地址，抓取完成后需要针对每个列表项再抓取对应的详情页。gecco派生地址的方式有两种：一种是通过注解@Href(click=true)，click为true时，抽取出来的url会继续抓取，如：

@Href(click=true)
@HtmlField(cssPath=".tm-qx-nrBox a")
private String detailUrl;

还一种是显式的加入SpiderScheduler的方法，如：

SchedulerContext.into(currRequest.subRequest("subUrl");

使用@Request注解可以获得当前HttpRequest对象，使用当前request的subRequest方法生成派生地址的请求，这样在相应的pipeline类中即可控制派生请求的增加。

五、多个初始地址的配置

通过在classpath的根目录下放置配置文件starts.json可以配置多个初始地址，如下：

[
    {
        "charset": "GBK",
        "url": "http://item.jd.com/1455427.html"
    },
    {
        "url": "https://github.com/xtuhcy/gecco"
    }
]

六、BeforeDownload和AfterDownload

一些特殊的场景，可能会需要在下载前做下载的预处理和在下载后做特定的处理，之后再传递给pipeline进行处理，这时需要实现BeforeDownload和AfterDownload。如：

@GeccoClass(CruiseDetail.class)
public class CruiseDetailBeforeDownload implements BeforeDownload {
    @Override
    public void process(HttpRequest request) {

    }
}

上面的类针对CruiseDetail这个bean的下载前会做自定义的处理。

@GeccoClass(CruiseRedirect.class)
public class CruiseRedirectAfterDownload implements AfterDownload {

    @Override
    public void process(HttpRequest request, HttpResponse response) {

    }

}

上面这个类会对CruiseRedirect这个bean做下载后的自定义处理。

七、使用httpUnit作为下载引擎

gecco通过扩展downloader实现了对htmlunit的支持。htmlunit是一款开源的java 页面分析工具，读取页面后，可以有效的使用htmlunit分析页面上的内容。项目可以模拟浏览器运行，被誉为java浏览器的开源实现。这个没有界面的浏览器，运行速度也是非常迅速的。htmlunit采用的是rhino作为javascript的解析引擎。

下载

<dependency>
    <groupId>com.geccocrawler</groupId>
    <artifactId>gecco-htmlunit</artifactId>
    <version>x.x.x</version>
</dependency>

优缺点

使用htmlunit确实能省去很多工作，但是htmlunit也存在很多弊端：

1、效率低下，使用htmlunit后，下载器要将所有js一并下载下来，同时要执行所有js代码，下载一个页面有时需要5～10秒。

2、rhino引擎对js的兼容问题，rhino的兼容性还是存在不少问题的，上述demo就有很多js执行错误。如果大家在抓取时不想看到这些error日志输出可以配置log4j：

log4j.logger.com.gargoylesoftware.htmlunit=OFF

3、使用selenium也可以达到类似目的，selenium本身并不解析js，通过调用不同的浏览器驱动达到模拟浏览器的目的。selenium支持chrome、IE、firefox等多个真实浏览器驱动，也支持htmlunit作为驱动，还支持PhantomJS这种js开发的驱动。

六、抽取页面内容

gecco的内容抽取都是直接映射到java bean的属性中，利用注解可以方便的注入页面中的各种信息包括html页面内容、Ajax请求、javascript变量、request信息等

一、Html页面内容抽取

jsoup语法介绍

Selector选择器概述  
tagname: 通过标签查找元素，比如：a  
ns|tag: 通过标签在命名空间查找元素，比如：可以用 fb|name 语法来查找 <fb:name> 元素  
#id: 通过ID查找元素，比如：#logo
.class: 通过class名称查找元素，比如：.masthead
[attribute]: 利用属性查找元素，比如：[href]
[^attr]: 利用属性名前缀来查找元素，比如：可以用[^data-] 来查找带有HTML5 Dataset属性的元素
[attr=value]: 利用属性值来查找元素，比如：[width=500]
[attr^=value], [attr$=value], [attr*=value]: 利用匹配属性值开头、结尾或包含属性值来查找元素，比如：[href*=/path/]
[attr~=regex]: 利用属性值匹配正则表达式来查找元素，比如： img[src~=(?i)\.(png|jpe?g)]
*: 这个符号将匹配所有元素
Selector选择器组合使用  
el#id: 元素+ID，比如： div#logo  
el.class: 元素+class，比如： div.masthead  
el[attr]: 元素+class，比如： a[href]  
任意组合，比如：a[href].highlight
ancestor child: 查找某个元素下子元素，比如：可以用.body p 查找在"body"元素下的所有 p元素  
parent > child: 查找某个父元素下的直接子元素，比如：可以用div.content > p 查找 p 元素，也可以用body > * 查找body标签下所有直接子元素  
siblingA + siblingB: 查找在A元素之前第一个同级元素B，比如：div.head + div  
siblingA ~ siblingX: 查找A元素之前的同级X元素，比如：h1 ~ p  
el, el, el:多个选择器组合，查找匹配任一选择器的唯一元素，例如：div.masthead, div.logo  
伪选择器selectors
:lt(n): 查找哪些元素的同级索引值（它的位置在DOM树中是相对于它的父节点）小于n，比如：td:lt(3) 表示小于三列的元素
:gt(n):查找哪些元素的同级索引值大于n，比如： div p:gt(2)表示哪些div中有包含2个以上的p元素
:eq(n): 查找哪些元素的同级索引值与n相等，比如：form input:eq(1)表示包含一个input标签的Form元素
:has(seletor): 查找匹配选择器包含元素的元素，比如：div:has(p)表示哪些div包含了p元素
:not(selector): 查找与选择器不匹配的元素，比如： div:not(.logo) 表示不包含 class=logo 元素的所有 div 列表
:contains(text): 查找包含给定文本的元素，搜索不区分大不写，比如： p:contains(jsoup)
:containsOwn(text): 查找直接包含给定文本的元素
:matches(regex): 查找哪些元素的文本匹配指定的正则表达式，比如：div:matches((?i)login)
:matchesOwn(regex): 查找自身包含文本匹配指定正则表达式的元素
注意：上述伪选择器索引是从0开始的，也就是说第一个元素索引值为0，第二个元素index为1等

详细使用方式可以参考jsoup首页手册

@HtmlField

html属性定义，表示该属性是通过html查找解析，在html的渲染器下使用

cssPath：jquery风格的元素选择器，使用jsoup实现。jsoup在分析html方面提供了极大的便利。计划实现xpath风格的元素选择器。

@Href

表示该字段是一个链接类型的元素，jsoup会默认获取元素的href属性值。属性必须是String类型。

value：默认获取href属性值，可以多选，按顺序查找
click：表示是否点击打开，继续让爬虫抓取

@Image

表示该字段是一个图片类型的元素，jsoup会默认获取元素的src属性值。属性必须是String类型。

value：默认获取src属性值，可以多选，按顺序查找
download：表示是否需要将图片下载到本地

@Attr

获取html元素的attribute。属性支持java基本类型的自动转换。

value:表示属性名称

@Text

获取元素的text或者owntext。属性支持java基本类型的自动转换。

own:是否获取owntext，默认为是

@Html

默认类型，可以不写，获取html元素的整个节点内容。属性必须是String类型。

二、页面中的Ajax请求

现在的页面通常都会有很多ajax请求，很多主题爬虫在针对这种请求一般是使用htmlunit等类似的渲染引擎，将页面所有的信息都渲染完毕后交给爬虫处理，gecco可以通过实现自定义的downloader类来实现类似的方式。不过该方式会对整个页面都进行渲染，效率较低，很多时候你可能只需要某一个ajax请求就可以了。gecco实现了模拟ajax请求的定义，如：

@Ajax(url="http://p.3.cn/prices/mgets?skuIds=J_{code}")
private JDPrice price;

上述代码通过ajax方式获得jd商品的价格，{code}表示request中的属性值，使用[...]可以引用已经解析出来的html页面中的属性值。全部代码可以参考源码中的src/test/java/com/geccocrawler/gecco/demo/ajax

三、json格式内容的抽取

有ajax请求涉及到json格式的内容抽取，gecco除了支持html的内容抽取，同时也支持json内容的抽取

@JSONPath

使用fastjson的jsonpath，jsonpath类似是一种对象查询语言，能方便的查询json中个字段的值，详情请查看fastjson-jsonpath

@JSONPath("$.p[0]")
private float price;

四、页面中的javascript变量抽取

gecco支持抽取页面中的javascript全局变量的内容抽取。

@JSVar

var:表示变量名
jsonpath：如果变量是json格式的数据，通过定义jsonpath抽取需要的内容，如果不是json格式的数据可以不填

五、request信息的注入

@Request

将httpRequest信息注入到java bean中。

@RequestParameter

将url中定义的变量注入到java bean中。

六、自定义注解

通过实现CustomFieldRender接口可以实现自定义的注解。

@FieldRenderName("jdPricesFieldRender")
public class JdPricesFieldRender implements CustomFieldRender {
    /**
     * 
     * @param request HttpRequest
     * @param response HttpResponse
     * @param beanMap 将Field放入SpiderBean
     * @param bean 已经注入后的SpiderBean
     * @param field 需要注入的Field
     */
    public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean, Field field) {
        //获取需要注入的内容

        ...
        ...
        //进内容注入到对应的field中
        beanMap.put(field.getName(), prices);
    }
}

在SpiderBean中引入自定义的注解

public class ProductList implements HtmlBean {

    ...

    @FieldRenderName("jdPricesFieldRender")
    private List<JDPrice> prices;

    ...
}

七、业务逻辑处理

至此页面内容已经被gecco转换为一个普通的javabean。剩下的工作就是将javabean进一步清洗然后针对特定的业务逻辑进行持久化等处理。

一、实现pipeline接口

gecco采用管道过滤器模式灵活的实现业务逻辑处理，首先实现一个特定的管道过滤器，如：

@PipelineName("consolePipeline")
public class ConsolePipeline implements Pipeline<SpiderBean> {

    @Override
    public void process(SpiderBean bean) {
        System.out.println(JSON.toJSONString(bean));
    }

}

然后将定义的pipeline关联到对应的javabean中，如：

@Gecco(matchUrl="https://github.com/{user}/{project}", pipelines="consolePipeline")

二、结合spring开发业务逻辑

现在开发java服务器端应用已经基本离不开spring框架了，gecco实现了和spring框架的结合，请下载gecco-spring。

使用注解方式配置Spring

扫描com.geccocrawler.gecco.spring，自动注入springPipelineFactory和consolePipeline

<context:component-scan base-package="com.geccocrawler.gecco.spring" />

使用非注解方式配置Spring

手动增加bean：springPipelineFactory和consolePipeline

<bean id="springPipelineFactory" class="com.geccocrawler.gecco.spring.SpringPipelineFactory"/>

<bean id="consolePipeline" class="com.geccocrawler.gecco.spring.ConsolePipeline"/>

初始化Gecco

加载完成bean后启动Gecco，可以通过继承SpringGeccoEngine类，初始化你的GeccoEngine，需要特别注意的是GeccoEngine需要用非阻塞模式start()运行:

@Service
public class InitGecco extends SpringGeccoEngine {

    @Override
    public void init() {
        GeccoEngine.create()
        .pipelineFactory(springPipelineFactory)
        .classpath("com.geccocrawler.gecco.spring")
        .start("https://github.com/xtuhcy/gecco")
        .interval(3000)
        .start();
    }

}

开发Pipeline

pipeline的开发和之前一样，唯一不同的是不需要@PipelineName("consolePipeline")定义pipeline的名称，而是使用spring的@Service定义，spring的bean名称即为pipeline的名称。可以参考：

@Service("consolePipeline")
public class ConsolePipeline implements Pipeline<SpiderBean> {
    @Override
    public void process(SpiderBean bean) {
        System.out.println(JSON.toJSONString(bean));
    }
}

八、爬虫的监控

爬虫为什么要监控

gecco是一个十分简单易用的java开源爬虫框架，同时也一个款拥有很好扩展性的框架，目前已经有：

结合spring的插件gecco-spring

结合htmlunit的插件gecco-htmlunit

结合reids的插件gecco-reids

在开发爬虫时，由于要对很多网站和链接进行抓取，并对抓取下来的网站进行内容的抽取。大量的链接下载和内容抽取如果没有监控，很难发现问题。特别是对于主题爬虫，需要抽取页面的具体内容，如果网站改版务必要能尽快的发现并修正，gecco爬虫框架在完成了基本的框架和必要的插件的实现后，将重点放在了监控的开发上。

对扩展开放，对修改关闭的开闭原则一致是gecco框架的基本设计原则。gecco爬虫的监控模块同样基于该原则，基于jmx协议，使用aop模式。

输入图片说明

监控指标

爬虫基本信息

刷新基本信息：exec/com.geccocrawler.gecco:name=gecco/monitor

读取基本信息：read/com.geccocrawler.gecco:name=gecco

{
Interval: 5000,//抓取间隔时间ms
StartTime: "2016-03-20 20:34:11",//抓取开始时间
ThreadCount: 1,//爬虫线程数量
StarUrlCount: 8//初始url数量
}

下载监控

获取当前正在抓取的所有域名：exec/com.geccocrawler.gecco:name=downloader/hosts
获取某个域名的下载监控信息：exec/com.geccocrawler.gecco:name=downloader/statistics/xx.xx.com

读取下载监控信息：read/com.geccocrawler.gecco:name=downloader

Statistics: "{
    "exception":8,//该域名抓取异常的数量，主要是超时等异常
    "serverError":0,//该域名返回500，404等错误信息的数量
    "success":3263//成功抓取数量
}",
Host: "xx.xx.com"//域名

内容抽取监控

刷新内容抽取监控信息：exec/com.geccocrawler.gecco:name=render/refresh

获取内容抽取监控信息：read/com.geccocrawler.gecco:name=render

Statistics: "{
    "xx.xx.com":0,//域名xx.xx.com的网站内容抽取的异常数量
    "yy.yy.com":0//域名yy.yy.com的网站内容抽取的异常数量
}"

jmxutils和jolokia

jmxutils

gecco的监控使用了jmxutils这个开源的mbean注解框架。在以前的开发工作中要么就用原生的动态mbean，要么是使用spring的jmx注解框架。原生的动态mbean写起来太繁琐，spring的jmx注解框架使用起来还是很方便的，但是现在spring感觉有些重。jmxutils这个框架很轻量，使用方法可以参考https://github.com/martint/jmxutils。

jolokia

Jolokia是一个利用JSON通过Http实现JMX远程管理的开源项目。具有快速、简单等特点。除了支持基本的JMX操作之外，它还提供一些独特的特性来增强JMX远程管理如：批量请求，细粒度安全策略等。也就是说jmx的mbean可以通过http来访问不需要在启动java时配置那么多参数。只需要新增一个servlet：

<servlet>
    <servlet-name>jolokia-agent</servlet-name>
    <servlet-class>org.jolokia.http.AgentServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>jolokia-agent</servlet-name>
    <url-pattern>/jmx/*</url-pattern>
</servlet-mapping>

这样应用中的mbean就能轻松控制和访问。jolokia还提供了java客户端和js客户端来访问mbean，具体的使用方法和权限控制可以查看jolokia的官方文档https://jolokia.org/reference/html/index.html

九、稳定性测试

最近对开源的java爬虫Gecco做了一个稳定性测试，测试环境：一台爬虫+web应用服务器，一台mongodb服务器。服务器配置很low，两台都是阿里云最低端的主机，1核+512内存。

单线程测试场景

爬虫采用单线程，测试时间3×24小时，测试期间系统无异常，jvm内存稳定。测试结果：

基本信息
```
Interval: 5000,
StartTime: "2016-03-22 14:47:40",
ThreadCount: 1,
StarUrlCount: 8
```
单线程，共有8个初始抓取链接，每个请求抓取完成后休息5秒。

爬虫监控数据

taocan.ctrip.com
Statistics: "{"exception":134,"serverError":0,"success":11270}"

vacations.ctrip.com
Statistics: "{"exception":61,"serverError":0,"success":17548}"

huodong.ctrip.com
Statistics: "{"exception":42,"serverError":0,"success":11814}"

www.tuniu.com
Statistics: "{"exception":4,"serverError":0,"success":228}"

temai.tuniu.com
Statistics: "{"exception":78,"serverError":0,"success":3507}"

www.lvmama.com
Statistics: "{"exception":0,"serverError":415,"success":41}"
http://www.lvmama.com/tuangou/sale-623250 DOWNLOAD ERROR :500
http://www.lvmama.com/tuangou/sale-612687 DOWNLOAD ERROR :400

结果

从监控数据可以看到：

ctrip.com相关的数据抓取成功率较高，为99.99%，出现的失败都是exception，也就是类似超时之类的错误。

tuniu.com相关的数据抓取成功率也较高，为99.97%，出现的失败也是exception。

lvmama.com的成功率就十分低了，而且返回都是serverError也就是服务器500或者400错误，查看发日志发现可能对方服务器对ip做了访问限制，在成功抓取10多条后就一直报400或者500错误。

多线程测试场景

爬虫采用3线程，测试时间2×24小时，测试期间系统无异常，jvm内存稳定。测试结果：

基本信息

Interval: 5000,
StartTime: "2016-03-26 11:16:57",
ThreadCount: 3,
StarUrlCount: 8

3线程，共有8个初始抓取链接，每个请求抓取完成后休息5秒。