java 进阶 知乎_(二)零基础写Java知乎爬虫之进阶篇

转自:https://www..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 queue= new LinkedList();//入队列

/*

* 将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 visitedUrl = new HashSet();

/**

* 添加到访问过的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

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..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 extracLinks(String url,LinkFilter filter){

String encode=null;

Set links =new HashSet();

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);

//过滤标签的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来设置过滤标签和标签

OrFilter linkFilter = new OrFilter(new NodeClassFilter(

LinkTag.class),frameFilter);

//得到所有经过过滤的标签

NodeList list = parser.extractAllNodesThatMatch(linkFilter);

for(int i = 0;i

Node tag=list.elementAt(i);

if(tag instanceof LinkTag)//标签

{

LinkTag link=(LinkTag) tag;

String linkUrl = link.getLink();//URL

if(filter.accept(linkUrl))

links.add(linkUrl);

}else//标签

{

//提取frame里src属性的链接，如

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

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

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

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

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

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

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