htmlunit抓取动态网页(一个爬虫动态生成的网页是什么？一般来说怎么办
)
　　最近公司想写一个爬虫项目。遇到一些js或者ajax动态生成的网页。我在网上搜了一下，发现是webdriver比较可靠。至于htmlunit，我测试了一些网站直接抛出异常。 , 可能对js支持不是特别好。
　　一般来说，WebDriver 有两种方式：本地 diver 和远程 diver。由于爬虫最终会部署到Linux服务器上，只能在命令行上运行，看来浏览器是装不了的，所以本地驱动的进程就不行了，只能尝试远程驱动了。幸运的是，我找到了一个phantomjs webdriver，它可以在Linux下无界面运行，所以选择了它作为从js动态生成网页的解决方案。
　　到官网下载：，找到对应的版本下载。解压并安装它。进入bin目录，执行phantomjs，需要带启动参数，执行远程驱动的地址和端口。 phantomjs --webdriver 127.0.0.1:10025.
　　java 连接：
　　WebDriver driver = new RemoteWebDriver("http://127.0.0.1:10025", DesiredCapabilities.phantomjs());
driver.get("http://www.iteye.com"); 查看全部

　　htmlunit抓取动态网页(JsoupJsoup:JavaHTMLParser,,andjquery使用入门案例)
　　汤
　　Jsoup：Java HTML 解析器，具有最好的 DOM、CSS 和 jquery
　　使用入门案例介绍
　　
org.jsoup
jsoup
1.10.2
　　使用简单
　　Document document = Jsoup.connect(url)
.timeout(30000)
.validateTLSCertificates(false)
.get();
Elements elements = document.select(".book-chapter-list > .cf:last-child > li");
for (Element element : elements) {
String title = element.text();
String chapUrl = url + element.select("a").attr("href");
// 其他构件存储操作
}
　　这里的主要目的是指定一个访问的url，然后通过各种选择器获取我们想要的元素信息。
　　动态js内容背景
　　最近因为工作需要，开始学习爬虫。对于静态加载的页面，爬取并不难，但是遇到ajax动态加载的页面，就无法爬取到动态加载的信息了！
　　爬取Ajax动态加载的数据，一般有两种方式：
　　1.因为js渲染页面的数据也是从后端获取的，而且基本都是AJAX获取的，所以分析AJAX请求，找到对应的数据
　　请求也是一种更可行的方法。并且与页面样式相比，这个界面不太可能发生变化。
　　缺点是找到这个请求并模拟它是一个比较困难的过程，需要比较多的分析经验。
　　2.在爬虫阶段，爬虫内置了一个浏览器内核，执行js渲染页面后，就会被爬取。这方面对应的工具是Selenium，
　　HtmlUnit 或 PhantomJs。但是，这些工具存在一定的效率问题，同时也不太稳定。
　　好处是写规则
　　对于第二种方法，我测试过只有Selenium可以成功爬到Ajax动态加载的页面，但是每次请求页面都会弹出浏览器窗口，这对于后面的项目部署到浏览器非常不利！
　　所以推荐第一种方法，代码也是第一种方法。
　　htmlunitjava 模拟js执行
　　ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
engine.eval(new InputStreamReader(Login.class
.getResourceAsStream("/sha1.js")));
Object t = engine.eval("CryptoJS.SHA1('" + password+ "').toString();");
System.out.println(t);
　　jsoup 模拟ajax请求
　　//然后就是模拟ajax请求，当然了，根据规律，需要将"datasku"的属性值替换下面链接中的"133537397"和"0000000000"值
Document document1=Jsoup.connect("http://ds.suning.cn/ds/general ... 6quot;)
.ignoreContentType(true)
.data("query", "Java")
.userAgent("Mozilla")
.cookie("auth", "token")
.timeout(3000)
.get();
//打印出模拟ajax请求返回的数据，一个json格式的数据，对它进行解析就可以了
System.out.println(document1.text());
　　jsoup抓取页面js信息
　　 /*设置网页抓取响应时间*/
private static final int TIMEOUT = 10000;

public static Map getSerieExtDetail(int serieId) throws Exception{

/*车系参数配置页面*/
String serieInfo = "http://car.autohome.com.cn/con ... 3B%3B

/*用來封裝要保存的参数*/
Map map = new HashMap();

/*取得车系参数配置页面文档*/
Document document = Jsoup.connect(serieInfo).timeout(TIMEOUT).get();

/*取得script下面的JS变量*/
Elements e = document.getElementsByTag("script").eq(6);

/*循环遍历script下面的JS变量*/
for (Element element : e) {

/*取得JS变量数组*/
String[] data = element.data().toString().split("var");

/*取得单个JS变量*/
for(String variable : data){

/*过滤variable为空的数据*/
if(variable.contains("=")){

/*取到满足条件的JS变量*/
if(variable.contains("option") || variable.contains("config")
|| variable.contains("color") || variable.contains("innerColor")){

String[] kvp = variable.split("=");

/*取得JS变量存入map*/
if(!map.containsKey(kvp[0].trim()))
map.put(kvp[0].trim(), kvp[1].trim().substring(0, kvp[1].trim().length()-1).toString());
}
}
}
}
return map;
}
　　进一步阅读
　　webmagic-另一个爬虫选项 查看全部

　　htmlunit抓取动态网页(Web网络爬虫系统的原理及应用)
　　1、 爬虫技术概述
　　网络爬虫是根据一定的规则自动抓取万维网信息的程序或脚本。它们广泛用于互联网搜索引擎或其他类似的网站，可以自动将采集它所能访问的页面的所有内容获取或更新这些网站@的内容和检索方法>. 从功能上来说，爬虫一般分为三个部分：数据采集、处理、存储。传统爬虫从一个或多个初始网页的网址开始，获取初始网页上的网址，在网页抓取过程中不断从当前页面中提取新的网址放入队列中，直到某个停止条件系统的满足。聚焦爬虫的工作流程比较复杂。需要按照一定的网页分析算法过滤与主题无关的链接，保留有用的链接，放入URL队列等待被抓取。然后，它会根据一定的搜索策略从队列中选择下一个要抓取的网页的网址，并重复上述过程，直到达到系统的某个条件时停止。另外，爬虫爬过的所有网页都会被系统存储起来，进行一定的分析、过滤、索引，以备以后查询检索；对于专注的爬虫，这个过程中得到的分析结果还是可以对后续的爬虫过程给出反馈和指导的。它会根据一定的搜索策略从队列中选择下一个要抓取的网页的网址，重复上述过程，直到达到系统的某个条件时停止。另外，爬虫爬过的所有网页都会被系统存储起来，进行一定的分析、过滤、索引，以备以后查询检索；对于专注的爬虫，这个过程中得到的分析结果还是可以对后续的爬虫过程给出反馈和指导的。它会根据一定的搜索策略从队列中选择下一个要抓取的网页的网址，重复上述过程，直到达到系统的某个条件时停止。另外，爬虫爬过的所有网页都会被系统存储起来，进行一定的分析、过滤、索引，以备以后查询检索；对于专注的爬虫，这个过程中得到的分析结果还是可以对后续的爬虫过程给出反馈和指导的。并为以后的查询和检索建立索引；对于专注的爬虫，这个过程中得到的分析结果还是可以对后续的爬虫过程给出反馈和指导的。并为以后的查询和检索建立索引；对于专注的爬虫，这个过程中得到的分析结果还是可以对后续的爬虫过程给出反馈和指导的。
　　与一般网络爬虫相比，聚焦爬虫需要解决三个主要问题：
　　（1) 爬取目标的描述或定义；
　　（2) 对网页或数据的分析和过滤；
　　（3) URL 搜索策略。
　　
　　2、爬取的原理
　　2.1 网络爬虫原理
　　网络爬虫系统的作用是下载网页数据，为搜索引擎系统提供数据源。许多大型互联网搜索引擎系统被称为基于Web数据的搜索引擎系统，如谷歌和百度。这说明了网络爬虫系统在搜索引擎中的重要性。除了供用户阅读的文本信息外，网页还收录一些超链接信息。网络爬虫系统通过网页中的超链接信息不断获取网络上的其他网页。正是因为这个采集进程就像一个爬虫或蜘蛛在网络上漫游，所以被称为网络爬虫系统或网络蜘蛛系统，英文称为Spider或Crawler。
　　
　　2.2 网络爬虫系统的工作原理
　　在网络爬虫的系统框架中，主要流程由控制器、解析器和资源库三部分组成。控制器的主要工作是为多线程中的每个爬虫线程分配工作任务。解析器的主要工作是下载网页并处理页面，主要是处理一些JS脚本标签、CSS代码内容、空格字符、HTML标签等内容。爬虫的基本工作由解析器完成。资源库用于存储下载的网页资源，一般使用Oracle数据库等大型数据库存储，并建立索引。
　　控制器
　　控制器是网络爬虫的中央控制器。主要负责根据系统传递过来的URL链接分配一个线程，然后启动线程调用爬虫对网页进行爬取。
　　解析器
　　解析器是负责网络爬虫的主要部分。它的主要任务包括：下载网页，处理网页文本，如过滤，提取特殊的HTML标签，分析数据。
　　资源库
　　主要用于存储网页中下载的数据记录，并提供生成索引的目标源。中大型数据库产品包括：Oracle、Sql Server等。
　　网络爬虫系统一般会选择一些输出度（网页中超链接数）较高的比较重要的URL作为种子URL集合。网络爬虫系统使用这些种子集作为初始 URL 开始数据爬取。由于网页中收录链接信息，所以会通过现有网页的网址获取一些新的网址。网页之间的指向结构可以看作是一个森林。每个种子 URL 对应的网页是森林中一棵树的根节点。. 这样，网络爬虫系统就可以按照广度优先算法或深度优先算法遍历所有网页。由于深度优先搜索算法可能会导致爬虫系统陷入网站内部，不利于搜索更接近< @网站主页，采集网页一般采用广度优先搜索算法。网络爬虫系统首先将种子 URL 放入下载队列，然后简单地从队列头部取一个 URL 来下载相应的网页。获取网页内容并存储后，通过解析网页中的链接信息，可以得到一些新的网址，并将这些网址加入到下载队列中。然后取出一个URL，下载其对应的网页，然后解析，如此周而复始，直到遍历全网或满足某个条件，才会停止。然后简单地从队列的头部检索一个 URL 来下载相应的网页。获取网页内容并存储后，通过解析网页中的链接信息，可以得到一些新的网址，并将这些网址加入到下载队列中。然后取出一个URL，下载其对应的网页，然后解析，如此周而复始，直到遍历全网或满足某个条件，才会停止。然后简单地从队列的头部检索一个 URL 来下载相应的网页。获取网页内容并存储后，通过解析网页中的链接信息，可以得到一些新的网址，并将这些网址加入到下载队列中。然后取出一个URL，下载其对应的网页，然后解析，如此周而复始，直到遍历全网或满足某个条件，才会停止。
　　
　　网络爬虫的基本工作流程如下：
　　1.首先选择一些精心挑选的种子网址；
　　2.将这些URL放入URL队列进行抓取；
　　3. 从待爬取的URL队列中取出待爬取的URL，解析DNS，获取主机IP，下载该URL对应的网页，并存储到下载的网页库中。另外，将这些 URL 放入爬取的 URL 队列中。
　　4.对爬取的URL队列中的URL进行分析，分析其中的其他URL，将这些URL放入待爬取的URL队列中，从而进入下一个循环。
　　
　　
　　2.3 爬取策略
　　在爬虫系统中，要爬取的URL队列是一个非常重要的部分。URL队列中要爬取的URL的顺序也是一个很重要的问题，因为它涉及到先爬哪个页面，后爬哪个页面。确定这些 URL 顺序的方法称为抓取策略。下面重点介绍几种常见的爬取策略：
　　2.3.1 深度优先遍历策略
　　深度优先遍历策略是指网络爬虫会从起始页开始，逐个跟踪每一个链接，处理完这一行后转移到下一个起始页，继续跟踪链接。我们以下图为例：
　　遍历的路径：AFG EHI BCD
　　
　　2.3.2 广度优先遍历策略
　　广度优先遍历策略的基本思想是将新下载的网页中找到的链接直接插入到待爬取的URL队列的末尾。即网络爬虫会先抓取起始网页中链接的所有网页，然后选择其中一个链接的网页，继续抓取该网页中链接的所有网页。以上图为例：
　　遍历路径：ABCDEF GHI
　　2.3.3 反向链接计数策略
　　反向链接数是指从其他网页链接到某个网页的数量。反向链接的数量表示网页内容被他人推荐的程度。因此，很多时候搜索引擎的爬取系统都会使用这个指标来评估网页的重要性，从而决定不同网页的爬取顺序。
　　在真实的网络环境中，由于广告链接和作弊链接的存在，反向链接的数量不能完全坐等别人的重视。因此，搜索引擎通常会考虑一些可靠的反向链接。
　　2.3.4Partial PageRank 策略
　　Partial PageRank算法借鉴了PageRank算法的思想：对于下载的网页，连同要爬取的URL队列中的URL，形成一个网页集合，计算每个页面的PageRank值，经过计算完成后，将要爬取的URL队列中的URL按照PageRank值的大小进行排列，依次爬取页面。
　　如果每个页面都被抓取，则重新计算 PageRank 值。一个折衷的方案是：每爬取K个页面后，重新计算PageRank值。但是，这种情况下仍然存在一个问题：对于从下载页面分析出来的链接，也就是我们前面提到的未知网页部分，暂时没有PageRank值。为了解决这个问题，这些页面会被赋予一个临时的PageRank值：将所有传入该页面链的PageRank值聚合起来，从而形成未知页面的PageRank值参与排名。以下示例说明：
　　2.3.5OPIC 策略
　　该算法实际上对页面的重要性进行评分。在算法开始之前，给所有页面相同的初始现金（cash）。下载某个页面P后，将P的现金分配给所有从P分析的链接，并清除P的现金。待抓取的 URL 队列中的所有页面均按照现金的数量进行排序。
　　2.3.六大站优先策略
　　URL队列中所有要爬取的网页，按照所属的网站进行分类。网站需要下载的页面较多，优先下载。这种策略因此被称为大站优先策略。
　　3、 爬虫分类
　　我应该选择 Nutch、Crawler4j、WebMagic、scrapy、WebCollector 还是其他来开发网络爬虫？上面提到的爬虫基本上可以分为三类：
　　(1）分布式爬虫：Nutch
　　（2）JAVA 爬虫：Crawler4j、WebMagic、WebCollector
　　（3）非JAVA爬虫：scrapy（基于Python语言开发）
　　3.1 个分布式爬虫
　　爬虫采用分布式，主要解决两个问题：
　　1)海量网址管理
　　2)网速
　　最受欢迎的分布式爬虫是 Apache 的 Nutch。但是对于大多数用户来说，Nutch 是这些类型的爬虫中最糟糕的选择，原因如下：
　　1)Nutch 是一款专为搜索引擎设计的爬虫。大多数用户需要一个爬虫来进行准确的数据爬取（精细提取）。Nutch 运行的一组进程中有三分之二是为搜索引擎设计的。精细提取没有多大意义。换句话说，使用 Nutch 进行数据提取会在不必要的计算上浪费大量时间。而如果你试图通过二次开发让Nutch适合精炼业务，你基本上会破坏Nutch的框架，将Nutch改得面目全非，并有能力修改Nutch。自己写一个新的确实更好。分布式爬虫框架。
　　2)Nutch 依赖于hadoop 来运行，而hadoop 本身就消耗大量时间。如果集群机器数量少，爬取速度不如单机爬虫快。
　　3)Nutch有一套插件机制，作为亮点推广。可以看到一些开源的Nutch插件，提供精细的提取功能。但是任何开发过 Nutch 插件的人都知道 Nutch 的插件系统有多烂。使用反射机制加载和调用插件使得编写和调试程序变得极其困难，更不用说在其上开发复杂的精细提取系统了。并且Nutch没有提供相应的插件挂载点进行精细提取。Nutch的插件只有五六个挂载点，而这五六个挂载点是为搜索引擎服务的，不提供精细提取的挂载点。Nutch的大部分精提取插件都挂载在挂载点“解析器”（parser）上。
　　4)使用Nutch进行爬虫二次开发，爬虫的准备和调试时间往往是单机爬虫所需时间的十倍以上。学习Nutch源代码的成本非常高，更何况团队中的每个人都必须了解Nutch源代码。在调试过程中，会出现程序本身以外的各种问题（hadoop问题、hbase问题）。
　　5) 很多人说Nutch2有gora，可以持久化数据到avro文件、hbase、mysql等，其实很多人理解错了。这里所说的持久化数据是指在avro、hbase、mysql中存储URL信息（URL管理所需的数据）。这不是您要提取的结构化数据。事实上，对于大多数人来说，URL 信息存在于何处并不重要。
　　6)Nutch2 版本目前不适合开发。Nutch官方稳定版是nutch2.2.1，但是这个版本绑定了gora-0.3。如果你想和nutch一起使用hbase（大多数人使用nutch2来使用hbase），你只能在0.90版本左右使用hbase，因此你必须将hadoop版本降低到hadoop 0.2左右. 而且，Nutch2的官方教程更具有误导性。Nutch2有两个教程，分别是Nutch1.x和Nutch2.x。Nutch2.x 官网可以支持转到hbase 0.94。但其实这个Nutch2.x指的是Nutch2.3之前和Nutch2.2.1之后的版本。此版本在官方SVN中不断更新。
　　所以，如果你不是搜索引擎，尽量不要选择Nutch作为爬虫。有些团队喜欢效仿。他们坚持选择Nutch来开发集约化提取的爬虫。其实是为了Nutch的名气（Nutch的作者是Doug Cutting）。当然，最终的结果往往是项目延期。
　　如果你是一个搜索引擎，Nutch1.x 是一个非常好的选择。Nutch1.x 与 solr 或 es 合作组成了一个非常强大的搜索引擎。如果非要使用Nutch2，建议等到Nutch2.3发布。当前的 Nutch2 是一个非常不稳定的版本。
　　
　　分布式爬虫平台架构图
　　3.2 JAVA爬虫
　　这里将JAVA爬虫单独划分为一个类别，因为JAVA在网络爬虫的生态系统中是非常完整的。相关资料也是最全的。这里可能有争议，我只是随便说说。
　　其实开源网络爬虫（框架）的开发很简单，难点复杂的问题（比如DOM树解析定位、字符集检测、海量URL去重）都已经被前人解决了，可以说没有技术含量。包括Nutch，其实Nutch的技术难点就是开发hadoop，代码本身也很简单。从某种意义上说，网络爬虫类似于遍历机器的文件以查找文件中的信息。没有任何困难。之所以选择开源爬虫框架，是为了省事。比如爬虫URL管理、线程池等模块，任何人都可以做，但是需要一段时间的调试和修改才能稳定下来。
　　用于爬虫的功能。用户比较关心的问题往往是：
　　1） 爬虫是否支持多线程，爬虫能不能用agent，能不能抓取重复数据，能不能抓取JS生成的信息？
　　那些不支持多线程、代理、过滤重复网址的不叫开源爬虫，而是叫循环执行http请求。
　　js生成的信息能否被爬取与爬虫本身关系不大。爬虫主要负责遍历网站和下载页面。爬取js产生的信息与网页信息提取模块有关，往往需要通过模拟浏览器（htmlunit、selenium）来完成。这些模拟浏览器通常需要花费大量时间来处理页面。所以一种策略是利用这些爬虫来遍历网站，当遇到需要解析的页面时，将页面的相关信息提交给模拟浏览器，完成对JS生成信息的提取。
　　2）爬虫可以爬取ajax信息吗？
　　网页上有一些异步加载的数据。爬取这个数据有两种方式：使用模拟浏览器（问题1描述），或者分析ajax http请求，自己生成ajax请求url，获取返回数据。如果自己生成ajax请求，使用开源爬虫有什么意义？其实还是需要用到开源爬虫的线程池和URL管理功能（比如断点爬取）。
　　如果我已经可以生成我需要的ajax请求（列表），我该如何使用这些爬虫来抓取这些请求？
　　爬虫通常被设计成广度遍历或深度遍历的模式来遍历静态或动态页面。爬取ajax信息属于深网（deep web）的范畴，虽然大部分爬虫不直接支持。但它也可以通过某些方式完成。例如，WebCollector 使用广度遍历来遍历网站。第一轮爬取是爬取种子集（seeds）中的所有URL。简单的说，就是将生成的ajax请求作为种子，放入爬虫中。使用爬虫以深度为1（默认为广度遍历）遍历这些种子。
　　3）爬虫如何爬取网站登录？
　　这些开源爬虫都支持在爬取时指定cookies，模拟登录主要依赖cookies。至于如何获取cookie，就不是爬虫的事情了。您可以手动获取cookies，模拟http请求登录，或者使用模拟浏览器自动登录获取cookies。
　　4）爬虫如何从网页中提取信息？
　　开源爬虫一般都集成了网页提取工具。主要支持两种规范：CSS SELECTOR 和 XPATH。至于哪个更好，这里就不评价了。
　　5）爬虫是如何保存网页信息的？
　　一些爬虫带有一个负责持久化的模块。例如，webmagic 有一个名为管道的模块。通过简单的配置，爬虫提取的信息可以持久化到文件、数据库等中，也有一些爬虫不直接为用户提供数据持久化模块。如 crawler4j 和 webcollector。让用户在网页处理模块中添加提交数据库的操作。至于使用pipeline模块好不好，类似于是否使用ORM来操作数据库的问题。这取决于您的业务。
　　6）爬虫被网站拦截怎么办？
　　爬虫被网站拦截，通常可以通过多个代理（随机代理）解决。但是，这些开源爬虫一般不直接支持随机代理的切换。因此，用户往往需要自己将获取到的代理放入一个全局数组中，自己编写代码来随机获取代理（从数组中）。
　　7）网页可以调用爬虫吗？
　　爬虫的调用是在Web的服务器端调用的，你可以照常使用。所有这些爬虫都可以使用。
　　8）爬行速度怎么样？
　　一个单机的开源爬虫的速度基本可以用到机器网速的极限。爬虫速度慢，往往是因为用户线程少，网速慢，或者持久化数据时与数据库交互慢。这些东西往往是由用户的机器和二次开发代码决定的。这些开源爬虫的速度非常好。
　　9）显然代码写对了，爬不出来数据。爬虫有问题吗？别的爬虫能解决吗？
　　如果代码写对了，数据爬不出来，其他爬虫也是一样。在这种情况下，要么 网站 阻止了您，要么您抓取的数据是由 javascript 生成的。爬取数据无法通过改变爬虫来解决。
　　10）哪个爬虫可以判断网站是否爬完了，哪个爬虫可以根据主题爬取？
　　爬虫无法判断网站是否爬过，只能尽量覆盖。
　　至于基于主题的爬取，爬虫只有向下爬取内容才知道主题是什么。所以它通常是从整体上爬下来，然后去过滤内容。如果觉得抓取过于笼统，可以通过限制网址规律等方法缩小范围。
　　11） 哪个爬虫有更好的设计模式和结构？
　　设计模式纯属无稽之谈。当软件设计模式好的时候，开发软件，然后总结出几种设计模式。设计模式对软件开发没有指导作用。使用设计模式来设计爬虫只会让爬虫的设计更加臃肿。
　　在架构上，开源爬虫目前主要是详细数据结构的设计，比如爬取线程池、任务队列等，大家都可以控制。爬虫的业务太简单了，不谈结构。
　　所以对于JAVA开源爬虫，我觉得，找一个好用的就好了。如果业务复杂，使用哪种爬虫就必须经过复杂的二次开发才能满足需求。
　　3.3 个非 Java 爬虫
　　在非JAVA语言编写的爬虫中，有很多优秀的爬虫。这里单独提取为一个类别，不是针对爬虫本身的质量，而是针对larbin、scrapy等爬虫对开发成本的影响。
　　先说python爬虫，python可以用30行代码完成JAVA 50行代码的任务。Python 代码编写确实很快，但是在调试代码阶段，Python 代码的调试往往比编码阶段节省的时间消耗的时间要多得多。使用python开发，为了保证程序的正确性和稳定性，需要编写更多的测试模块。当然，如果爬取规模不大，爬取业务不复杂，使用scrapy也是相当不错的，可以轻松完成爬取任务。
　　
　　上图是Scrapy的架构图。绿线是数据流。首先，从初始 URL 开始，调度程序会将其交给下载程序进行下载。下载完成后，会交给Spider进行分析。需要保存的数据会被发送到Item Pipeline。，也就是数据的后处理。此外，可以在数据流通道中安装各种中间件来进行必要的处理。所以在开发爬虫的时候，最好先规划好各个模块。我的做法是分别规划下载模块、爬取模块、调度模块、数据存储模块。
　　对于C++爬虫来说，学习成本会比较大。而且你不能只计算一个人的学习成本。如果软件需要团队开发或交接，那将是很多人的学习成本。软件调试并不是那么容易。
　　还有一些ruby、php爬虫，这里不多评论。确实有一些非常小的数据采集任务，用ruby或者php非常方便。但是要选择这些语言的开源爬虫，一方面需要调查相关生态，另一方面这些开源爬虫可能会产生一些你找不到的bug（人少信息少） .
　　4、反爬虫技术
　　由于搜索引擎的流行，网络爬虫已经成为一种非常流行的网络技术。除了专门从事搜索的谷歌、雅虎、微软和百度，几乎每个大型门户网站网站都有自己大大小小的搜索引擎。可以叫出的名字有几十个，不知道的名字也有上万个。对于一个内容驱动的网站来说，难免会被网络爬虫光顾。
　　网站上一些智能搜索引擎爬虫的爬取频率比较合理，消耗的资源比较少。但是，很多不良的网络爬虫对网页的爬取能力较差，经常会发送几十甚至上百个请求，重复爬取循环。拿，这种爬虫往往对中小网站来说是毁灭性的打击，尤其是缺乏爬虫编写经验的程序员写的爬虫，破坏力极强，网站访问压力会很大很高。, 会导致网站 访问缓慢甚至无法访问。
　　一般来说，网站从三个方面进行反爬虫：用户请求的Headers、用户行为、网站目录和数据加载方式。前两个比较容易遇到，大多数网站反爬虫都是从这些角度来看的。将采用第三类ajax应用网站，增加爬虫难度。
　　4.1 个通过 Headers 的反爬虫
　　从用户请求的Headers反爬取是最常见的反爬取策略。很多网站会检测Headers的User-Agent，有的网站会检测Referer（部分资源网站的防泄漏环节就是检测Referer）。如果遇到这种反爬虫机制，可以直接给爬虫添加Headers，将浏览器的User-Agent复制到爬虫的Headers中；或者将Referer值修改为目标网站域名【注：经常容易被Ignore，通过对请求的抓包分析确定referer，并将其添加到模拟访问的请求头中该程序]。对于检测header的反爬虫，在爬虫中修改或添加header很容易绕过。
　　4.2 基于用户行为的反爬虫
　　网站的另一部分是检测用户行为，比如同一IP在短时间内多次访问同一个页面，或者同一个账号在短时间内多次执行相同的操作。【这种反爬需要足够的ip来应对】
　　大部分网站都是前一种情况。在这种情况下，使用IP代理来解决它。可以专门写一个爬虫来爬取网上公开的代理ip，检测后全部保存。这类代理ip爬虫经常用到，最好自己准备一个。有大量代理ip后，每次请求几次就可以换一个ip。这在requests或urllib2中很容易做到，这样就可以轻松绕过第一个反爬虫。【点评：动态拨号也是一种解决方案】
　　在第二种情况下，您可以在每次请求后以几秒钟的随机间隔发出下一个请求。一些存在逻辑漏洞的网站可以通过多次请求、注销、重新登录、继续请求来绕过同一账号不能在短时间内多次发出相同请求的限制。【点评：账号反爬限制一般很难处理。几秒钟的随机请求也可能被阻止。如果有多个账号，在它们之间切换会有更好的效果】
　　4.3 动态页面反爬虫
　　以上情况大部分出现在静态页面上，还有一些网站，我们需要爬取的数据是通过ajax请求获取或者通过Java生成的。首先，使用Firebug或者HttpFox来分析网络请求【评论：感觉Google和IE的网络请求分析也很好】。如果能找到ajax请求，分析出响应的具体参数和具体含义，就可以通过上面的方法直接使用requests或者urllib2来模拟ajax请求，分析响应json得到需要的数据。
　　能够直接模拟ajax请求获取数据是很棒的，但是有些网站加密了ajax请求的所有参数。我们没有办法为我们需要的数据构造一个请求。这几天爬的网站就是这样的。除了对ajax参数进行加密外，还封装了一些基础功能，都是调用自己的接口，对接口参数进行加密。遇到这样的网站，就不能用上面的方法了。我使用selenium+phantomJS框架，调用浏览器内核，使用phantomJS执行js模拟人的操作，触发页面中的js脚本。从填表到点击按钮再到滚动页面，一切都可以模拟，无论具体的请求和响应过程，只是一个完整的模拟人们浏览页面获取数据的过程。【评论：支持phantomJS】
　　使用这个框架几乎可以绕过大部分反爬虫，因为它不是冒充浏览器获取数据（上面是通过添加Headers在一定程度上冒充浏览器），它是浏览器本身，phantomJS是一个没有界面的浏览器，但它不是控制浏览器的人。使用selenium+phantomJS可以做很多事情，比如识别point-and-touch（12306）或者滑动验证码，页面表单的暴力破解等）。它还将在自动化渗透方面展示其才华，并且在未来也会这样做。提这个。 查看全部

