原文地址:http://blog.csdn.net/pleasecallmewhy/article/details/18010015

下載地址：https://code.csdn.net/wxg694175346/zhihudown

說到爬蟲，使用Java本身自帶的URLConnection可以實現一些基本的抓取頁面的功能，但是對於一些比較高級的功能，比如重定向的處理，HTML標記的去除，僅僅使用URLConnection還是不夠的。

在這裏我們可以使用HttpClient這個第三方jar包，下載地址點擊這裏。

接下來我們使用HttpClient簡單的寫一個爬去百度的Demo：

1. import java.io.FileOutputStream;
2. import java.io.InputStream;
3. import java.io.OutputStream;
4. import org.apache.commons.httpclient.HttpClient;
5. import org.apache.commons.httpclient.HttpStatus;
6. import org.apache.commons.httpclient.methods.GetMethod;
8. /**
9. *
10. * @author CallMeWhy
11. *
12. */
13. public class Spider {
14. private static HttpClient httpClient = new HttpClient();
16. /**
17. * @param path
18. * 目標網頁的鏈接
19. * @return 返回布爾值，表示是否正常下載目標頁面
20. * @throws Exception
21. * 讀取網頁流或寫入本地文件流的IO異常
22. */
23. public static boolean downloadPage(String path) throws Exception {
24. // 定義輸入輸出流
25. InputStream input = null;
26. OutputStream output = null;
27. // 得到 post 方法
28. GetMethod getMethod = new GetMethod(path);
29. // 執行，返回狀態碼
30. int statusCode = httpClient.executeMethod(getMethod);
31. // 針對狀態碼進行處理
32. // 簡單起見，只處理返回值為 200 的狀態碼
33. if (statusCode == HttpStatus.SC_OK) {
34. input = getMethod.getResponseBodyAsStream();
35. // 通過對URL的得到文件名
36. String filename = path.substring(path.lastIndexOf(‘/‘) + 1)
37. + ".html";
38. // 獲得文件輸出流
39. output = new FileOutputStream(filename);
40. // 輸出到文件
41. int tempByte = -1;
42. while ((tempByte = input.read()) > 0) {
43. output.write(tempByte);
44. }
45. // 關閉輸入流
46. if (input != null) {
47. input.close();
48. }
49. // 關閉輸出流
50. if (output != null) {
51. output.close();
52. }
53. return true;
54. }
55. return false;
56. }
58. public static void main(String[] args) {
59. try {
60. // 抓取百度首頁，輸出
61. Spider.downloadPage("http://www.baidu.com");
62. } catch (Exception e) {
63. e.printStackTrace();
64. }
65. }
66. }

先來介紹寬度優先爬蟲。

寬度優先相信大家都不陌生，簡單說來可以這樣理解寬度優先爬蟲。

我們把互聯網看作一張超級大的有向圖，每一個網頁上的鏈接都是一個有向邊，每一個文件或沒有鏈接的純頁面則是圖中的終點：

寬度優先爬蟲就是這樣一個爬蟲，爬走在這個有向圖上，從根節點開始一層一層往外爬取新的節點的數據。

寬度遍歷算法如下所示：

(1) 頂點 V 入隊列。
(2) 當隊列非空時繼續執行，否則算法為空。
(3) 出隊列，獲得隊頭節點 V，訪問頂點 V 並標記 V 已經被訪問。
(4) 查找頂點 V 的第一個鄰接頂點 col。
(5) 若 V 的鄰接頂點 col 未被訪問過，則 col 進隊列。
(6) 繼續查找 V 的其他鄰接頂點 col，轉到步驟(5)，若 V 的所有鄰接頂點都已經被訪問過，則轉到步驟(2)。

按照寬度遍歷算法，上圖的遍歷順序為：A->B->C->D->E->F->H->G->I，這樣一層一層的遍歷下去。

而寬度優先爬蟲其實爬取的是一系列的種子節點，和圖的遍歷基本相同。

