【转】(二)零基础写Java知乎爬虫之进阶篇

转自:https://www.cnblogs.com/shirui/p/5137238.html
说到爬虫，使用Java本身自带的URLConnection可以实现一些基本的抓取页面的功能，但是对于一些比较高级的功能，比如重定向的处理，HTML标记的去除，仅仅使用URLConnection还是不够的。

在这里我们可以使用HttpClient这个第三方jar包。

接下来我们使用HttpClient简单的写一个爬去百度的Demo：

package internet_worm.Demo1;

import java.io.FileOutputStream;  
import java.io.InputStream;  
import java.io.OutputStream;  

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod; 

public class Demo2 {
    private static HttpClient httpClient =new HttpClient();
    /**
     *@param path
     *          目标网页的连接
     *@return   返回布尔值,表示是否正常下载目标页面
     *@throws Exception
     *          读取网页流或写入本地文件的IO异常 
     */
    public static boolean downloadPage(String path)throws  Exception{
        //定义输入输出流
        InputStream input =null;
        OutputStream output =null;
        String filename1 = path.substring(path.lastIndexOf('/')+1)+".html"; 
        //得到post方法
        GetMethod getMethod =new GetMethod(path);
        //执行,返回状态码
        int statusCode=httpClient.executeMethod(getMethod);
        //针对状态码进行处理
        //简单起见，只处理返回值为200的状态码
        if (statusCode == HttpStatus.SC_OK){
            input=getMethod.getResponseBodyAsStream(); 
            //通过对URL的得到的文件名
            String filename = path.substring(path.lastIndexOf('/')+1)+".html"; 
            //获得文件输出流
            output = new FileOutputStream(filename);
            //得到文件
            int tempByte=-1;
            while ((tempByte = input.read())>0){
                output.write(tempByte);
            }
            //关闭输入流
            if(input!=null){
                input.close();
            }
            //关闭输出流
            if(output!=null){
                output.close();
            }
            return true;
        }   
        return false;
    }

