网络爬虫实现全网搜索

1. 如何使用webcollector爬取搜索引擎

使用webcollector爬取搜索引擎，按照关键字搜索的结果页面，解析规则可能会随网络搜索的改版而失效。
代码如下：
[java] view plain
package com.wjd.key.crawler;

import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.TimeZone;

import org.apache.poi.poifs.filesystem.DirectoryEntry;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import cn.e.hfut.dmic.contentextractor.ContentExtractor;
import cn.e.hfut.dmic.webcollector.model.CrawlDatum;
import cn.e.hfut.dmic.webcollector.model.CrawlDatums;
import cn.e.hfut.dmic.webcollector.model.Page;
import cn.e.hfut.dmic.webcollector.plugin.ram.RamCrawler;

public class BdiKeywordCrawler extends RamCrawler{

private Connection connection;
private PreparedStatement pstatement;
// 连接MySql数据库，用户名root，密码mahao
String url = "jdbc:mysql://localhost:3306/wjd";
String username = "root";
String password = "mahao";
//保存抽取到的数据
StringBuilder result = new StringBuilder();
public BdiKeywordCrawler(String keyword, int maxPageNum) throws Exception {
for (int pageNum = 1; pageNum <= maxPageNum; pageNum++) {
String url = createUrl(keyword, pageNum);
CrawlDatum datum = new CrawlDatum(url)
.putMetaData("keyword", keyword)
.putMetaData("pageNum", pageNum + "")
.putMetaData("pageType", "searchEngine")
.putMetaData("depth", "1");
addSeed(datum);
}
}
@Override
public void visit(Page page, CrawlDatums next) {
String keyword = page.getMetaData("keyword");
String pageType = page.getMetaData("pageType");
int depth = Integer.valueOf(page.getMetaData("depth"));
if (pageType.equals("searchEngine")) {
int pageNum = Integer.valueOf(page.getMetaData("pageNum"));
System.out.println("成功抓取关键词" + keyword + "的第" + pageNum + "页搜索结果");
// || div[class=result-op c-container xpath-log ]>h3>a
Elements results = page.select("div[class=result c-container ]>h3>a");
// Elements results1 = page.select("div[class=result-op c-container xpath-log]>h3>a");//,div[id=result-op c-container xpath-log]>h3>a
//System.out.println(results1.get(0));
//results.add(results1.get(0));
for (int rank = 0; rank < results.size(); rank++) {
Element result = results.get(rank);
/*
* 我们希望继续爬取每条搜索结果指向的网页，这里统称为外链。
* 我们希望在访问外链时仍然能够知道外链处于搜索引擎的第几页、第几条，
* 所以将页号和排序信息放入后续的CrawlDatum中，为了能够区分外链和
* 搜索引擎结果页面，我们将其pageType设置为outlink，这里的值完全由 用户定义，可以设置一个任意的值
* 在经典爬虫中，每个网页都有一个refer信息，表示当前网页的链接来源。
* 例如我们首先访问新浪首页，然后从新浪首页中解析出了新的新闻链接，
* 则这些网页的refer值都是新浪首页。WebCollector不直接保存refer值，
* 但我们可以通过下面的方式，将refer信息保存在metaData中，达到同样的效果。
* 经典爬虫中锚文本的存储也可以通过下面方式实现。
* 在一些需求中，希望得到当前页面在遍历树中的深度，利用metaData很容易实现
* 这个功能，在将CrawlDatum添加到next中时，将其depth设置为当前访问页面 的depth+1即可。
*/
CrawlDatum datum = new CrawlDatum(result.attr("abs:href"))
.putMetaData("keyword", keyword)
.putMetaData("pageNum", pageNum + "")
.putMetaData("rank", rank + "")
.putMetaData("pageType", "outlink")
.putMetaData("depth", (depth + 1) + "")
.putMetaData("refer", page.getUrl());
next.add(datum);
}
} else if (pageType.equals("outlink")) {
/*int pageNum = Integer.valueOf(page.getMetaData("pageNum"));
int rank = Integer.valueOf(page.getMetaData("rank"));
String refer = page.getMetaData("refer");*/
try {
String content = ContentExtractor.getContentByUrl(page.getUrl());
/*String line = String.format(
"第%s页第%s个结果:标题:%s(%s字节)\tdepth=%s\trefer=%s", pageNum,
rank + 1, page.getDoc().title(), content,
depth, refer);*/
String line = String.format("标题：%s\n来源：%s\n正文：%s", page.getDoc().title(),page.getUrl(),content);
HashMap<String, String> data = new HashMap<String,String>();
Date currentDate = new java.util.Date();
SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
TimeZone timeZoneChina = TimeZone.getTimeZone("Asia/Shanghai");// 获取中国的时区
myFmt.setTimeZone(timeZoneChina);// 设置系统时区
String grabTime = myFmt.format(currentDate);// new Date()为获取当前系统时间
data.put("title", page.getDoc().title());
data.put("from", page.getUrl());
data.put("content", content);
data.put("grabTime", grabTime);
//String line = String.format("标题：%s\n", page.getDoc().title());
//持久化到word文档中
//是否为线程安全？？？
//synchronized(this) {
String destFile = "D:\\"+"Result"+keyword+".doc";
result.append(line);
//将result写到doc文件中
write2File(destFile,result.toString());
//添加到数据库中
addResultData(data);
//}
System.out.println(line);
} catch (Exception e) {
//e.printStackTrace();
System.out.println("链接"+page.getUrl()+"失效");
}
}
}
//将数据保存到mysql数据库中
private void addResultData(HashMap<String, String> data) {

String title = data.get("title");
String source_url = data.get("from");
String content = data.get("content").replaceAll("\\?{2,}", "");//去掉字符串中出现的多个连续问号。
//抓取时间
String grabTime = data.get("grabTime");
/*SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = null;
try {
date = format.parse(grabTime);
} catch (Exception e) {
e.printStackTrace();
}*/
//System.out.println("抓取时间"+grabTime);
try {
connection = DriverManager.getConnection(url, username, password);
String sql = "INSERT INTO wjd_keyword_search_table(TITLE,GRAP_TIME,CONTENT,SOURCE_URL) VALUES(?,?,?,?)";
String checkSql = "select 1 from wjd_keyword_search_table where TITLE='" + title + "'";
Statement statement = connection.prepareStatement(checkSql);
ResultSet result = statement.executeQuery(checkSql);
if (!result.next()) {
// 如果数据库中不存在该记录，则添加到数据库中
pstatement = connection.prepareStatement(sql);
pstatement.setString(1, title);
//pstatement.setString(2, date);
pstatement.setString(2,grabTime);
pstatement.setString(3, content);
pstatement.setString(4, source_url);
pstatement.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 将数据持久化到本地doc文件中
* @param destFile
* @param line
*/
private void write2File(String destFile, String line) {
try {
//doc content
ByteArrayInputStream s = new ByteArrayInputStream(line.getBytes());
POIFSFileSystem fs = new POIFSFileSystem();
DirectoryEntry directory = fs.getRoot();
directory.createDocument("WordDocument", s);
FileOutputStream ostream = new FileOutputStream(destFile);
fs.writeFilesystem(ostream);
s.close();
ostream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
String[] keywordsList = {"网络爬虫","搜索引擎"};
int pageToal =5;
for (String keyword : keywordsList) {
BdiKeywordCrawler crawler = new BdiKeywordCrawler(keyword, pageToal);
crawler.start();
}
}

/**
* 根据关键词和页号拼接网络搜索对应的URL
*/
public static String createUrl(String keyword, int pageNum)
throws Exception {
int first = (pageNum-1) * 10;
keyword = URLEncoder.encode(keyword, "utf-8");
return String.format("https://www..com/s?wd=%s&pn=%s",
keyword, first);
}
}

2. 网络爬虫可以采用的搜索方法

1.人为给定一个URL作为入口网页，数据的爬取从这里开始。
2.分别用抓取队列和完成队列来保存处于不同状态的链接。
3.爬虫程序从抓取队列读取队首URL，如果存在，则继续执行下去，否则停止爬取。
4.每处理完一个URL，将其放入完成队列，防止网页的重复访问。
5.每次抓取网页之后分析其中的URL，将经过过滤的合法链接写入完成队列，等待查询。
6.重复步骤3-5直至满足结束条件。

3. 一个网站除了百度以外爬虫其爬虫是那哪些呀

网络爬虫按照系统结构和实现技术，大致可以分为以下几种类型：通用网络爬
虫（General Purpose Web Crawler）、聚焦网络爬虫（Focused Web
Crawler）、增量式网络爬虫（Incremental Web Crawler）、深层网络爬虫（Deep Web Crawler）。
实际的网络爬虫系统通常是几种爬虫技术相结合实现的[1]
。

通用网络爬虫

通用网络爬虫又称全网爬虫（Scalable Web
Crawler），爬行对象从一些种子 URL 扩充到整个 Web，主要为门户站点搜索引擎和大型 Web 服务提供商采集数据。
由于商业原因，它们的技术细节很少公布出来。
这类网络爬虫的爬行范围和数量巨大，对于爬行速度和存储空间要求较高，对于爬行页面的顺序要求相对较低，同时由于待刷新的页面太多，通常采用并行工作方
式，但需要较长时间才能刷新一次页面。 虽然存在一定缺陷，通用网络爬虫适用于为搜索引擎搜索广泛的主题，有较强的应用价值[1]
。

通用网络爬虫的结构大致可以分为页面爬行模块 、页面分析模块、链接过滤模块、页面数据库、URL 队列、初始 URL 集合几个部分。为提高工作效率，通用网络爬虫会采取一定的爬行策略。 常用的爬行策略有：深度优先策略、广度优先策略[1]
。

1)
深度优先策略：其基本方法是按照深度由低到高的顺序，依次访问下一级网页链接，直到不能再深入为止。
爬虫在完成一个爬行分支后返回到上一链接节点进一步搜索其它链接。 当所有链接遍历完后，爬行任务结束。 这种策略比较适合垂直搜索或站内搜索，
但爬行页面内容层次较深的站点时会造成资源的巨大浪费[1]
。

2)
广度优先策略：此策略按照网页内容目录层次深浅来爬行页面，处于较浅目录层次的页面首先被爬行。
当同一层次中的页面爬行完毕后，爬虫再深入下一层继续爬行。
这种策略能够有效控制页面的爬行深度，避免遇到一个无穷深层分支时无法结束爬行的问题，实现方便，无需存储大量中间节点，不足之处在于需较长时间才能爬行
到目录层次较深的页面[1]
。

聚焦网络爬虫

聚焦网络爬虫（Focused
Crawler），又称主题网络爬虫（Topical Crawler），是指选择性地爬行那些与预先定义好的主题相关页面的网络爬虫[8]。
和通用网络爬虫相比，聚焦爬虫只需要爬行与主题相关的页面，极大地节省了硬件和网络资源，保存的页面也由于数量少而更新快，还可以很好地满足一些特定人群
对特定领域信息的需求[1]
。

聚焦网络爬虫和通用网络爬虫相比，增加了链接评价模块以及内容评价模块。聚焦爬虫爬行策略实现的关键是评价页面内容和链接的重要性，不同的方法计算出的重要性不同，由此导致链接的访问顺序也不同[1]
。

1)
基于内容评价的爬行策略：DeBra将文本相似度的计算方法引入到网络爬虫中，提出了 Fish Search
算法，它将用户输入的查询词作为主题，包含查询词的页面被视为与主题相关，其局限性在于无法评价页面与主题相关 度 的 高 低 。
Herseovic对 Fish Search 算 法 进 行 了 改 进 ，提 出 了 Sharksearch
算法，利用空间向量模型计算页面与主题的相关度大小[1]
。

2) 基于链接结构评价的爬行策略 ：Web
页面作为一种半结构化文档，包含很多结构信息，可用来评价链接重要性。 PageRank
算法最初用于搜索引擎信息检索中对查询结果进行排序，也可用于评价链接重要性，具体做法就是每次选择 PageRank 值较大页面中的链接来访问。
另一个利用 Web结构评价链接价值的方法是 HITS 方法，它通过计算每个已访问页面的 Authority 权重和 Hub
权重，并以此决定链接的访问顺序[1]
。