我們可以把需要爬取頁面的URL都放在一個TODO表中，將已經訪問的頁面放在一個Visited表中：

則寬度優先爬蟲的基本流程如下：

(1) 把解析出的鏈接和 Visited 表中的鏈接進行比較，若 Visited 表中不存在此鏈接， 表示其未被訪問過。
(2) 把鏈接放入 TODO 表中。
(3) 處理完畢後，從 TODO 表中取得一條鏈接，直接放入 Visited 表中。
(4) 針對這個鏈接所表示的網頁，繼續上述過程。如此循環往復。

下面我們就來一步一步制作一個寬度優先的爬蟲。

首先，對於先設計一個數據結構用來存儲TODO表， 考慮到需要先進先出所以采用隊列，自定義一個Quere類：

1. import java.util.LinkedList;
3. /**
4. * 自定義隊列類 保存TODO表
5. */
6. public class Queue {
8. /**
9. * 定義一個隊列，使用LinkedList實現
10. */
11. private LinkedList<Object> queue = new LinkedList<Object>(); // 入隊列
13. /**
14. * 將t加入到隊列中
15. */
16. public void enQueue(Object t) {
17. queue.addLast(t);
18. }
20. /**
21. * 移除隊列中的第一項並將其返回
22. */
23. public Object deQueue() {
24. return queue.removeFirst();
25. }
27. /**
28. * 返回隊列是否為空
29. */
30. public boolean isQueueEmpty() {
31. return queue.isEmpty();
32. }
34. /**
35. * 判斷並返回隊列是否包含t
36. */
37. public boolean contians(Object t) {
38. return queue.contains(t);
39. }
41. /**
42. * 判斷並返回隊列是否為空
43. */
44. public boolean empty() {
45. return queue.isEmpty();
46. }
48. }

還需要一個數據結構來記錄已經訪問過的 URL，即Visited表。

考慮到這個表的作用，每當要訪問一個 URL 的時候，首先在這個數據結構中進行查找，如果當前的 URL 已經存在，則丟棄這個URL任務。

這個數據結構需要不重復並且能快速查找，所以選擇HashSet來存儲。

綜上，我們另建一個SpiderQueue類來保存Visited表和TODO表：

1. import java.util.HashSet;
2. import java.util.Set;
4. /**
5. * 自定義類 保存Visited表和unVisited表
6. */
7. public class SpiderQueue {
9. /**
10. * 已訪問的url集合，即Visited表
11. */
12. private static Set<Object> visitedUrl = new HashSet<>();
14. /**
15. * 添加到訪問過的 URL 隊列中
16. */
17. public static void addVisitedUrl(String url) {
18. visitedUrl.add(url);
19. }
21. /**
22. * 移除訪問過的 URL
23. */
24. public static void removeVisitedUrl(String url) {
25. visitedUrl.remove(url);
26. }
28. /**
29. * 獲得已經訪問的 URL 數目
30. */
31. public static int getVisitedUrlNum() {
32. return visitedUrl.size();
33. }
35. /**
36. * 待訪問的url集合，即unVisited表
37. */
38. private static Queue unVisitedUrl = new Queue();
40. /**
41. * 獲得UnVisited隊列
42. */
43. public static Queue getUnVisitedUrl() {
44. return unVisitedUrl;
45. }
47. /**
48. * 未訪問的unVisitedUrl出隊列
49. */
50. public static Object unVisitedUrlDeQueue() {
51. return unVisitedUrl.deQueue();
52. }
54. /**
55. * 保證添加url到unVisitedUrl的時候每個 URL只被訪問一次
56. */
57. public static void addUnvisitedUrl(String url) {
58. if (url != null && !url.trim().equals("") && !visitedUrl.contains(url)
59. && !unVisitedUrl.contians(url))
60. unVisitedUrl.enQueue(url);
61. }
63. /**
64. * 判斷未訪問的 URL隊列中是否為空
65. */
66. public static boolean unVisitedUrlsEmpty() {
67. return unVisitedUrl.empty();
68. }
69. }