　　htmlunit抓取动态网页(
爬虫适应国内爬虫架构的解决方案架构解决方案摘要
)
　　如何制作最好的定向爬虫架构
　　姓名：郭忠
　　目前职位：在一家创业公司做爬虫工程师
　　概括
　　随着互联网信息的不断发展，信息和数据的挖掘技术也在不断发展。网络爬虫技术也得到了很大的发展。对于内容驱动的网站来说，反抄袭是必不可少的东西。很多网站使用Jquery脱壳，登录验证，限制每IP每秒请求数，防止爬虫窃取数据。因此，爬虫的智能化也越来越受到挑战。这就产生了一个适应目前国内爬虫架构的解决方案。
　　介绍
　　内容
　　1、—————重新优化URL深度优先策略
　　2、——————模拟浏览器内核，让爬行更强大
　　3、——————适配无效代理ip的管理优化
　　4、——————URL 上下文使开发业务逻辑更容易
　　5、—————— 多线程控制
　　6、——————任务的时间安排
　　7、——————转储错误页面会让调试更方便
　　8、—————— 爬取日志解决中断抓包
　　9、————— 爬虫JVM参数优化
　　10、————————基于hadoop分布式
　　1、重新优化URL深度优先策略
　　深度优先搜索策略。这个策略的主要思想是从根节点开始寻找叶子节点，以此类推。在网页中，选择一个超链接，链接的网页将进行深度优先搜索，形成一个单一的搜索链。当没有其他超链接时，搜索结束。但是，这种自动化的URL深度定制并不能达到业务需求的最佳优先状态。
　　让我们看看传统的 URL 队列模型。图中有一个入口网址“A”，解析得到三个后续网址“B”。传统的抓取顺序由飞机图标标记。每个子条目 URL 被顺序捕获到“C”。问题出来了。如果需要捕获的信息在C中，那么可以使用第一个C1来捕获C1的信息。为什么要等到 B 爬完才开始爬 C？而如果依赖于 URL 的深度，则较低的 URL 会累积。这是对内存的巨大浪费，所以爬虫很容易出现内存溢出，这也反映了一个方面。
　　
　　最好的优化效果是获取一组“B”的URL，然后递归地获取每个B及其下面的子URL“C”。这样就不会出现当前无法处理但占用大量内存的后续URL堆积问题。优化后，如图。
　　
　　2、模拟浏览器内核，让爬虫更强大
　　网页需要的内容由JS动态加载。有的甚至在jquery加载html源码后根本看不到信息数据。解决这个问题的唯一办法就是让爬虫本身变成一个没有界面的浏览器。现在java有现成的浏览器驱动库htmlunit，可以模拟浏览器，也可以调用现成的火狐和谷歌内核。Python 有 pyv8 JS 引擎、QtWebKit 等组件。有了这些组件，我们用js调用封装一个爬虫，模拟登录就很简单了。
　　模拟浏览器架构：
　　1、由于浏览器内核消耗大量内存，所以需要封装一个内核池WebDriberPool来管理所有内核，统一创建和关闭。
　　2、下载器必须提供外部接口用于设置JS代码
　　3、下载网页时需要执行JS自动执行之前设置的JS代码
　　4、爬取模式为代理IP模式时，自动从IP管理获取IP
　　3、适应无效代理ip的管理优化。对于普通的网站，只要设置了请求头User-Agent，我们就可以轻松绕过网站服务器的anti-pick机制。但对于大型 网站 来说，事情没那么简单。他们会通过网站流量统计系统和日志分析来识别爬虫或限制每秒IP请求数。但是他们无法阻止代理IP的自动轮换。目前国内基本没有所谓的“高隐蔽代理IP”。一些代理IP提供商的失败率也非常高。几乎找不到永久有效的代理IP。如果没有，为什么还要找它。为什么不适应这种代理IP失败是常态的情况。
　　假设我们购买了某个代理IP，供应商改进了API提取方式。
　　1 需要代理IP的网络缓冲池
　　2需要代理本地缓存池来缓存有效IP
　　3 爬虫提取代理IP时，判断缓存是否足够使用，如果有则取缓存IP。
　　4 如果没有缓存，网络会提取一批代理IP加入网络缓冲池。
　　5、 爬取过程也是一个验证过程。有效的代理IP被缓存到缓存池中以供其他请求使用。
　　6、请求失败时，如果IP来自缓存，设备IP会被踢出缓存队列。
　　7、 可以设置代理IP失败超时时间。驻留在内存中超过时间的IP被踢出队列
　　实现框架图如下：
　　4、URL 上下文使开发业务逻辑更容易
　　在开发爬虫的时候，发现数据库设计的数据往往单页不完整。通常需要几个页面或者需要查询一些业务相关的ID。所以对于这些情况，一般都是去数据库查询更新后的数据，所以在写DAO层的时候方法就多了很多。业务逻辑的复杂度越来越高。案例如图：
　　上下文类架构：
　　1、为每个初始 URL 创建包 startRequest
　　2、提供支持线程并发安全的全局缓存key-value表
　　3、每个Request的实例化传递到上下文类
　　4、 爬虫爬取时可以把属性放到key-value表中
　　5、 子页面需要时，可以通过Requst获取上下文实例，获取对应的属性
　　6、爬虫任务完成。自动清除所有上下文缓存信息。
　　
　　5、多线程控制
　　爬虫线程工作周期长。如果在程序的某个阶段出现异常，那么你认为之前程序所做的工作就会丢失。所有爬虫多线程应该分为两部分。一个是专门请求 URL 以下载 html 页面的线程。这部分线程需要很长时间并且独立工作。不需要多用synchronized，容易出现异常。另一部分是“离线处理”线程，对下载的数据进行提取、清理、封装和存储。这部分线程与业务密切相关，处理速度快，耗时长。有时需要协调工作，需要使用更多同步和线程安全的缓冲队列。
　　最后，还有一个线程，其生命周期与爬虫任务相同。它不断轮询 URL 队列以获取最新的 URL，并将该 URL 分配给下载线程。
　　6、任务计时问题
　　爬虫任务周期长短。或者业务需要爬虫反复抓取一些动态数据。这时候就需要一个定时机制。其实Java的Timer已经提供了计时功能。我们只需要给定时器启动爬虫的程序即可。爬虫任务完成后，定时器设置下一次启动时间。然后它会休眠并等待它再次启动。
　　结合多线程控制和任务时序管理，得到如下架构图：
　　 查看全部