3) 基于增强学习的爬行策略：Rennie 和 McCallum 将增强学习引入聚焦爬虫，利用贝叶斯分类器，根据整个网页文本和链接文本对超链接进行分类，为每个链接计算出重要性，从而决定链接的访问顺序[1]
。

4) 基于语境图的爬行策略：Diligenti
等人提出了一种通过建立语境图（Context Graphs）学习网页之间的相关度，训练一个机器学习系统，通过该系统可计算当前页面到相关 Web
页面的距离，距离越近的页面中的链接优先访问。印度理工大学（IIT）和 IBM 研究中心的研究人员开发了一个典型的聚焦网络爬虫。
该爬虫对主题的定义既不是采用关键词也不是加权矢量，而是一组具有相同主题的网页。
它包含两个重要模块：一个是分类器，用来计算所爬行的页面与主题的相关度，确定是否与主题相关；另一个是净化器，用来识别通过较少链接连接到大量相关页面
的中心页面[1]
。

增量式网络爬虫

增量式网络爬虫（Incremental Web Crawler）是 指
对 已 下 载 网 页 采 取 增 量式更新和只爬行新产生的或者已经发生变化网页的爬虫，它能够在一定程度上保证所爬行的页面是尽可能新的页面。
和周期性爬行和刷新页面的网络爬虫相比，增量式爬虫只会在需要的时候爬行新产生或发生更新的页面
，并不重新下载没有发生变化的页面，可有效减少数据下载量，及时更新已爬行的网页，减小时间和空间上的耗费，但是增加了爬行算法的复杂度和实现难度。增量
式网络爬虫的体系结构[包含爬行模块、排序模块、更新模块、本地页面集、待爬行 URL 集以及本地页面URL 集[1]
。

增量式爬虫有两个目标：保持本地页面集中存储的页面为最新页面和提高本地
页面集中页面的质量。 为实现第一个目标，增量式爬虫需要通过重新访问网页来更新本地页面集中页面内容，常用的方法有：1)
统一更新法：爬虫以相同的频率访问所有网页，不考虑网页的改变频率；2) 个体更新法：爬虫根据个体网页的改变频率来重新访问各页面；3)
基于分类的更新法：爬虫根据网页改变频率将其分为更新较快网页子集和更新较慢网页子集两类，然后以不同的频率访问这两类网页[1]
。