上面是一些自定義類的封裝，接下來就是一個定義一個用來下載網頁的工具類，我們將其定義為DownTool類：

1. package controller;
3. import java.io.*;
4. import org.apache.commons.httpclient.*;
5. import org.apache.commons.httpclient.methods.*;
6. import org.apache.commons.httpclient.params.*;
8. public class DownTool {
9. /**
10. * 根據 URL 和網頁類型生成需要保存的網頁的文件名，去除 URL 中的非文件名字符
11. */
12. private String getFileNameByUrl(String url, String contentType) {
13. // 移除 "http://" 這七個字符
14. url = url.substring(7);
15. // 確認抓取到的頁面為 text/html 類型
16. if (contentType.indexOf("html") != -1) {
17. // 把所有的url中的特殊符號轉化成下劃線
18. url = url.replaceAll("[\\?/:*|<>\"]", "_") + ".html";
19. } else {
20. url = url.replaceAll("[\\?/:*|<>\"]", "_") + "."
21. + contentType.substring(contentType.lastIndexOf("/") + 1);
22. }
23. return url;
24. }
26. /**
27. * 保存網頁字節數組到本地文件，filePath 為要保存的文件的相對地址
28. */
29. private void saveToLocal(byte[] data, String filePath) {
30. try {
31. DataOutputStream out = new DataOutputStream(new FileOutputStream(
32. new File(filePath)));
33. for (int i = 0; i < data.length; i++)
34. out.write(data[i]);
35. out.flush();
36. out.close();
37. } catch (IOException e) {
38. e.printStackTrace();
39. }
40. }
42. // 下載 URL 指向的網頁
43. public String downloadFile(String url) {
44. String filePath = null;
45. // 1.生成 HttpClinet對象並設置參數
46. HttpClient httpClient = new HttpClient();
47. // 設置 HTTP連接超時 5s
48. httpClient.getHttpConnectionManager().getParams()
49. .setConnectionTimeout(5000);
50. // 2.生成 GetMethod對象並設置參數
51. GetMethod getMethod = new GetMethod(url);
52. // 設置 get請求超時 5s
53. getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
54. // 設置請求重試處理
55. getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
56. new DefaultHttpMethodRetryHandler());
57. // 3.執行GET請求
58. try {
59. int statusCode = httpClient.executeMethod(getMethod);
60. // 判斷訪問的狀態碼
61. if (statusCode != HttpStatus.SC_OK) {
62. System.err.println("Method failed: "
63. + getMethod.getStatusLine());
64. filePath = null;
65. }
66. // 4.處理 HTTP 響應內容
67. byte[] responseBody = getMethod.getResponseBody();// 讀取為字節數組
68. // 根據網頁 url 生成保存時的文件名
69. filePath = "temp\\"
70. + getFileNameByUrl(url,
71. getMethod.getResponseHeader("Content-Type")
72. .getValue());
73. saveToLocal(responseBody, filePath);
74. } catch (HttpException e) {
75. // 發生致命的異常，可能是協議不對或者返回的內容有問題
76. System.out.println("請檢查你的http地址是否正確");
77. e.printStackTrace();
78. } catch (IOException e) {
79. // 發生網絡異常
80. e.printStackTrace();
81. } finally {
82. // 釋放連接
83. getMethod.releaseConnection();
84. }
85. return filePath;
86. }
87. }