　　htmlunit抓取动态网页(htmlunit网络工具一个没有没有
)
　　1：背景
　　我想用jsoup抓取一个页面，但是我抓取的数据总是不完整的，然后我发现页面执行了js之后有一些数据渲染在页面上，也就是说，它只在执行js后的数据页。数据会显示出来，但是jsoup无法实现执行页面的js。
　　2：解决
　　搜索后发现htmlunit网络工具可以执行js，相当于没有页面的浏览器。解决办法是先用htmlUnit发送网络请求，执行js获取页面，然后用jsoup转换成Document页面对象。然后用jsoup分析页面读取数据。
　　3: htmlUnit 发送请求
　　4：返回的Document对象交给jsoup处理
　　我这里只做了一个简单的输出，我检查了数据是否全部渲染完毕。
　　 1 Document doc=getDocument();
2 Element table=doc.select("table.table.table-bordered.aggregate_table").get(0);//获取到表格
3 Element tableContext=table.getElementsByTag("tbody").get(0);
4 Elements contextTrs=tableContext.getElementsByTag("tr");
5 System.out.println(contextTrs.size());
6
7
8 String context=doc.toString();
9 OutputStreamWriter pw = null;
10 pw = new OutputStreamWriter(new FileOutputStream("D:/test.txt"),"GBK");
11 pw.write(context);
12 pw.close(); 查看全部

