说到爬虫，使用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解析库，具体用法可以查看
：
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.
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