为实现第二个目标，增量式爬虫需要对网页的重要性排序，常用的策略有：广
度优先策略、PageRank 优先策略等。IBM 开发的
WebFountain是一个功能强大的增量式网络爬虫，它采用一个优化模型控制爬行过程，并没有对页面变化过程做任何统计假设，而是采用一种自适应的方
法根据先前爬行周期里爬行结果和网页实际变化速度对页面更新频率进行调整。北京大学的天网增量爬行系统旨在爬行国内
Web，将网页分为变化网页和新网页两类，分别采用不同爬行策略。
为缓解对大量网页变化历史维护导致的性能瓶颈，它根据网页变化时间局部性规律，在短时期内直接爬行多次变化的网页
，为尽快获取新网页，它利用索引型网页跟踪新出现网页[1]
。

Deep Web 爬虫

Web 页面按存在方式可以分为表层网页（Surface
Web）和深层网页（Deep Web，也称 Invisible Web Pages 或 Hidden Web）。
表层网页是指传统搜索引擎可以索引的页面，以超链接可以到达的静态网页为主构成的 Web 页面。Deep Web
是那些大部分内容不能通过静态链接获取的、隐藏在搜索表单后的，只有用户提交一些关键词才能获得的 Web
页面。例如那些用户注册后内容才可见的网页就属于 Deep Web。 2000 年 Bright Planet 指出：Deep Web
中可访问信息容量是 Surface Web 的几百倍，是互联网上最大、发展最快的新型信息资源[1]
。

