[转] [Java] 知乎下巴第5集:使用HttpClient工具包和宽度爬虫

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[转] [Java] 知乎下巴第5集:使用HttpClient工具包和宽度爬虫相关的知识,希望对你有一定的参考价值。

原文地址: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;  
  7.   
  8. /** 
  9.  *  
  10.  * @author CallMeWhy 
  11.  *  
  12.  */  
  13. public class Spider {  
  14.     private static HttpClient httpClient = new HttpClient();  
  15.   
  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.     }  
  57.   
  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;  
  2.   
  3. /** 
  4.  * 自定义队列类 保存TODO表 
  5.  */  
  6. public class Queue {  
  7.   
  8.     /** 
  9.      * 定义一个队列,使用LinkedList实现 
  10.      */  
  11.     private LinkedList<Object> queue = new LinkedList<Object>(); // 入队列  
  12.   
  13.     /** 
  14.      * 将t加入到队列中 
  15.      */  
  16.     public void enQueue(Object t) {  
  17.         queue.addLast(t);  
  18.     }  
  19.   
  20.     /** 
  21.      * 移除队列中的第一项并将其返回 
  22.      */  
  23.     public Object deQueue() {  
  24.         return queue.removeFirst();  
  25.     }  
  26.   
  27.     /** 
  28.      * 返回队列是否为空 
  29.      */  
  30.     public boolean isQueueEmpty() {  
  31.         return queue.isEmpty();  
  32.     }  
  33.   
  34.     /** 
  35.      * 判断并返回队列是否包含t 
  36.      */  
  37.     public boolean contians(Object t) {  
  38.         return queue.contains(t);  
  39.     }  
  40.   
  41.     /** 
  42.      * 判断并返回队列是否为空 
  43.      */  
  44.     public boolean empty() {  
  45.         return queue.isEmpty();  
  46.     }  
  47.   
  48. }  


 

还需要一个数据结构来记录已经访问过的 URL,即Visited表。

考虑到这个表的作用,每当要访问一个 URL 的时候,首先在这个数据结构中进行查找,如果当前的 URL 已经存在,则丢弃这个URL任务。

这个数据结构需要不重复并且能快速查找,所以选择HashSet来存储。

综上,我们另建一个SpiderQueue类来保存Visited表和TODO表:

 

  1. import java.util.HashSet;  
  2. import java.util.Set;  
  3.   
  4. /** 
  5.  * 自定义类 保存Visited表和unVisited表 
  6.  */  
  7. public class SpiderQueue {  
  8.   
  9.     /** 
  10.      * 已访问的url集合,即Visited表 
  11.      */  
  12.     private static Set<Object> visitedUrl = new HashSet<>();  
  13.   
  14.     /** 
  15.      * 添加到访问过的 URL 队列中 
  16.      */  
  17.     public static void addVisitedUrl(String url) {  
  18.         visitedUrl.add(url);  
  19.     }  
  20.   
  21.     /** 
  22.      * 移除访问过的 URL 
  23.      */  
  24.     public static void removeVisitedUrl(String url) {  
  25.         visitedUrl.remove(url);  
  26.     }  
  27.   
  28.     /** 
  29.      * 获得已经访问的 URL 数目 
  30.      */  
  31.     public static int getVisitedUrlNum() {  
  32.         return visitedUrl.size();  
  33.     }  
  34.   
  35.     /** 
  36.      * 待访问的url集合,即unVisited表 
  37.      */  
  38.     private static Queue unVisitedUrl = new Queue();  
  39.   
  40.     /** 
  41.      * 获得UnVisited队列 
  42.      */  
  43.     public static Queue getUnVisitedUrl() {  
  44.         return unVisitedUrl;  
  45.     }  
  46.   
  47.     /** 
  48.      * 未访问的unVisitedUrl出队列 
  49.      */  
  50.     public static Object unVisitedUrlDeQueue() {  
  51.         return unVisitedUrl.deQueue();  
  52.     }  
  53.   
  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.     }  
  62.   
  63.     /** 
  64.      * 判断未访问的 URL队列中是否为空 
  65.      */  
  66.     public static boolean unVisitedUrlsEmpty() {  
  67.         return unVisitedUrl.empty();  
  68.     }  
  69. }  


上面是一些自定义类的封装,接下来就是一个定义一个用来下载网页的工具类,我们将其定义为DownTool类:

 

  1. package controller;  
  2.   
  3. import java.io.*;  
  4. import org.apache.commons.httpclient.*;  
  5. import org.apache.commons.httpclient.methods.*;  
  6. import org.apache.commons.httpclient.params.*;  
  7.   
  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.     }  
  25.   
  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.     }  
  41.   
  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. }  

在这里我们需要一个HtmlParserTool类来处理Html标记:

 

  1. package controller;  
  2.   
  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;  
  13.   
  14. import model.LinkFilter;  
  15.   
  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");  
  23.   
  24.             // 过滤 <frame >标签的 filter,用来提取 frame 标签里的 src 属性  
  25.             NodeFilter frameFilter = new NodeFilter() {  
  26.                 private static final long serialVersionUID = 1L;  
  27.   
  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;  
  3.   
  4. import model.LinkFilter;  
  5. import model.SpiderQueue;  
  6.   
  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.     }  
  15.   
  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.     }  
  48.   
  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工具包和宽度爬虫的主要内容,如果未能解决你的问题,请参考以下文章

java Swing第5集:BoxLayout

Java架构师人手一份的Spring Cloud Alibaba笔记,知乎疯转上万次!

word中都有哪些好用的插件 知乎

知乎文章转视频实现(乞丐版本)

Java架构师人手一份的Spring Cloud Alibaba笔记,知乎疯转上万次

为什么参数化查询可以防止SQL注入?(转)