1. package controller;
3. import java.util.HashSet;
4. import java.util.Set;
5. import org.htmlparser.Node;
6. import org.htmlparser.NodeFilter;
7. import org.htmlparser.Parser;
8. import org.htmlparser.filters.NodeClassFilter;
9. import org.htmlparser.filters.OrFilter;
10. import org.htmlparser.tags.LinkTag;
11. import org.htmlparser.util.NodeList;
12. import org.htmlparser.util.ParserException;
14. import model.LinkFilter;
16. public class HtmlParserTool {
17. // 獲取一個網站上的鏈接，filter 用來過濾鏈接
18. public static Set<String> extracLinks(String url, LinkFilter filter) {
19. Set<String> links = new HashSet<String>();
20. try {
21. Parser parser = new Parser(url);
22. parser.setEncoding("gb2312");
24. // 過濾 <frame >標簽的 filter，用來提取 frame 標簽裏的 src 屬性
25. NodeFilter frameFilter = new NodeFilter() {
26. private static final long serialVersionUID = 1L;
28. @Override
29. public boolean accept(Node node) {
30. if (node.getText().startsWith("frame src=")) {
31. return true;
32. } else {
33. return false;
34. }
35. }
36. };
37. // OrFilter 來設置過濾 <a> 標簽和 <frame> 標簽
38. OrFilter linkFilter = new OrFilter(new NodeClassFilter(
39. LinkTag.class), frameFilter);
40. // 得到所有經過過濾的標簽
41. NodeList list = parser.extractAllNodesThatMatch(linkFilter);
42. for (int i = 0; i < list.size(); i++) {
43. Node tag = list.elementAt(i);
44. if (tag instanceof LinkTag)// <a> 標簽
45. {
46. LinkTag link = (LinkTag) tag;
47. String linkUrl = link.getLink();// URL
48. if (filter.accept(linkUrl))
49. links.add(linkUrl);
50. } else// <frame> 標簽
51. {
52. // 提取 frame 裏 src 屬性的鏈接， 如 <frame src="test.html"/>
53. String frame = tag.getText();
54. int start = frame.indexOf("src=");
55. frame = frame.substring(start);
56. int end = frame.indexOf(" ");
57. if (end == -1)
58. end = frame.indexOf(">");
59. String frameUrl = frame.substring(5, end - 1);
60. if (filter.accept(frameUrl))
61. links.add(frameUrl);
62. }
63. }
64. } catch (ParserException e) {
65. e.printStackTrace();
66. }
67. return links;
68. }
69. }

1. package controller;
2. import java.util.Set;
4. import model.LinkFilter;
5. import model.SpiderQueue;
7. public class BfsSpider {
8. /**
9. * 使用種子初始化URL隊列
10. */
11. private void initCrawlerWithSeeds(String[] seeds) {
12. for (int i = 0; i < seeds.length; i++)
13. SpiderQueue.addUnvisitedUrl(seeds[i]);
14. }
16. // 定義過濾器，提取以 http://www.xxxx.com開頭的鏈接
17. public void crawling(String[] seeds) {
18. LinkFilter filter = new LinkFilter() {
19. public boolean accept(String url) {
20. if (url.startsWith("http://www.baidu.com"))
21. return true;
22. else
23. return false;
24. }
25. };
26. // 初始化 URL 隊列
27. initCrawlerWithSeeds(seeds);
28. // 循環條件：待抓取的鏈接不空且抓取的網頁不多於 1000
29. while (!SpiderQueue.unVisitedUrlsEmpty()
30. && SpiderQueue.getVisitedUrlNum() <= 1000) {
31. // 隊頭 URL 出隊列
32. String visitUrl = (String) SpiderQueue.unVisitedUrlDeQueue();
33. if (visitUrl == null)
34. continue;
35. DownTool downLoader = new DownTool();
36. // 下載網頁
37. downLoader.downloadFile(visitUrl);
38. // 該 URL 放入已訪問的 URL 中
39. SpiderQueue.addVisitedUrl(visitUrl);
40. // 提取出下載網頁中的 URL
41. Set<String> links = HtmlParserTool.extracLinks(visitUrl, filter);
42. // 新的未訪問的 URL 入隊
43. for (String link : links) {
44. SpiderQueue.addUnvisitedUrl(link);
45. }
46. }
47. }
49. // main 方法入口
50. public static void main(String[] args) {
51. BfsSpider crawler = new BfsSpider();
52. crawler.crawling(new String[] { "http://www.baidu.com" });
53. }
54. }

[轉] [Java] 知乎下巴第5集：使用HttpClient工具包和寬度爬蟲