Deep Web 爬虫体系结构包含六个基本功能模块
（爬行控制器、解析器、表单分析器、表单处理器、响应分析器、LVS 控制器）和两个爬虫内部数据结构（URL 列表、LVS 表）。 其中
LVS（Label Value Set）表示标签/数值集合，用来表示填充表单的数据源[1]
。

Deep Web 爬虫爬行过程中最重要部分就是表单填写，包含两种类型：

1)
基于领域知识的表单填写：此方法一般会维持一个本体库，通过语义分析来选取合适的关键词填写表单。 Yiyao Lu[25]等人提出一种获取 Form
表单信息的多注解方法，将数据表单按语义分配到各个组中
，对每组从多方面注解，结合各种注解结果来预测一个最终的注解标签；郑冬冬等人利用一个预定义的领域本体知识库来识别 Deep Web 页面内容，
同时利用一些来自 Web 站点导航模式来识别自动填写表单时所需进行的路径导航[1]
。

2) 基于网页结构分析的表单填写：
此方法一般无领域知识或仅有有限的领域知识，将网页表单表示成 DOM 树，从中提取表单各字段值。 Desouky 等人提出一种 LEHW
方法，该方法将 HTML 网页表示为DOM 树形式，将表单区分为单属性表单和多属性表单，分别进行处理；孙彬等人提出一种基于 XQuery
的搜索系统，它能够模拟表单和特殊页面标记切换，把网页关键字切换信息描述为三元组单元，按照一定规则排除无效表单，将 Web 文档构造成 DOM
树，利用 XQuery 将文字属性映射到表单字段[1]
。

Raghavan 等人提出的 HIWE 系统中，爬行管理器负责管理整个爬行过程，分析下载的页面，将包含表单的页面提交表单处理器处理，表单处理器先从页面中提取表单，从预先准备好的数据集中选择数据自动填充并提交表单，由爬行控制器下载相应的结果页面[1]
。

4. 请问什么是网络爬虫啊是干什么的呢

网络爬虫（抄Web crawler）是一种按照袭一定的规则，自动地抓取万维网信息的程序或者脚本。

网络爬虫被广泛用于互联网搜索引擎或其他类似网站，可以自动采集所有其能够访问到的页面内容，以获取或更新这些网站的内容和检索方式。

