網路爬蟲實現全網搜索

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.垂直網路爬蟲（聚焦爬蟲）：簡單的可以理解為一個無限細化的增量網路爬蟲，可以細致的對諸如行業、內容、發布時間、頁面大小等很多因素進行篩選。
這些網路爬蟲的功能不一，使用方法也不同。例如谷歌、網路搜索就是典型的增量型爬蟲，提供大而全的內容來滿足世界各地的用戶。另外像天貓、京東很多店鋪都需要屏蔽外來的抓取，這時就需要爬蟲根據一些低級域名的鏈接來抓取他們進行排名。
後來隨著爬蟲使用越來越靈活，很多網站都使用多個爬蟲同步進行抓取。例如現下很多視頻網站，都是先通過一般爬蟲或者人工批量抓取內容，然後給用戶一些可選項，讓客戶自己給聚焦爬蟲劃定范圍最後找到匹配度足夠高的內容，整個過程極大的降低了資源和時間的消耗。相反如果這些內容全部用聚焦爬蟲來完成，不僅要消耗大量的網路資源，而且會延長搜索時間時間，影響客戶體驗。