　　htmlunit抓取动态网页(
静态网页是指存放在服务器中实实在在的HTML文件中)
　　动态网页和静态网页
　　静态网页是指存储在服务器文件系统中的实际 HTML 文件。当用户在浏览器中进入页面时
　　URL，然后回车，浏览器会下载、渲染并在窗口中呈现相应的 HTML 文件。早期的 网站 通常是由静态页面制作的。
　　1. 动态网页
　　动态网页相对于静态网页。当浏览器请求服务器的页面时，服务器根据当前时间、环境参数、数据库操作等动态生成HTML页面，然后发送给浏览器（后续处理同静态网页页）。
　　显然，动态网页中的“动态”是指服务器端页面的动态生成，相反，“静态”是指页面实际的、独立的文件。
　　注意：
　　1.1 JavaScript
　　JavaScript 是一种属于网络的脚本语言。它在Web应用程序开发中得到了广泛的应用。常用于为网页添加各种动态功能，为用户提供更流畅美观的浏览效果。LavaScript 脚本通常嵌入在 HTML 中以实现自己的功能。
　　可以在网页源代码的标签中看到，如：
　　JavaScript 可以动态创建 HTML 内容，只有在 JavaScript 代码执行后才会生成和显示。如果使用传统的方法采集页面内容，则只能在执行JavaScript代码之前获取页面上的内容。
　　查询
　　JQuery 是一个快速简洁的 JavaScript 框架，它封装了 JavaScript 常用的函数代码，提供了简单的 JavaScript 设计模式，优化了 HTML 文档操作、事件处理、动画设计和 Ajax 交互。-网站 使用JQuery的一个特点是源码中收录了JQuery的入口，比如：
　　如果 网站 网页的源代码中出现了 jQuery，则在使用 采集 数据时必须非常小心。因为 jQuery 可以动态创建 HTML 内容，所以这些内容只有在 JavaScript 代码执行后才会生成和显示。如果使用传统的方法采集页面内容，则只能在执行JavaScript代码之前获取页面上的内容。
　　1.2 阿贾克斯
　　使用Ajax技术更新网页内容的网站有一个很大的特点，就是可以在不重新加载整个网页的情况下更新网页的某一部分。
　　Ajax其实并不是一种语言，而是一系列用来完成网络任务的技术（可以认为类似于网络数据采集）。Ajax网站 可以在不使用整个页面加载的情况下与 web 服务器交互。
　　1.3 DHTML
　　DHTML：Dynamic HTML 动态HTML，这个技术并不是什么新技术，而是结合了我们之前学过的
　　HTML、CSS、JavaScript集成在一起，使用S操作页面元素，使元素动态变化，使页面与用户进行交互行为。
　　2. 动态网页处理方法
　　使用动态加载的网站，用Python有几种方法可以解决：
　　直接破解JavaScript代码中采集的内容。
　　抓包解析，查看截图的请求响应信息，伪造请求，实现响应的获取。（推荐）
　　使用Python的第三方库运行JavaScript，直接采集浏览器中看到的页面。（推荐）
　　既然浏览器可以获取数据，那么就可以模拟一个浏览器，从浏览器中获取数据。即使用程序控制浏览器，从而达到数据采集的目的。
　　文章来源： 查看全部