(4)网络爬虫实现全网搜索扩展阅读：

许多网站针对爬虫都设置了反爬虫机制。常见的有：

1、登陆限制：通过模拟登陆可以解决

2、用户代理检测：通过设置User-Agent header

3、Referer检测：通过设置Referer header

4、访问频率限制：如果是针对同一账号的频率限制，则可以使用多个账号轮流发请求；如果针对IP，可通过IP代理；还可以为相邻的两个请求设置合适的时间间隔来，减小请求频率，从而避免被服务端认定为爬虫。

5. 如何用python实现在爬取到某网页搜索框中，并输入文字后，自动搜索信息并抓取

网络爬虫只能根据你指定的url爬取网页的html代码，至于你想要包含指定内容的网页的话，只能先爬取下来网页，然后在对页面内容进行匹配(正则，也有开源工具)找到你想要的内容就可以了!顺便说一句网络爬虫不能根据关键字来爬取网页!

6. 网络爬虫主要能干啥

网络爬虫是一种互联网机器人，它通过爬取互联网上网站的内容来工作。它是用计算机语言编写的程序或脚本，用于自动从Internet上获取任何信息或数据。机器人扫描并抓取每个所需页面上的某些信息，直到处理完所有能正常打开的页面。

网络爬虫大致有4种类型的结构：通用网络爬虫、聚焦网络爬虫、增量式网络爬虫、深层网络爬虫 。

1、通用Web爬虫

通用网络爬虫所爬取的目标数据是巨大的，并且爬行的范围也是非常大的，正是由于其爬取的数据是海量数据，故而对于这类爬虫来说，其爬取的性能要求是非常高的。这种网络爬虫主要应用于大型搜索引擎中，有非常高的应用价值。 或者应用于大型数据提供商。

2、聚焦网络爬虫

聚焦网络爬虫是按照预先定义好的主题有选择地进行网页爬取的一种爬虫，聚焦网络爬虫不像通用网络爬虫一样将目标资源定位在全互联网中，而是将爬取的目标网页定位在与主题相关的页面中，此时，可以大大节省爬虫爬取时所需的带宽资源和服务器资源。聚焦网络爬虫主要应用在对特定信息的爬取中，主要为某一类特定的人群提供服务。

3、增量Web爬虫

增量式网络爬虫，在爬取网页的时候，只爬取内容发生变化的网页或者新产生的网页，对于未发生内容变化的网页，则不会爬取。增量式网络爬虫在一定程度上能够保证所爬取的页面，尽可能是新页面。

4、深层网络爬虫

在互联网中，网页按存在方式分类，可以分为表层页面和深层页面。所谓的表层页面，指的是不需要提交表单，使用静态的链接就能够到达的静态页面；而深层页面则隐藏在表单后面，不能通过静态链接直接获取，是需要提交一定的关键词之后才能够获取得到的页面。在互联网中，深层页面的数量往往比表层页面的数量要多很多，故而，我们需要想办法爬取深层页面。

网络爬虫可以做什么？

由于互联网和物联网的蓬勃发展，人与网络之间的互动正在发生。每次我们在互联网上搜索时，网络爬虫都会帮助我们获取所需的信息。此外，当需要从Web访问大量非结构化数据时，我们可以使用Web爬网程序来抓取数据。

1、Web爬虫作为搜索引擎的重要组成部分

使用聚焦网络爬虫实现任何门户网站上的搜索引擎或搜索功能。它有助于搜索引擎找到与搜索主题具有最高相关性的网页。

对于搜索引擎，网络爬虫有帮助，为用户提供相关且有效的内容， 创建所有访问页面的快照以供后续处理。

2、建立数据集

网络爬虫的另一个好用途是建立数据集以用于研究，业务和其他目的。

· 了解和分析网民对公司或组织的行为

· 收集营销信息，并在短期内更好地做出营销决策。

· 从互联网收集信息并分析它们进行学术研究。

· 收集数据，分析一个行业的长期发展趋势。

· 监控竞争对手的实时变化

7. 网络爬虫是地毯式搜索吗

是。网络爬虫都是非常仔细的进行全面的搜索，所以是地毯式搜索。爬虫就是通过一定的规则策略，自动抓取、下载互联网上网页，在按照某些规则算法对这些网页进行数据抽取、索引。

8. Java网络爬虫怎么实现