    public static void main(String[] args) {
        try {
            //抓取百度首页，输出
            Demo2.downloadPage("http://www.baidu.com");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

但是这样基本的爬虫是不能满足各色各样的爬虫需求的。

先来介绍宽度优先爬虫。

宽度优先相信大家都不陌生，简单说来可以这样理解宽度优先爬虫。

我们把互联网看作一张超级大的有向图，每一个网页上的链接都是一个有向边，每一个文件或没有链接的纯页面则是图中的终点：

宽度优先爬虫就是这样一个爬虫，爬走在这个有向图上，从根节点开始一层一层往外爬取新的节点的数据。

宽度遍历算法如下所示：

(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类：

package internet_worm.Demo2;

import java.util.LinkedList;

/**
 * 自定义队列累 保存TODO表
 * @author sky
 *
 */
public class Queue {
/**
 * 定义一个队列，使用LinkedList
 */
private LinkedList<Object> queue= new LinkedList<Object>();//入队列
/*
 * 将T加入到队列中
 */

public void enQueue(Object  t){
    queue.addLast(t);
}
/*
 * 移除队列中的第一项并将其返回
 */
public Object deQueue(){
    return queue.removeFirst();
}

/*
 * 返回队列是否为空
 * 
 */
public boolean isQueueEmpty(){
    return queue.isEmpty();
}
/**
 * 判断并返回队列是否包含T
 */
public boolean contians(Object t){
    return queue.contains(t);
}
/**
 * 判断并返回队列是否为空
 */
public boolean empty(){
    return queue.isEmpty();
}
}

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

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

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

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

package internet_worm.Demo2;

import java.util.HashSet;
import java.util.Set;

/*
 * 自定义类,保存Visited表和unVisited表
 */
public class SpiderQueue {
/*
 * 已访问的url集合，即Visited表
 */
private static Set<Object> visitedUrl = new HashSet<Object>();
/**
 * 添加到访问过的URL队列中
 */
public static void addVisitedUrl(String url){
    visitedUrl.add(url);
}
/*
 * 移除访问过的URL
 */
public static void removeVisitedUrl(String url){
    visitedUrl.remove(url);
}
/*
 * 获得已经访问的URL数目
 */
public static int getVisitedUrlNum(){
    return visitedUrl.size();
}
/*
 * 待访问的url集合，即unVisited表
 */
private static Queue unVisitedUrl = new Queue();
/*
 * 获得UnVisited队列
 */
public static Queue getUnVisitedUrl(){
    return unVisitedUrl;
}
/*
 * 未访问的unVisitedUrl出队列
 */
public static Object unVisitedUrlDeQueue(){
    return unVisitedUrl.deQueue();
}
/*
 * 保证添加url到unVisitedUrl的时候每个 URL只被访问一次
 */
public static void addUnvisitedUrl(String url){
    if(url != null && !url.trim().equals("") && !visitedUrl.contains(url)
            && !unVisitedUrl.contians(url))
        unVisitedUrl.enQueue(url);
}
/*
 * 判断未访问的URL队列中是否为空
 */
public static boolean unVisitedUrlsEmpty(){
    return unVisitedUrl.empty();
}

}

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

package internet_worm.Demo2;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.httpclient.util.HttpURLConnection;

public class Downtool {
    /**
     * 根据URL和网页类型生成需要保存的网页文件名了，去除URL中的非文件名字符
     */
    private String getFileNameByUrl(String url,String contentType){
        //移除"http://"这七个字符
        url = url.substring(7);
        //确认抓取到的页面text/html类型
        if(contentType.indexOf("html")!=-1){
            //把所有的url中的特殊符号转化成下划线
            url=url.replaceAll("[\\?/:*|<>\"]", "_")+".html";
        }else{
            url =url.replaceAll("[\\?/:*|<>\"]", "_")+"."+
            contentType.substring(contentType.lastIndexOf("/")+1);
        }
        return url;
    }
    /**
     * 保存网页字节到本地文件,filePath为要保存的文件的相对地址
     */
    private void saveToLocal(byte[] data,String filePath){
        try{
            File file=new File(filePath);
            DataOutputStream out = new DataOutputStream(new FileOutputStream(
                    new File(filePath)));
            for(int i=0;i<data.length;i++){
                out.write(data[i]);
            }
                out.flush();
                out.close();

        }catch(Exception e){
            e.printStackTrace();
        }
    }
    //下载URL指向的网页
    public String downlaodFile(String url){
        String filePath =null;
        //1.生成HttpClient对象设置参数
        HttpClient httpClient = new HttpClient();
        //设置HTTP连接超时5s
        httpClient.getHttpConnectionManager().getParams()
        .setConnectionTimeout(5000);
        //2.生成GetMethod对象并设置参数
        GetMethod getMethod = new GetMethod(url);
        //设置get请求5s
        getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
        //设置请求重试处理
        getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
        //3.执行get请求
        try{
            int statusCode = httpClient.executeMethod(getMethod);
            //判断访问状态码
            if(statusCode!=HttpStatus.SC_OK){
                System.err.println("Method failed:"
                        + getMethod.getStatusLine());
                filePath =null;
            }
            //4.处理HTTP响应内容
            byte[] responseBody = getMethod.getResponseBody();//读取为字节数组
            //根据网页url生成保存时的文件名
            filePath ="temp\\"+getFileNameByUrl(url,
                    getMethod.getResponseHeader("Content-Type")
                    .getValue());
            saveToLocal(responseBody, filePath);
        }catch(HttpException e){
            //发生致命的异常，可能是协议不对或者返回的内容有问题
            System.out.println("请检查你的http地址是否正确");
            e.printStackTrace();
        } catch (IOException e) {
            //发生网络异常
            e.printStackTrace();
        }finally{
            //释放连接
            getMethod.releaseConnection();
        };
        return filePath;

    }
}

这里要写一个过滤器接口，保证从返回的HTML里提取的网页地址都是目标网站的下子网页，如我们现在要爬的是www.baidu.com，那我们就要定义是下载www.baidu.com开头的网页，而不是外链的网址。

package model;

public interface LinkFilter {
    public boolean accept(String url);
}

在这里我们需要一个HtmlParserTool类来处理Html标记（解析返回的HTML）
HtmlParserTool是一个很好的HTML解析库，具体用法可以查看
http://blog.csdn.net/qq_37307352/article/details/78616615：

package internet_worm.Demo2;

import java.util.HashSet;
import java.util.Set;

import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.filters.NodeClassFilter;
import org.htmlparser.filters.OrFilter;
import org.htmlparser.tags.BodyTag;
import org.htmlparser.tags.Html;
import org.htmlparser.tags.LinkTag;
import org.htmlparser.util.NodeIterator;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;

import com.sun.xml.internal.xsom.impl.scd.ParseException;

import model.LinkFilter;

public class HtmlParserTool {
    //定义可能出现的HTML字符集
    private static final String oriEncode = "utf-8,gb2312,gbk,iso-8859-1";
    private static String encode=null;
    //获取一个网站上的链接,filter用来过滤链接
    public static Set<String> extracLinks(String url,LinkFilter filter){
        String encode=null;
        Set<String> links =new HashSet<String>();
        try{
            //处理字符组
            String[] encodes = oriEncode.split(",");
            for (int i = 0; i < encodes.length; i++) {
                Parser parser =new Parser(url);
                 parser.setEncoding(encodes[i]);
                 /*
                  * 字符集是否存在页面返回的内容里，判断出页面是形容哪种字符集解码
                  */

                 for (NodeIterator e = parser.elements(); e.hasMoreNodes();) {
                       Node node = (Node) e.nextNode();
                       if (node instanceof Html||node instanceof BodyTag) {
                           encode=encodes[i];
                           break;
                       }
                   }
                 if(encode !=null){
                     break;
                 }

               }

            Parser parser =new Parser(url);

            parser.setEncoding(encode);

            //过滤<frame>标签的filter,用来提取frame标签的src属性
            NodeFilter frameFilter = new NodeFilter(){
                private static final long serialVersionUID = 1L;
                //@Override
                public boolean accept(Node node) {
                    // TODO Auto-generated method stub
                    if(node.getText().startsWith("frame src=")){
                        return true;
                    }else{
                        return false;
                    }

                }
            };
        //OrFilter来设置过滤<a>标签和<frame>标签
        OrFilter linkFilter = new OrFilter(new NodeClassFilter(
                LinkTag.class),frameFilter);
        //得到所有经过过滤的标签
        NodeList list = parser.extractAllNodesThatMatch(linkFilter);
        for(int i = 0;i<list.size();i++){
            Node tag=list.elementAt(i);
            if(tag instanceof LinkTag)//<a>标签
            {
                LinkTag link=(LinkTag) tag;
                String linkUrl = link.getLink();//URL
                if(filter.accept(linkUrl))
                    links.add(linkUrl);
                }else//<frame>标签
                {
                //提取frame里src属性的链接，如<frame src="test.html"/>
                String frame =tag.getText();
                System.out.println(frame);
                int start = frame.indexOf("src=");

                frame =frame.substring(start);
                int end =frame.indexOf(" ");
                if(end ==-1){
                    end =frame.indexOf(">");
                    String frameUrl = frame.substring(5,end-1);
                    if (filter.accept(frameUrl)) {
                    links.add(frameUrl);
                    }
                }
                }
            }

        }catch(ParserException e){
            e.printStackTrace();
        }
        return links;

    }
}

最后我们来写个爬虫类调用前面的封装类和函数：

package internet_worm.Demo2;
import java.util.Set;

import org.omg.CORBA.PUBLIC_MEMBER;

import model.LinkFilter;
import internet_worm.Demo2.SpiderQueue;
public class BfsSpider {
    /**
     * 使用种子初始化URL队列
     */
    private void initCrawlerWithSeeds(String[] seeds){
        for(int i= 0; i <seeds.length;i++){
            SpiderQueue.addUnvisitedUrl(seeds[i]);
        }
    }
    //定义过滤器，提取以http://www.xxx.com开头的连接
    public void crawling(String[] seeds){
        LinkFilter filter = new LinkFilter(){
            public boolean accept(String url) {
            // TODO Auto-generated method stub
            //重写LinkFilter接口方法
                if(url.startsWith("http://www.baidu.com"))
                    return true;
                else
                    return false;
    }
    };
    //初始化URL队列
    initCrawlerWithSeeds(seeds);
    //循环条件：待抓取的链接不空切抓取的网页不多于100
    while (!SpiderQueue.unVisitedUrlsEmpty()
            && SpiderQueue.getVisitedUrlNum()<=100){
        //队头URL出队列
        String visitUrl =(String)SpiderQueue.unVisitedUrlDeQueue();
        if(visitUrl == null){
            continue;
        }
        Downtool downLoader= new Downtool();
        //下载网页
        downLoader.downlaodFile(visitUrl);
        //该URL放入已访问的URL中
        SpiderQueue.addVisitedUrl(visitUrl);
        //提取出下载网页中的URL入队
        Set<String> links =HtmlParserTool.extracLinks(visitUrl, filter);
        //新的未访问URL入队
        for(String link:links){
            SpiderQueue.addUnvisitedUrl(link);
        }
    }

}   
    //main方法入口
    public static void main(String[] args){
        BfsSpider crawler =new BfsSpider();
        crawler.crawling(new String[] {"http://www.baidu.com"});
    }
}

运行可以看到，爬虫已经把百度网页下所有的页面都抓取出来了：

*

总结思路

1.下载网页我们需要httpclient-3.1.Jar
2.解析网页我们需要htmlparser-1.6.Jar
3.使用htmlparser有时候会报缺tools-1.5.0Jar包错误，解决方法大概是将系统的tools包改了名复制到指定文件夹。（具体操作忘记了，原谅我）。

4.首先要下载网页，我们需要使用httpclient库写一个downTool类，其中使用正则表达去除网页地址多余的字符，以生成清晰的网页文件名来保存。

5.下载网页后，我们要根据网页中的内容读取出需要继续爬的网页地址，所以我们要使用htmlperser解析网页，因此写一个HtmlParserTool类。

6.解析网页得出网页链接的地址后(<a></a><frame></frame>),我们要判断这地址是属于我们要爬的目标网站的，还是属于链接到其它网站的。所以我们要写个LinkFilter过滤器接口，以此判断地址是不是目标网站的。为什么是接口呢？因为我们目标的网站会经常变啊，过滤方法也可能经常变更，如果写死了在类里面，那不就很难更改了。写成接口，需要时才实现就方便很多了。随便写个新的实现就可以改动了。

7.判断完是属于目标网站后，我们又要来判断了。

7.1判断得到的网址我们以前有没有下载过，解析过。如果有就不用重复工作了。所以我们要写集合存储已经下载过的网址，这个数据结构需要不重复并且能快速查找，所以选择HashSet来存储，生成一个集合名字叫作visitedUrl 。

7.2另外我们还要将未下载的网址存到另一个集合，以用来从中提取后下载。考虑到需要先进先出所以采用队列，所以我们用LinkedList来实现一个Queue(队列)接口，以此写了一个Queue类，生成一个集合unVisitedUrl 。

8.最后写一个封装类，调用downTool下载，调用HtmlParserTool来解析网页内容，然后得出新的需要下载的网址，再重新调用downTool。以此循环爬出整个目标网站的数据。

多谢，多谢大家，我是谭咏麟Fands.