　　htmlunit抓取动态网页(jsoup的简单使用方法教程)
　　jsoup 只能解析静态 html 页面。如果页面是js动态生成的，jsoup将无法启动。使用htmlunit获取js运行后的页面，还可以模拟浏览器点击页面元素，非常强大，本文介绍htmlunit的简单使用。步骤如下：
　　1、引入依赖
　　
net.sourceforge.htmlunit
htmlunit
2.36.0
org.jsoup
jsoup
1.12.1
　　2、我们爬取我们绘制的页面，首先绘制一个简单的页面，页面中id为content的div的原创内容为hello，页面加载后内容变为
　　HtmlUnit 太强大了
　　，访问此页面查看结果
　　

Title
HtmlUnit简单使用

hello

document.getElementById("content").innerHTML = "HtmlUnit好强大";
　　
　　3、写测试类，先用jsoup直接爬取，看内容是什么，我们打印出来，可以看到是hello
　　@Test
public void testJsoup() throws IOException {
Document document = Jsoup.connect("http://localhost:8080/index.html").get();
System.out.println(document.getElementById("content").html());
}
　　4、用htmlunit看看效果
　　@Test
public void test() {
final WebClient webClient = new WebClient(BrowserVersion.CHROME);
webClient.getOptions().setThrowExceptionOnScriptError(false);
webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);
webClient.getOptions().setActiveXNative(false);
webClient.getOptions().setCssEnabled(false);
webClient.getOptions().setJavaScriptEnabled(true);
webClient.setAjaxController(new NicelyResynchronizingAjaxController());
HtmlPage page = null;
try {
page = webClient.getPage("http://localhost:8080/index.html");
} catch (Exception e) {
e.printStackTrace();
}finally {
webClient.close();
}
webClient.waitForBackgroundJavaScript(30000);
String pageXml = page.asXml();
Document document = Jsoup.parse(pageXml);//获取html文档
System.out.println(document.getElementById("content").html());
}
　　
　　可以看到js运行后的内容，与浏览器看到的结果一致 查看全部

　　htmlunit抓取动态网页(Java爬取博客阅读文章最多)
　　更新，这很尴尬。这个文章博客阅读量最多文章，但也被最讨厌。
　　爬行思路：
　　所谓动态，就是可以通过请求后台动态改变对应的html页面，一开始页面并不是全部显示出来的。
　　大多数操作都是通过请求来完成的，一个请求，一个返回。在大多数网页中，请求往往被开发者隐藏在 js 代码中。
　　因此，爬取动态网页的思路转化为寻找对应的js代码，并执行对应的js代码，从而通过java代码动态改变页面。
　　而当页面能够正确显示时，我们就可以像抓取静态网页一样抓取数据了！
　　首先可以使用htmlunit来模拟鼠标点击事件，实现起来很简单：
　　 /**
* 通过htmlunit来获得一些搜狗的网址。
* 通过模拟鼠标点击事件来实现
* @param key
* @return
* @throws Exception
*/
public String getNextUrl(String key){
String page = new String();
try {
WebClient webClient = new WebClient();
webClient.getOptions().setCssEnabled(false);
webClient.getOptions().setJavaScriptEnabled(false);
//去拿网页
HtmlPage htmlPage = webClient.getPage("http://pic.sogou.com/");
//得到表单
HtmlForm form = htmlPage.getFormByName("searchForm");
//得到提交按钮
HtmlSubmitInput button = form.getInputByValue("搜狗搜索");
//得到输入框
HtmlTextInput textField = form.getInputByName("query");
//输入内容
textField.setValueAttribute(key);
//点一下按钮
HtmlPage nextPage = button.click();
String str = nextPage.toString();
page = cutString(str);
webClient.close();
} catch (Exception e) {
e.printStackTrace();
}
return page;
}
　　如上图，我通过java代码将关键字填入搜索我的，然后通过getInputByValue方法获取按钮控件，最后直接button.click()，
　　也就是说可以模拟点击，点击后返回的http请求可以解析成htmlpage。
　　
　　这个功能其实非常强大。例如，您可以使用该功能来模拟抢票，或者使用点击事件和搜索相关知识将整个系统下线并保存在 html 中。
　　下一步就是使用强大的 htmlunit 来执行 js 代码了。
　　先写一个简单的jsp页面：
　　
Insert title here
原数字
function change(value) {
document.getElementById("test").innerHTML = value;
return "hello htmlUnit";
}
　　从上面可以看出，jsp页面很简单，只是一个函数变化，用来调用htmlUnit。
　　接下来是一个使用 htmlunit 的类。这个类支持 JavaScript 解释器，
　　然后将自己编写的JavaScript代码嵌入到页面中执行，执行后得到返回结果返回页面。
　　package com.blog.anla;
import com.gargoylesoftware.htmlunit.ScriptResult;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
public class TestMyOwnPage {
private void action() {
WebClient webClient = new WebClient();
try {
webClient.getOptions().setCssEnabled(false);
webClient.getOptions().setJavaScriptEnabled(true); // 设置支持JavaScript。
// 去拿网页
HtmlPage htmlPage = webClient
.getPage("http://localhost:8989/testHtmlScrop/index.jsp");
String s = "更改后的数字";
ScriptResult t = htmlPage.executeJavaScript("change(\"" + s
+ "\");", "injected script", 500);
// 这里是在500行插入这一小行JavaScript代码段，因为如果在默认的1行，那不会有结果
// 因为js是顺序执行的，当你执行第一行js代码时，可能还没有渲染body里面的标签。
HtmlPage myPage = (HtmlPage) t.getNewPage();
String nextPage = myPage.asXml().toString();
String nextPage2 = myPage.asText().toString();
} catch (Exception e) {
e.printStackTrace();
} finally {
webClient.close();
}
}
public static void main(String[] args) {
TestMyOwnPage tmop = new TestMyOwnPage();
tmop.action();
}
}
　　t.getNewPage() 中有两个属性，一个是
　　javaScriptResult：执行代码后返回的结果，如果有（如我上面写的，返回hello htmlunit），如果没有（返回Undefined）。
　　newPage_：执行这段代码后返回的整个页面。
　　结果如图所示：
　　
　　这段代码执行的最终结果如下：
　　asXml()：将整个页面的html代码返回给我们：
　　
　　而asText()只返回页面上可以显示的值，即head标签和label标签：
　　
　　这种执行思路也可以动态的执行对应的js代码，从而抓取到需要的数据。
　　-------------------------------------------------- -------------------------------------- 2017 年 7 月更新------- ------------------------------------------------- - ----------------------------------------------
　　这两天一直在研究一个关于网络爬虫的系统
　　但是第一次爬的时候就发现了这个问题，js的动态页面爬不下来。
　　网上找了很多方法，google也问了，主要是指htmlunit，下面是核心代码，
　　使用htmlunit的主要目的是模拟浏览器操作，因为有些链接点击无法通过src直接获取url，通常使用JavaScript
　　简单拼接后的URL，这样一来，相比之下，直接用htmlunit模拟浏览器点击就简单多了。
　　 WebClient webClient = new WebClient();
webClient.getOptions().setJavaScriptEnabled(true); //启用JS解释器，默认为true
webClient.getOptions().setCssEnabled(false); //禁用css支持
webClient.getOptions().setThrowExceptionOnScriptError(false); //js运行错误时，是否抛出异常
webClient.getOptions().setTimeout(20000);
HtmlPage page = wc.getPage("http://www.hao123.com");
//我认为这个最重要
String pageXml = page.asXml(); //以xml的形式获取响应文本

/**jsoup解析文档*/
Document doc = Jsoup.parse(pageXml, "http://cq.qq.com");
　　这个时候，就可以得到jsoup中的document对象了，接下来就好写了，就像爬普通静态网页一样了。
　　不过，webclient解析是还是会出现一些问题，js的问题，
　　主要是由于目标url的js写的有些问题，但在实际的浏览器中却会忽略，eclipse中会报异常。
　　今天看到的时候，很多人都踩了。也许他们当时没有认真写博客。如果想找java爬虫项目可以到我的专栏。
　　图片搜索包括使用 jsoup 抓取图片，以及使用 lire 对图片进行索引和搜索。
　　给玫瑰手留下余香。有什么问题可以多多讨论哦！ 查看全部