网络爬虫是一个自动提取网页的程序，它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成。x0dx0a传统爬虫从一个或若干初始网页的URL开始，获得初始网页上的URL，在抓取网页的过程中，不断从当前页面上抽取新的URL放入队列，直到满足系统的一定停止条件。对于垂直搜索来说，聚焦爬虫，即有针对性地爬取特定主题网页的爬虫，更为适合。x0dx0ax0dx0a以下是一个使用java实现的简单爬虫核心代码：x0dx0apublic void crawl() throws Throwable { x0dx0a while (continueCrawling()) { x0dx0a CrawlerUrl url = getNextUrl(); //获取待爬取队列中的下一个URL x0dx0a if (url != null) { x0dx0a printCrawlInfo(); x0dx0a String content = getContent(url); //获取URL的文本信息 x0dx0a x0dx0a //聚焦爬虫只爬取与主题内容相关的网页，这里采用正则匹配简单处理 x0dx0a if (isContentRelevant(content, this.regexpSearchPattern)) { x0dx0a saveContent(url, content); //保存网页至本地 x0dx0a x0dx0a //获取网页内容中的链接，并放入待爬取队列中 x0dx0a Collection urlStrings = extractUrls(content, url); x0dx0a addUrlsToUrlQueue(url, urlStrings); x0dx0a } else { x0dx0a System.out.println(url + " is not relevant ignoring ..."); x0dx0a } x0dx0a x0dx0a //延时防止被对方屏蔽 x0dx0a Thread.sleep(this.delayBetweenUrls); x0dx0a } x0dx0a } x0dx0a closeOutputStream(); x0dx0a}x0dx0aprivate CrawlerUrl getNextUrl() throws Throwable { x0dx0a CrawlerUrl nextUrl = null; x0dx0a while ((nextUrl == null) && (!urlQueue.isEmpty())) { x0dx0a CrawlerUrl crawlerUrl = this.urlQueue.remove(); x0dx0a //doWeHavePermissionToVisit：是否有权限访问该URL，友好的爬虫会根据网站提供的"Robot.txt"中配置的规则进行爬取 x0dx0a //isUrlAlreadyVisited：URL是否访问过，大型的搜索引擎往往采用BloomFilter进行排重，这里简单使用HashMap x0dx0a //isDepthAcceptable：是否达到指定的深度上限。爬虫一般采取广度优先的方式。一些网站会构建爬虫陷阱（自动生成一些无效链接使爬虫陷入死循环），采用深度限制加以避免 x0dx0a if (doWeHavePermissionToVisit(crawlerUrl) x0dx0a && (!isUrlAlreadyVisited(crawlerUrl)) x0dx0a && isDepthAcceptable(crawlerUrl)) { x0dx0a nextUrl = crawlerUrl; x0dx0a // System.out.println("Next url to be visited is " + nextUrl); x0dx0a } x0dx0a } x0dx0a return nextUrl; x0dx0a}x0dx0aprivate String getContent(CrawlerUrl url) throws Throwable { x0dx0a //HttpClient4.1的调用与之前的方式不同 x0dx0a HttpClient client = new DefaultHttpClient(); x0dx0a HttpGet httpGet = new HttpGet(url.getUrlString()); x0dx0a StringBuffer strBuf = new StringBuffer(); x0dx0a HttpResponse response = client.execute(httpGet); x0dx0a if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) { x0dx0a HttpEntity entity = response.getEntity(); x0dx0a if (entity != null) { x0dx0a BufferedReader reader = new BufferedReader( x0dx0a new InputStreamReader(entity.getContent(), "UTF-8")); x0dx0a String line = null; x0dx0a if (entity.getContentLength() > 0) { x0dx0a strBuf = new StringBuffer((int) entity.getContentLength()); x0dx0a while ((line = reader.readLine()) != null) { x0dx0a strBuf.append(line); x0dx0a } x0dx0a } x0dx0a } x0dx0a if (entity != null) { x0dx0a nsumeContent(); x0dx0a } x0dx0a } x0dx0a //将url标记为已访问 x0dx0a markUrlAsVisited(url); x0dx0a return strBuf.toString(); x0dx0a}x0dx0apublic static boolean isContentRelevant(String content, x0dx0aPattern regexpPattern) { x0dx0a boolean retValue = false; x0dx0a if (content != null) { x0dx0a //是否符合正则表达式的条件 x0dx0a Matcher m = regexpPattern.matcher(content.toLowerCase()); x0dx0a retValue = m.find(); x0dx0a } x0dx0a return retValue; x0dx0a}x0dx0apublic List extractUrls(String text, CrawlerUrl crawlerUrl) { x0dx0a Map urlMap = new HashMap(); x0dx0a extractHttpUrls(urlMap, text); x0dx0a extractRelativeUrls(urlMap, text, crawlerUrl); x0dx0a return new ArrayList(urlMap.keySet()); x0dx0a} x0dx0aprivate void extractHttpUrls(Map urlMap, String text) { x0dx0a Matcher m = (text); x0dx0a while (m.find()) { x0dx0a String url = m.group(); x0dx0a String[] terms = url.split("a href=\""); x0dx0a for (String term : terms) { x0dx0a // System.out.println("Term = " + term); x0dx0a if (term.startsWith("http")) { x0dx0a int index = term.indexOf("\""); x0dx0a if (index > 0) { x0dx0a term = term.substring(0, index); x0dx0a } x0dx0a urlMap.put(term, term); x0dx0a System.out.println("Hyperlink: " + term); x0dx0a } x0dx0a } x0dx0a } x0dx0a} x0dx0aprivate void extractRelativeUrls(Map urlMap, String text, x0dx0a CrawlerUrl crawlerUrl) { x0dx0a Matcher m = relativeRegexp.matcher(text); x0dx0a URL textURL = crawlerUrl.getURL(); x0dx0a String host = textURL.getHost(); x0dx0a while (m.find()) { x0dx0a String url = m.group(); x0dx0a String[] terms = url.split("a href=\""); x0dx0a for (String term : terms) { x0dx0a if (term.startsWith("/")) { x0dx0a int index = term.indexOf("\""); x0dx0a if (index > 0) { x0dx0a term = term.substring(0, index); x0dx0a } x0dx0a String s = //" + host + term; x0dx0a urlMap.put(s, s); x0dx0a System.out.println("Relative url: " + s); x0dx0a } x0dx0a } x0dx0a } x0dx0a x0dx0a}x0dx0apublic static void main(String[] args) { x0dx0a try { x0dx0a String url = ""; x0dx0a Queue urlQueue = new LinkedList(); x0dx0a String regexp = "java"; x0dx0a urlQueue.add(new CrawlerUrl(url, 0)); x0dx0a NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L, x0dx0a regexp); x0dx0a // boolean allowCrawl = crawler.areWeAllowedToVisit(url); x0dx0a // System.out.println("Allowed to crawl: " + url + " " + x0dx0a // allowCrawl); x0dx0a crawler.crawl(); x0dx0a } catch (Throwable t) { x0dx0a System.out.println(t.toString()); x0dx0a t.printStackTrace(); x0dx0a } x0dx0a}

9. Java网络爬虫怎么实现

网络爬虫是一个自动提取网页的程序，它为搜索引擎从万维网上下载网页，是搜索引擎的重要组成。
传统爬虫从一个或若干初始网页的URL开始，获得初始网页上的URL，在抓取网页的过程中，不断从当前页面上抽取新的URL放入队列，直到满足系统的一定停止条件。对于垂直搜索来说，聚焦爬虫，即有针对性地爬取特定主题网页的爬虫，更为适合。

以下是一个使用java实现的简单爬虫核心代码：
public void crawl() throws Throwable {
while (continueCrawling()) {
CrawlerUrl url = getNextUrl(); //获取待爬取队列中的下一个URL
if (url != null) {
printCrawlInfo();
String content = getContent(url); //获取URL的文本信息

//聚焦爬虫只爬取与主题内容相关的网页，这里采用正则匹配简单处理
if (isContentRelevant(content, this.regexpSearchPattern)) {
saveContent(url, content); //保存网页至本地

//获取网页内容中的链接，并放入待爬取队列中
Collection urlStrings = extractUrls(content, url);
addUrlsToUrlQueue(url, urlStrings);
} else {
System.out.println(url + " is not relevant ignoring ...");
}

//延时防止被对方屏蔽
Thread.sleep(this.delayBetweenUrls);
}
}
closeOutputStream();
}
private CrawlerUrl getNextUrl() throws Throwable {
CrawlerUrl nextUrl = null;
while ((nextUrl == null) && (!urlQueue.isEmpty())) {
CrawlerUrl crawlerUrl = this.urlQueue.remove();
//doWeHavePermissionToVisit：是否有权限访问该URL，友好的爬虫会根据网站提供的"Robot.txt"中配置的规则进行爬取
//isUrlAlreadyVisited：URL是否访问过，大型的搜索引擎往往采用BloomFilter进行排重，这里简单使用HashMap
//isDepthAcceptable：是否达到指定的深度上限。爬虫一般采取广度优先的方式。一些网站会构建爬虫陷阱（自动生成一些无效链接使爬虫陷入死循环），采用深度限制加以避免
if (doWeHavePermissionToVisit(crawlerUrl)
&& (!isUrlAlreadyVisited(crawlerUrl))
&& isDepthAcceptable(crawlerUrl)) {
nextUrl = crawlerUrl;
// System.out.println("Next url to be visited is " + nextUrl);
}
}
return nextUrl;
}
private String getContent(CrawlerUrl url) throws Throwable {
//HttpClient4.1的调用与之前的方式不同
HttpClient client = new DefaultHttpClient();
HttpGet httpGet = new HttpGet(url.getUrlString());
StringBuffer strBuf = new StringBuffer();
HttpResponse response = client.execute(httpGet);
if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
HttpEntity entity = response.getEntity();
if (entity != null) {
BufferedReader reader = new BufferedReader(
new InputStreamReader(entity.getContent(), "UTF-8"));
String line = null;
if (entity.getContentLength() > 0) {
strBuf = new StringBuffer((int) entity.getContentLength());
while ((line = reader.readLine()) != null) {
strBuf.append(line);
}
}
}
if (entity != null) {
nsumeContent();
}
}
//将url标记为已访问
markUrlAsVisited(url);
return strBuf.toString();
}
public static boolean isContentRelevant(String content,
Pattern regexpPattern) {
boolean retValue = false;
if (content != null) {
//是否符合正则表达式的条件
Matcher m = regexpPattern.matcher(content.toLowerCase());
retValue = m.find();
}
return retValue;
}
public List extractUrls(String text, CrawlerUrl crawlerUrl) {
Map urlMap = new HashMap();
extractHttpUrls(urlMap, text);
extractRelativeUrls(urlMap, text, crawlerUrl);
return new ArrayList(urlMap.keySet());
}
private void extractHttpUrls(Map urlMap, String text) {
Matcher m = (text);
while (m.find()) {
String url = m.group();
String[] terms = url.split("a href=\"");
for (String term : terms) {
// System.out.println("Term = " + term);
if (term.startsWith("http")) {
int index = term.indexOf("\"");
if (index > 0) {
term = term.substring(0, index);
}
urlMap.put(term, term);
System.out.println("Hyperlink: " + term);
}
}
}
}
private void extractRelativeUrls(Map urlMap, String text,
CrawlerUrl crawlerUrl) {
Matcher m = relativeRegexp.matcher(text);
URL textURL = crawlerUrl.getURL();
String host = textURL.getHost();
while (m.find()) {
String url = m.group();
String[] terms = url.split("a href=\"");
for (String term : terms) {
if (term.startsWith("/")) {
int index = term.indexOf("\"");
if (index > 0) {
term = term.substring(0, index);
}
String s = //" + host + term;
urlMap.put(s, s);
System.out.println("Relative url: " + s);
}
}
}

}
public static void main(String[] args) {
try {
String url = "";
Queue urlQueue = new LinkedList();
String regexp = "java";
urlQueue.add(new CrawlerUrl(url, 0));
NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L,
regexp);
// boolean allowCrawl = crawler.areWeAllowedToVisit(url);
// System.out.println("Allowed to crawl: " + url + " " +
// allowCrawl);
crawler.crawl();
} catch (Throwable t) {
System.out.println(t.toString());
t.printStackTrace();
}
}

10. 网络爬虫的几种常见类型

版权归作者所有，任何形式转载请联系作者。
作者：盛世阳光（来自豆瓣）
来源：https://www.douban.com/note/617498592/
1.批量型网络爬虫：限制抓取的属性，包括抓取范围、特定目标、限制抓取时间、限制数据量以及限制抓取页面，总之明显的特征就是受限；
2.增量型网络爬虫（通用爬虫）：与前者相反，没有固定的限制，无休无止直到抓完所有数据。这种类型一般应用于搜索引擎的网站或程序；
3.垂直网络爬虫（聚焦爬虫）：简单的可以理解为一个无限细化的增量网络爬虫，可以细致的对诸如行业、内容、发布时间、页面大小等很多因素进行筛选。
这些网络爬虫的功能不一，使用方法也不同。例如谷歌、网络搜索就是典型的增量型爬虫，提供大而全的内容来满足世界各地的用户。另外像天猫、京东很多店铺都需要屏蔽外来的抓取，这时就需要爬虫根据一些低级域名的链接来抓取他们进行排名。
后来随着爬虫使用越来越灵活，很多网站都使用多个爬虫同步进行抓取。例如现下很多视频网站，都是先通过一般爬虫或者人工批量抓取内容，然后给用户一些可选项，让客户自己给聚焦爬虫划定范围最后找到匹配度足够高的内容，整个过程极大的降低了资源和时间的消耗。相反如果这些内容全部用聚焦爬虫来完成，不仅要消耗大量的网络资源，而且会延长搜索时间时间，影响客户体验。