　　htmlunit抓取动态网页(,ajax动态加载的网页并提取网页信息（需进行）
)
　　网页有几种采集：
　　1.静态网页
　　2.动态网页（需要js、ajax动态加载数据的网页）
　　3.采集的网页前需要模拟登录
　　4.加密网页
　　3、4个解决方案和想法会在后续博客中说明
　　目前只有 1、2 的解决方案和想法：
　　一.静态网页
　　解决静态网页的方法有很多很多采集！ java和python都提供了很多工具包或者框架，比如java httpclient、Htmlunit、Jsoup、HtmlParser等，Python urllib、urllib2、BeautifulSoup、Scrapy等，不详，网上资料很多。
　　二.动态网页
　　对于采集来说，动态网页就是那些需要通过js和ajax动态加载获取数据的网页。 采集 有两种数据方案：
　　1.通过抓包工具分析js、ajax的请求，模拟js加载后获取数据的请求。
　　2.调用浏览器内核，获取加载网页的源码，然后解析源码
　　研究爬虫的人一定对js有所了解。网上学习资料很多，就不一一列举了。我写这篇文章只是为了文章完整性
　　调用浏览器内核的工具包也有几个，不过不是今天的重点。今天的重点是文章的标题。 Scrapy框架结合Spynner采集需要动态加载js和ajax。并提取页面信息（以采集微信公众号文章列表为例）
　　开始...
　　1.创建微信公众号文章list采集项目（以下简称微采集）
　　scrapy startproject weixin
　　2.在spider目录下创建一个采集spider文件
　　vim weixinlist.py
　　编写如下代码
　　from weixin.items import WeixinItem
import sys
sys.path.insert(0,'..')
import scrapy
import time
from scrapy import Spider
class MySpider(Spider):
name = 'weixinlist'
allowed_domains = []
start_urls = [
'http://weixin.sogou.com/gzh%3F ... 39%3B,
]
download_delay = 1
print('start init....')
def parse(self, response):
sel=scrapy.Selector(response)
print('hello,world!')
print(response)
print(sel)
list=sel.xpath('//div[@class="txt-box"]/h4')
items=[]
for single in list:
data=WeixinItem()
title=single.xpath('a/text()').extract()
link=single.xpath('a/@href').extract()
data['title']=title
data['link']=link
if len(title)>0:
print(title[0].encode('utf-8'))
print(link)
　　3.在items.py中添加WeixinItem类
　　4.在items.py同级目录下创建一个下载中间件downloadwebkit.py，在里面写入如下代码：
　　import spynner
import pyquery
import time
import BeautifulSoup
import sys
from scrapy.http import HtmlResponse
class WebkitDownloaderTest( object ):
def process_request( self, request, spider ):
# if spider.name in settings.WEBKIT_DOWNLOADER:
# if( type(request) is not FormRequest ):
browser = spynner.Browser()
browser.create_webview()
browser.set_html_parser(pyquery.PyQuery)
browser.load(request.url, 20)
try:
browser.wait_load(10)
except:
pass
string = browser.html
string=string.encode('utf-8')
renderedBody = str(string)
return HtmlResponse( request.url, body=renderedBody )
　　这段代码是在网页加载完成后调用浏览器内核获取源码
　　5.在setting.py文件中配置并声明下载使用下载中间件
　　在底部添加以下代码：
　　#which spider should use WEBKIT
WEBKIT_DOWNLOADER=['weixinlist']
DOWNLOADER_MIDDLEWARES = {
'weixin.downloadwebkit.WebkitDownloaderTest': 543,
}
import os
os.environ["DISPLAY"] = ":0"
　　6.运行程序：
　　运行命令：
　　scrapy crawl weixinlist
　　运行结果：
<p>kevinflynndeMacBook-Pro:spiders kevinflynn$ scrapy crawl weixinlist
start init....
2015-07-28 21:13:55 [scrapy] INFO: Scrapy 1.0.1 started (bot: weixin)
2015-07-28 21:13:55 [scrapy] INFO: Optional features available: ssl, http11
2015-07-28 21:13:55 [scrapy] INFO: Overridden settings: {&#39;NEWSPIDER_MODULE&#39;: &#39;weixin.spiders&#39;, &#39;SPIDER_MODULES&#39;: [&#39;weixin.spiders&#39;], &#39;BOT_NAME&#39;: &#39;weixin&#39;}
2015-07-28 21:13:55 [py.warnings] WARNING: :0: UserWarning: You do not have a working installation of the service_identity module: &#39;No module named service_identity&#39;. Please install it from and make sure all of its dependencies are satisfied. Without the service_identity module and a recent enough pyOpenSSL to support it, Twisted can perform only rudimentary TLS client hostname verification. Many valid certificate/hostname mappings may be rejected.
2015-07-28 21:13:55 [scrapy] INFO: Enabled extensions: CloseSpider, TelnetConsole, LogStats, CoreStats, SpiderState
2015-07-28 21:13:55 [scrapy] INFO: Enabled downloader middlewares: HttpAuthMiddleware, DownloadTimeoutMiddleware, UserAgentMiddleware, RetryMiddleware, WebkitDownloaderTest, DefaultHeadersMiddleware, MetaRefreshMiddleware, HttpCompressionMiddleware, RedirectMiddleware, CookiesMiddleware, ChunkedTransferMiddleware, DownloaderStats
2015-07-28 21:13:55 [scrapy] INFO: Enabled spider middlewares: HttpErrorMiddleware, OffsiteMiddleware, RefererMiddleware, UrlLengthMiddleware, DepthMiddleware
2015-07-28 21:13:55 [scrapy] INFO: Enabled item pipelines:
2015-07-28 21:13:55 [scrapy] INFO: Spider opened
2015-07-28 21:13:55 [scrapy] INFO: Crawled 0 pages (at 0 pages/min), scraped 0 items (at 0 items/min)
2015-07-28 21:13:55 [scrapy] DEBUG: Telnet console listening on 127.0.0.1:6023
QFont::setPixelSize: Pixel size 查看全部

　　htmlunit抓取动态网页(邯郸SEO推荐最佳答案：蜘蛛爬行过程中要抓取伪静态的原理)
　　补充问题：我们的网站已经伪静态了，但是通过拆分日志，我们发现蜘蛛还是爬取了大量的动态文件。百度也有很多答案，但大部分答案都比较水。什么是正常的？机器人禁止他们。我现在想知道，首先，是什么导致了这种情况。想想蜘蛛的爬行模式，为什么会爬出动态地址呢？我问了程序方，确认没有入口。我想过这个问题。关于伪静态的原理，我不明白怎么爬到动态网址，而且是比较大的量。第二个是这种情况怎么处理，Robots禁止爬行，另一个是使用canonical标签（这个网站还没设置），请问各位兄弟，
　　邯郸SEO推荐最佳答案：伪静态并不是真正的静态，伪静态、动态和伪静态URL后的页面都可以正常打开网页。爬虫爬取伪静态页面有两种方法：一是爬到动态链接，然后网站跳转到伪静态链接，二是爬到伪静态链接直接地 。换句话说，这取决于网页的入口是什么样的。
　　回答你的两个问题：
　　A1：蜘蛛爬在前面，伪静态在后面。
　　在伪静态之前，蜘蛛已经爬取了大量的动态页面。比较伪静态前后的日志。如果动态链接重复，应该是蜘蛛在看爬取的页面有没有更新，不用管，做个301跳蜘蛛我去抓伪静态链接。如果链接不重复，并且有很多新的动态页面，那么肯定有提供给蜘蛛的动态链接的页面。要么是程序处理的问题。虽然是伪静态，但网页上的链接还是动态的；或者内部链接（页面、站点地图）、外部链接等都是左动态链接。
　　蜘蛛不会凭空创建链接来捕捉它。既然抓到了，就有蜘蛛爬进去的入口。你必须倾听并相信技术术语，但你必须验证自己。毕竟，这是你的工作。
　　A2：我觉得不应该先禁止机器人，要看网站的情况。
　　如果蜘蛛正在爬取伪静态链接，而且数量每天都在增加，而且之前爬过的动态页面，伪静态蜘蛛也爬过了，可以考虑使用robots来禁止动态链接的爬取。
　　如果蜘蛛没有重新爬取之前的页面，在robots被禁止之后，就意味着这些页面的收录很可能被清除了。我不会做这种事到死。301跳转我都会做，canonical标签也会加，站长工具里的网站改版也会用到。总之，我会尽量让蜘蛛重新抓到旧的伪静态页面，然后再考虑机器人。禁止动态抓取。 查看全部

　　htmlunit抓取动态网页(什么是HTML源码中的内容？如何对网页进行爬取呢？
)
　　我们之前抓取的网页大多是 HTML 静态生成的内容。您可以直接从 HTML 源代码中找到您看到的数据和内容。然而，并不是所有的网页都是这样。
　　网站的部分内容是前端JS动态生成的。由于网页呈现的内容是由JS生成的，我们可以在浏览器上看到，但在HTML源代码中是找不到的。比如今天的头条：
　　HTML源代码
　　网页上的新闻在HTML源代码中是找不到的，都是JS动态生成和加载的。
　　在这种情况下，我们应该如何抓取网页呢？有两种方式：
　　1、从网页响应中找到JS脚本返回的JSON数据；2、使用Selenium模拟访问网页
　　这里只介绍第一种方法。关于Selenium的使用有专门的文章。
　　一、从网页响应中查找JS脚本返回的JSON数据
　　即使网页内容是由JS动态生成和加载的，JS也需要调用一个接口，根据接口返回的JSON数据进行加载和渲染。
　　所以我们可以找到JS调用的数据接口，从数据接口中找到网页最后呈现的数据。
　　以今日头条为例来说明：
　　1、找到JS请求的数据接口
　　F12打开网页调试工具
　　网页调试工具
　　选择“网络”选项卡后，我们发现有很多响应。让我们过滤并只查看 XHR 响应。
　　（XHR 是 Ajax 中的一个概念，意思是 XMLHTTPrequest）
　　然后我们发现很多链接都没有了，随便点一个看看：
　　我们选择city，预览中有一串json数据：
　　原来它们都是城市列表，应该用来加载地区新闻。
　　现在你应该明白如何找到JS请求的接口了吧？但是我们刚才并没有找到我们想要的消息，所以再次查找：
　　有一个焦点，我们打开看看：
　　我们打开一个接口链接看看：
　　返回一串乱码，但是从响应中查看的是正常的编码数据：
　　有了对应的数据接口，我们就可以模仿前面的方法向数据接口请求并得到响应
　　2、请求和解析数据接口数据
　　先上传完整代码：
　　
import requests
import json
url = 'http://www.toutiao.com/api/pc/focus/'
wbdata = requests.get(url).text
data = json.loads(wbdata)
news = data['data']['pc_feed_focus']
# print news
for n in news:
title = n['title']
img_url = n['image_url']
url = n['media_url']
print(json.dumps(title).decode("unicode-escape"))
print img_url 查看全部

　　htmlunit抓取动态网页(1.HtmlUnit的学习方法是什么？怎么样？HtmlUnit)
　　1.HtmlUnit是一个用java编写的无界面浏览器，建模html文档，通过API调用页面，填写表单，点击链接等，像普通浏览器一样操作。通常用于测试和从网页中获取信息。而且HtmlUnit兼有HttpClient和soup的功能，但是速度比较慢，但是如果取消它解析css和js的功能，速度会有所提升，默认是开启的。
　　2. 这里选择HtmlUnit爬取数据的主要目的是为了获取他的js和css。
　　3.主要代码如下
　　package com.los;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.DomElement;
import com.gargoylesoftware.htmlunit.html.DomNodeList;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import com.los.util.DownlandPic;
import java.io.IOException;
import java.util.regex.Pattern;
public class HtmlUnitTest {

public static void main(String[] args) throws IOException {
DownlandPic dd = new DownlandPic();
WebClient webClient = new WebClient();//实例化web客户端
//http://www.bdqn.cn/ https://www.baidu.com/?tn=78000241_22_hao_pg
String url = "http://www.bdqn.cn/";
HtmlPage page = webClient.getPage(url);
webClient.waitForBackgroundJavaScript(10000); //等侍js脚本执行完成
System.out.println(page.asXml());
DomNodeList img = page.getElementsByTagName("script");
for (int i=0;i 0) {
output.write(buffer, 0, length);
}
fileOutputStream.write(output.toByteArray());
dataInputStream.close();
fileOutputStream.close();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static int getCharacterPosition3(String string){
//这里是获取"\""符号的位置
Matcher slashMatcher = Pattern.compile("\"").matcher(string);
int mIdx = 0;
while(slashMatcher.find()) {
mIdx++;
//当"/"符号第三次出现的位置
if(mIdx == 2){
break;
}
}
return slashMatcher.start();
}
public static int getCharacterPosition4(String string){
//这里是获取"\""符号的位置
Matcher slashMatcher = Pattern.compile("\"").matcher(string);
int mIdx = 0;
while(slashMatcher.find()) {
mIdx++;
//当"/"符号第三次出现的位置
if(mIdx == 3){
break;
}
}
return slashMatcher.start();
}
public static void main(String[] args) {
String content = "<img class=\"lazy\" data-original=\"/img/newImg/news_img2.jpg\" src=\"/img/newImg/news2.jpg\" style=\"display: block;\"/>";
System.out.println(getCharacterPosition3(content));
System.out.println(getCharacterPosition4(content));
String substring = content.substring(getCharacterPosition3(content), getCharacterPosition4(content));
System.out.println(substring);
}
}
　　3.因为这里的网页中的图片地址是相对路径，所以下载的时候在下载地址中找到了页面的绝对路径并拼接。下载的路径必须与抓取后存储在本地页面的image标签中的地址相对应，否则找不到。
　　3.匹配时写2和3的原因”是根据这里爬取的数据
　　
　　4.与其他爬取网页的方式相比，这可能更简单，但更容易展示效果。如有错误，请指教。至于页面，则不会显示，涉及隐私。
　　5.学习HtmlUnit请参考：地址 查看全部

　　htmlunit抓取动态网页(Java环境下的一下配置实现思路介绍-苏州安嘉
)
　　在抓取网页数据的时候，传统的jsoup方案只能对静态页面有效，而且一些网页数据往往是js生成的，所以这个时候就需要其他的方案了。
　　第一个思路是分析js程序，重新抓取js请求。这适用于特定页面的抓取。实现不同目标URL的通用性比较麻烦。
　　第二个想法，也是更成熟的方法，是使用第三方驱动程序来呈现页面，然后下载它。这里介绍第二种实现思路。
　　Selenium 是一种模拟浏览器的自动化测试工具。它提供了一组 API 来与真正的浏览器内核进行交互。
　　Java环境中的maven配置如下：
　　
org.seleniumhq.selenium
selenium-java
2.46.0

　　第三方驱动主要有IEDriver、FirefoxDriver、ChromeDriver、HtmlUnitDriver。
　　htmlUnit 也是自动化测试的工具。您可以使用 HtmlUnit 来模拟浏览器的操作来获取执行的 html 页面。其中HtmlUnitDriver是对htmlUnit的封装。
　　因为htmlunit对js解析的支持有限，所以在实际项目中并不常用。
　　以chrome为例下载对应的驱动：。
　　下载驱动时需要注意与selenium版本的兼容性。可能会出现异常情况。一般下载最新版本即可。
　　在程序运行之前必须确定驱动程序位置，例如在Windows下
　　System.getProperties().setProperty("webdriver.chrome.driver",
"D:\\chromedriver\\chromedriver.exe");
　　获取整个页面
　　 public static void testChromeDriver() {
System.getProperties().setProperty("webdriver.chrome.driver",
"D:\\chromedriver\\chromedriver.exe");
WebDriver webDriver = new ChromeDriver();
webDriver.get("http://picture.youth.cn/qtdb/2 ... 6quot;);
String responseBody = webDriver.getPageSource();
System.out.println(responseBody);
webDriver.close();
} 查看全部

　　htmlunit抓取动态网页(.xmlmaven依赖代码
)
　　今天，当使用jsoup作为爬虫程序时，我发现jsoup只能抓取静态页面，这对支持Ajax和JSON动态生成的页面不友好
　　因此，我尝试将param和data header与请求一起直接发送，希望直接返回JSON数据，但可能无法成功，因为网站接口不支持它
　　在尝试其他方法后，从互联网上发现htmlunit可以用来模拟浏览器，生成动态网页，然后用jsoup解析生成的动态网页
　　下面是pom.xml Maven依赖项代码
　　下面是Java代码
　　import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import java.io.IOException;
public class JsoupTest {
public static void main(String[] args) {
queryDocument("北斗");
}
public static void queryDocument(String documentName){
WebClient browser = new WebClient();
browser.getOptions().setCssEnabled(false);
browser.getOptions().setJavaScriptEnabled(true);
browser.getOptions().setThrowExceptionOnScriptError(false);
String url = "http://oar.nstl.gov.cn/Paper/S ... 3B%3B
try {
HtmlPage htmlPage = browser.getPage(url);
browser.waitForBackgroundJavaScript(3000);
Document document = Jsoup.parse(htmlPage.asXml());
Element paper = document.getElementById("paper");
System.out.println(paper);
} catch (IOException e) {
e.printStackTrace();
}
}
} 查看全部

　　htmlunit抓取动态网页(HtmlUnit+Jsoup背景在开发爬虫进行动态规则)
　　HtmlUnit+Jsoup
　　背景
　　当开发一个通过动态规则捕获数据的爬虫程序时，htmlunit在登录后无法通过cookie访问数据，并且互联网上的一系列文章无效
　　HtmlUnit
　　它可以理解为一个沙盒浏览器，它将获得整个网页的最终显示代码（收录动态加载数据的JS），人们看到的就是他们得到的
　　Jsoup
　　只能获取网页内容（不包括JS执行后的动态内容）。优点是可以通过jQuery选择器提取元素，例如#id、，。类等。htmlunit只能从本机JS文档中提取
　　问题描述
　　htmlUnit代码
　　/** HtmlUnit请求web页面 */
WebClient wc = new WebClient(BrowserVersion.CHROME);
wc.getOptions().setUseInsecureSSL(true);
wc.getOptions().setJavaScriptEnabled(true); // 启用JS解释器，默认为true
wc.getOptions().setCssEnabled(false); // 禁用css支持
wc.getOptions().setThrowExceptionOnScriptError(false); // js运行错误时，是否抛出异常
wc.getOptions().setTimeout(10 * 1000); // 设置连接超时时间 ，这里是10S。如果为0，则无限期等待
wc.waitForBackgroundJavaScript(10 * 1000); // 等待js后台执行30秒
wc.getOptions().setDoNotTrackEnabled(false);
//其他文章一贯的cookie设置方式-无效
//wc.getCookieManager().addCookie(new Cookie("domain域名","JSESSIONID","11"));
//改为以下方式
wc.addCookie("Cookie value长串不需要切割",new URL("目标网址"),"domain域名");
HtmlPage page = wc.getPage("目标网址");
　　此外，还遇到了以下棘手问题（未解决）
<p>//失败：通过改变支持ajax支持方式
wc.setAjaxControllr(new NicelyResynchronizingAjaxController());

//失败：循环判断内容，增加js-ajax执行时间
for (int i = 0; i 查看全部

　　htmlunit抓取动态网页(Java环境下的一下配置实现思路
)
　　在抓取网页数据的时候，传统的jsoup方案只能对静态页面有效，而且一些网页数据往往是js生成的，所以这个时候就需要其他的方案了。
　　第一个思路是分析js程序，重新抓取js请求。这适用于特定页面的抓取。实现不同目标URL的通用性比较麻烦。
　　第二个想法，也是更成熟的方法，是使用第三方驱动程序来呈现页面，然后下载它。这里介绍第二种实现思路。
　　Selenium 是一种模拟浏览器的自动化测试工具。它提供了一组 API 来与真正的浏览器内核进行交互。
　　Java环境中的maven配置如下：
　　
org.seleniumhq.selenium
selenium-java
2.46.0

　　第三方驱动主要有IEDriver、FirefoxDriver、ChromeDriver、HtmlUnitDriver。
　　htmlUnit 也是自动化测试的工具。您可以使用 HtmlUnit 来模拟浏览器的操作来获取执行的 html 页面。其中HtmlUnitDriver是对htmlUnit的封装。
　　因为htmlunit对js解析的支持有限，所以在实际项目中并不常用。
　　以chrome为例下载对应的驱动：。
　　下载驱动时需要注意与selenium版本的兼容性。可能会出现异常情况。一般下载最新版本即可。
　　在程序运行之前必须确定驱动程序位置，例如在Windows下
　　System.getProperties().setProperty("webdriver.chrome.driver",
"D:\\chromedriver\\chromedriver.exe");
　　获取整个页面
　　 public static void testChromeDriver() {
System.getProperties().setProperty("webdriver.chrome.driver",
"D:\\chromedriver\\chromedriver.exe");
WebDriver webDriver = new ChromeDriver();
webDriver.get("http://picture.youth.cn/qtdb/2 ... 6quot;);
String responseBody = webDriver.getPageSource();
System.out.println(responseBody);
webDriver.close();
} 查看全部

　　htmlunit抓取动态网页(Ajax技术一改传统的静态网页架构模式分析及案例分析)
　　[摘要]：Ajax技术改变了传统的静态网页架构模型，利用JavaScript事件执行、状态识别和切换特性，使网页可以动态改变网页内容，而无需全部刷新，造成网络资源传统网络无法使用的。Crawler 爬取已经成为一种区别于 Surface Web 的 Deep Web 资源。目前的Ajax网站构建技术已经得到广泛应用。但是，这导致大量的 Deep Web 资源被隐藏，无法被人们使用。因此，使用一种能够有效捕获Ajax动态脚本网页的方法来提取Deep Web资源变得越来越重要。本文首先分析了Ajax技术的原理和Deep Web资源产生的根源，然后讲解了网络爬虫技术的工作原理和爬虫系统的构建方法。使用软件工程方法，设计并实现了解析Ajax动态网页信息和抓取Spideep的能力，Spideep是一个抓取Deep Web网络资源的爬虫系统。本文详细介绍了深网爬虫系统的需求分析、大纲设计、详细设计、整体实现、模块实现的软件开发过程。系统分为三个主要模块，即生产线（Worker Line）模块和任务管理（Task management）模块。Manager）模块、URL调度（Scheduler）模块。
　　其中，产线模块包括四个子模块：Fetcher、Extractor、Filter、Writer。在系统实现中，针对Ajax页面的爬取，本文在爬虫系统中嵌入了一个无界面的浏览器HtmlUnit。初步分析和重构DOM树，然后利用HtmlUnit提供的大量web组件模拟浏览器的各种操作行为，如点击按钮、翻页、滑动等用户操作行为，进一步隐藏隐藏的Deep Web 信息动态地出现，最后使用 Web 解析工具 HtmlParser 或 Jsoup 解析 DOM 树，获取有价值的 Deep Web 信息。最后通过设计实验验证了支持Ajax的Deep Web爬虫系统Spideep的三个方面的性能，即：对Spideep系统的Ajax页面抓取能力、稳定性和有效性进行了详细分析，并对实验结果进行了详细分析。实验结果表明，Spideep系统性能良好，满足预期使用要求。 查看全部

　　htmlunit抓取动态网页(蚂蚁金服类隔离框架Maven打包插件解析|SOFAArk源码解析)
　　基于Apache Nutch和Htmlunit的扩展实现AJAX页面爬虫爬取解析插件请求错误
　　基于Apache Nutch和Htmlunit的扩展实现AJAX页面爬虫爬取解析插件----------------------------- ------ -------------------------------------------- ------------------------------ 提示：项目当前版本已停止更新，最新的Apache Nutch 2.X版本是...
　　蚂蚁金服轻量级类隔离框架Maven打包插件分析| SOFAArk 源码分析
　　SOFAStack（Scalable Open Financial Architecture Stack）是蚂蚁金服自主研发的金融级云原生架构。它收录构建金融级云原生架构所需的所有组件。这是金融场景中的最佳实践。本文是《分析|SOFAArk实现原理》的第二篇。本文作者为盲僧，来自OYO。《解析|SOFAArk实现原理》系列由SOFA团队和源码爱好者制作，项目代码：、正文...
　　Kubernetes新概念“Initializers”解析（上篇）：一种新的模型，可以让你为集群编写插件
　　Kubernetes现在能做到最好的原因有两个：一是社区优势无限；其次，它来自于 Kubernetes API 的灵活性以及在其上编写自定义扩展或插件的便利性。在本文中，我将深入分析一个新概念：Initalizers，它可以在实际创建之前修改Kubernetes动态资源和可插拔方法。初始化器已被用作 Kubernetes 1.7 中的 Alpha 功能。举起...
　　Kubernetes“Initializers”新概念解析（中）：让你为集群编写插件的新模型
　　初始化解析1. 配置需要初始化的资源类型： InitializerConfiguration (#configure-initializers-on-the-fly) 对象允许你配置为被初始化器划分...
　　分析 | K8S网络插件exec
　　K8S支持3种网络插件。今天继续介绍另一个插件execK8S网络插件，支持exec、CNI、kubenet 3种类型。插件只需要满足K8S网络插件接口即可。type NetworkPlugin interface{ Init(host Host, hairpinModecomponentconfig.HairpinMode) error Event(n...
　　Angularjs 配合三方js插件使用，通过模板动态解析angularjs语法
　　对静态会议进行数据分析。因为前后端分离，所以前端使用Angularjs框架，后端使用RESTFUL。'laypage',function(){laypage = layoutui.laypage ;});laypage.render({elem:'...
　　HPUX上安装nagios监控插件（NRPE）的难点分析
　　在HPUX上安装NRPE，尤其是在监控ORACLE数据库有一些难点的时候。我一边摸索一边整理，作为备忘录一、下载预编译depot源码包网址：包名：NRPE-2.12.depot.gz 可能还需要支持另外两个包。如果没有安装操作系统，请下载：openssl-1.0.1f-ia64-11.31.depot.gzt...
　　解决Nutch插件系统
　　一、在Nutch的插件架构下，需要解释一些术语。1、扩展点（ExtensionPoint） 扩展点是一个可以在系统中再次扩展的类或接口。一个扩展点的定义可以使系统的执行过程变得可插拔，可以任意改变。2、Extension（扩展） 扩展插件内部的一个属性。扩展是扩展点的实现。每个扩展可以有自己的附加属性，用于在同一个扩展点中实现.. 查看全部

　　htmlunit抓取动态网页(
robots协议（也称为爬虫协议、机器人协议等）的全称)
　　
　　动态网站不用担心，搜索引擎可以正常抓取动态链接，但是使用robots文件可以轻松提高动态网站的抓取效率。我们都知道robots协议（也叫爬虫协议、机器人协议等）的全称是“Robots Exclusion Protocol”。网站 告诉搜索引擎哪些页面可以爬取，哪些页面通过Robots 协议爬取。无法抓取该页面。Robots协议的本质是网站与搜索引擎爬虫之间的通信方式，用于引导搜索引擎更好地抓取网站的内容。
　　百度官方建议所有网站使用robots文件，以更好地利用蜘蛛爬行。实际上，robots 不仅是告诉搜索引擎哪些不能抓取，也是网站优化的重要工具之一。
　　robots文件实际上是一个txt文件。基本措辞如下：
　　User-agent: * 其中*代表所有类型的搜索引擎，*是通配符
　　disallow: /admin/ 这里的定义是禁止爬取admin目录下的目录
　　Disallow: /require/ 这里的定义是禁止爬取require目录下的目录
　　Disallow: /ABC/ 这里的定义是禁止爬取ABC目录下的目录
　　禁止：/cgi-bin/*.htm 禁止访问 /cgi-bin/ 目录中所有后缀为“.htm”的 URL（包括子目录）。
　　Disallow: /*?* 禁止访问 网站 中的所有动态页面
　　Disallow: /.jpg$ 禁止抓取网络上所有.jpg 格式的图片
　　Disallow:/ab/adc.html 禁止抓取ab文件夹下的adc.html文件。
　　Allow：这里定义了/cgi-bin/，允许爬取cgi-bin目录下的目录
　　Allow: /tmp 这里的定义是允许爬取tmp的整个目录
　　允许：.htm$ 只允许访问带有“.htm”后缀的 URL。
　　允许：.gif$ 允许抓取网页和 gif 格式的图像
　　在网站优化方面，robots文件用于告诉搜索引擎什么是重要的内容，推荐robots文件禁止爬取不重要的内容。不重要内容的典型代表：网站的搜索结果页。
　　对于静态网站，我们可以使用Disallow: /*?* 来禁止动态页面爬取。但是对于动态网站，你不能简单地做到这一点。不过对于动态网站的站长来说，就不用太担心了。搜索引擎现在可以正常抓取动态页面。所以在写的时候一定要注意，可以专门写到搜索文件的名字。例如，如果您的站点是 search.asp? 后面的一个长列表，那么您可以这样写：
　　禁止：/search.asp?*
　　这样就可以屏蔽搜索结果页面。写完之后可以在百度站长平台上查看robots，看看有没有错误！您可以输入 URL 来检查它是否正常工作。
　　在这里，吴晓阳建议动态网站的站长一定要用robots文件来屏蔽不重要的内容动态链接，提高蜘蛛的抓取效率！
　　本文来源：吴晓阳目录 查看全部

　　htmlunit抓取动态网页(使用Python代码的适用实例有哪些？WebScraping的基本原理)
　　本文主要介绍了Web刮板的基本原则，基于Python语言，大型紫红色，面向可爱的小白（^ - ^）。
　　易于混淆的名称：
　　多次，每个人都将在互联网上获取数据代码，统称为“爬行动物”，
　　但是，但事实上，所谓的“爬行动物”并不特别准确，因为“爬行动物”也分开，
　　常见的“爬行动物”有两个：
　　网爬虫，也称为蜘蛛; Web刮刀，也称为网络收获; Web数据提取
　　，这个文章，主要解释第二“web刮刀”的原理。
　　Web刮擦是什么？
　　简单的Web刮擦，（在本文中）是指使用Python代码，从肉眼可见的网页，抓住数据。
　　为什么需要Web Scraping？
　　因为有太多的重复，自己做到，你可能会筋疲力尽！
　　代码的适用示例是什么？例如，目前需要50种不同股票的价格，或者想想打印，新闻网站 ON，所有最新的新闻标题，或者只是想在网站 网站 网站的价格列出所有商品的价格。把它放到Excel比较等等，尝试您的想象力.....
　　Web Scraping的基本原理：
　　首先，您需要知道如何在我们的屏幕上呈现;
　　实际上，我们发送请求，然后在100公里外的服务器将返回我们;然后我们看了很多单词，最后，浏览器，偷偷摸摸了这堆文字，把它放在我们有屏幕上;如果你贬低原则，你可以去看Bo Wen，Http下午茶 - 小嘴进入
　　然后我们必须了解，使用python，如何实现它，实现原则基本上四个步骤：
　　首先，代码需要向服务器发送请求，然后接收响应（HTML文件），我们需要处理收到的响应，找到我们需要的文本，然后设计了代码进程，最后处理重复的任务，导出我们的数据，最好是美丽的Excel形式，摘要：
　　这个文章，专注于解释实现的想法和过程，
　　因此，它不详细，没有给出实际代码，
　　但是，这个想法几乎是可以掌握的一般例程。
　　写在这里，想想任何更新，
　　如果有一个地方，你也没有到位，也请结束！ 查看全部