Programming a Spider in Java (翻译by:shuidao)

正在学 spider ，看到一篇 英文的 java 实现spider 的好文章，现翻译过来，存于此，备查：

翻译如下：

********************************************************************************************************

Programming a Spider in Java

简介：
Spider 是能够访问Web站点并跟踪（这些页面上的）超链接的程序。使用Spider，你能很快的找出（map out）Web站点中的所有页面。本文将

想您展示怎样用java语言构造一个Spider。还将给您呈现出一个可重用的Spider 类，这个类封装了一个基本的（basic）Spider。然后将会向

您演示怎么样创建一个定制的Spider，这个（定制的）spider能扫面一个Web站点并检查坏链接。

作为一种构造Spider的编程语言，Java 实在是一个非常好的选择。Java 具有内置的（built-in）对http协议的支持，而大多数Web 上的信息

都是由http协议来传输的。同时 Java 也具有一个内置的Html解析器(parser)。正是这两点特性是Java 成为了（编写）Spider的理想选择。

使用方法：
如本文下面的Listing1，这个例子程序能扫面一个Web站点，检查坏链接。使用这个程序，你必须输入一个URL，并且按下"Begin"按钮。这个

Spider启动以后，你会发现这个"Begin"按钮变成了"Cancel"按钮。在这个Spider扫描站点的同时，扫描进度会显示在"Cancel"按钮下面。当前

正在检查的页面以及一些好链和坏链信息会显示出来。所有的坏链会显示在程序底部的滚动文本区（scrolling text area） 里面。点

击"Cancel"按钮会终止（扫描）进程，并允许你（重新）输入新的URL。如果"Cancel"按钮没有被点击，程序将运行直到所有页面都被找到为止

。此时，"Cancel"按钮会变回"Begin"按钮，这表示（扫描的）程序没有运行了。

现在，向你展示这个例子程序是怎样跟那个可重用的Spider类之间通信的。正如Listing 1 中看到的，这个例子程序被包含在CheckLinks类中

。这个类（CheckLinks）实现了ISpiderReportable 接口，在Listing 2中可以看到。这个接口允许Spider类与例子程序之间通信。这个接口定

义了三个方法。第一个方法叫做"spiderFoundURL",每当spider找到一个URL时此方法就会被调用。如果这个方法返回true就表示这个URL应该被

解析，并同时再查找那里（这个Url指向的页面）的链接。第二个方法叫做"spiderURLError", 每次Spider检查页面所产生的任何error时都会

调用此方法。第三个方法叫做"spiderFoundEMail"，当找到e-mail地址时被调用。通过这三个方法，Spider类能够与创建它的应用程序交流找

到的结果。

当begin方法被调用时，spider就启动了。为了使例子程序能维护自己的用户界面，spider被作为一个独立的线程启动。点击"Begin"按钮就启

动了后台的spider线程，此时"CheckLinks"类的run方法就被调用。在run方法开始处会实例化一个Spider的对象。代码片段如下：

spider = new Spider(this);
spider.clear();
base = new URL(url.getText());
spider.addURL(base);
spider.begin();

首先实例化一个新的Spider对象，构造函数要求传入一个"ISpiderReportable"的对象。由于"CheckLinks"类实现了"ISpiderReportable"接口

，所以你可以简单的把当前对象传入构造函数，即使用this传入即可。spider维护一个已访问的URL的list。"clear"方法用来确保spider启动

的时候list是空的。在spider启动之前必须有一个URL加入到正在处理的list（processing list）里面。初始状态时用户输入的URL会被放入会

放入其中，这个url有被称为基RUL（base url）。spider会开始扫描这个页面，并会如期的找出这个页面中链接的页面。最后，"begin"方法被

调用，以启动spider。begin方法直到spider完成或者被取消才会返回。

当spider运行时，从ISpiderReportable接口继承的那三个方法会被调用，以此来报告spider当前的动作。例子程序完成的大多数工作都集中在

spiderFondURL方法中。每当spider 找到一个新的Url时，先检查url的有效性。如果产生错误，则这个url被报告为一个坏链。如果url有效，

再检查它是否位于别的服务器上，如果在同一服务器上，spiderFoundURL方法返回true，表明spider应该解析这个url并找出这个url页面上的

链接。别的服务器上的链接不会被扫描，因为这将导致spider无休止的访问Internet找到更多Web站点。本程序只是用来查找用户指定的Web站

点上的链接的。

构造Spider类

前面展示了怎么样使用Spider类，如Listing3中所示。使用Spider类和ISpiderReportable接口可以容易的让你自己的程序具有spider的功能。

本节将展示Spider类实际是怎样工作的。

Spider类必须记住哪些url已经被访问过了，这一点必须完成，这样spider才不至于多次访问同一个url。进一步，spider必须把url分为三个部

分。第一部分存储在"workloadWaiting"属性中，它包含一个url的列表，这些url是spider发现的但还未处理过的。spider要访问的第一个url

被放置其中以使spider启动。第二个部分存储在"workloadProcessed" 容器中，这是些spider已经处理过而且不需要再访问的url。第三个部分

存储在"workloadError"属性中，这包含了哪些产生error的url。

begin方法包含Spider类的主循环。begin方法反复的在workloadWaiting容器中循环，并处理每一个页面。当然，这些页面被处理过后，可能另

一些url会被加入到workloadWaiting容器中。begin方法持续这个过程直到调用Spider类的cancel方法被取消或者workloadWaiting容器中没有剩下的url为止。这个过程如下：

cancel = false;
while ( !getWorkloadWaiting().isEmpty() && !cancel ) {
Object list[] = getWorkloadWaiting().toArray();
for ( int i=0;(i<list.length)&&!cancel;i++ )
processURL((URL)list[i]);
}

在前面的代码的workloadWaiting容器中的循环中，将每一个将要处理的url传给processURL方法。这个方法会真的去如去并解析每一个url所存

储的html页面。

读取并解析Html

Java具有对访问url内容和解析html的双重支持。processURL方法做了这些工作，它被用来处理每一个url。读取url内容在Java中相对简单。下

面这些从processURL中截取的代码执行了这一过程。

URLConnection connection = url.openConnection();
if ( (connection.getContentType()!=null) &&
!connection.getContentType().toLowerCase()
.startsWith("text/") ) {
getWorkloadWaiting().remove(url);
getWorkloadProcessed().add(url);
log("Not processing because content type is: " +
connection.getContentType() );
return;
}

首先，从传入参数"url"创建一个URLConnection对象，Web站点上有多种的文档类型，spider只对html有兴趣，尤其是基于文本类型的文档。前

面的代码确保文档类型以"text/"开头。如果文档不是文本的，这个url将会从waiting workload 中移除，并被添加到processed workload中，

以确保这个url不会被再次访问。

由于从指定的url上打开了一个连接，内容必须被解析。下面几行代码允许你打开一个url连接，并像读取文件一样读取这个内容。

InputStream is = connection.getInputStream();
Reader r = new InputStreamReader(is);

现在有了一个可以读取url内容的Reader对象了。对这个spider来说，会简单的把内容传给HTML解析器。本例中用到的HTML解析器是Swing HTML

parser,这是内置于java的。java对HTML解析的支持是不十分好的。你必须重写一个类以访问HTML解析器。这是因为你必须调用HTMLEditorKit

类的getParser方法，而不幸的是Sun把这个方法设为protected，唯一的方法是创建你自己的类，重写getParser方法，并设为public。这些在

HTMLParse类中实现，如Listing 4中所示。

import javax.swing.text.html.*;

public class HTMLParse extends HTMLEditorKit {
public HTMLEditorKit.Parser getParser()
{
return super.getParser();
}
}

这个类在Spider类的processURL方法中用到。如下面你所看到的，用来读取页面内容Reader对象r被传入刚刚获得的"HTMLEditorKit.Parser对象。

HTMLEditorKit.Parser parse = new HTMLParse().getParser();
parse.parse(r,new Parser(url),true);

你现在会看到一个新的Parser类出现了。这个类是例子中的Spider类的一个内部类。这个类是一个回调类，它包含了很多每一种html标记被发

现时所调用的方法。API文档中描述的回调方法有很多，本文关心的只有其中的两个方法：发现当简单标记（simple tag ，没有结束标记的标

记 例如<br>）和发现起始标记是调用的方法。这两个方法分别叫做handleSimpleTag和handleStartTag。因为这两种处理方法是相同的（译注

：在本例中是相同的），所以handleStartTag方法只是简单的调用handleSimpleTag方法，那么handleSimpleTag方法就负责提取文档中的超链

接了。这些超链接会用来定位spider要访问的其他页面。handleSimpleTag方法开始时检查当前解析的标记是否有href属性或者超文本引用。

String href = (String)a.getAttribute(HTML.Attribute.HREF);

if( (href==null) && (t==HTML.Tag.FRAME) )
href = (String)a.getAttribute(HTML.Attribute.SRC);

if ( href==null )
return;

如果没有href属性，就检查当前标记是不是Frame。Frame用src属性指向其他的页面。一个典型的超链接像下面这样：

<a href="linkedpage.html">Click Here</a>

上面的href属性指向链接目标网页。但是linkedpage.html不是一个地址。你不能输入到浏览器中并到达任何页面。linkedpage.html简单的指

明页面在这个Web服务器上的某个地方。这叫做相对url。相对url必须被解析成指明页面的完整的绝对url，这可以用下面一行代码完成：

URL url = new URL(base,str);

这创建了一个url，str是相对url，base是url所在的页面。用URL类的这个构造函数允许你创建一个完整的绝对url。用现在的正确的绝对的url

来检查它是否已经被处理过了，确保它不在workload容器中。如果这个url没有处理过，将它加入等待处理的部分。以后它将会被处理，或者添

加新的超链接到等待处理的部分。

结论：

本文想你展示了创建一个简单的spider，它能访问Web服务器上的所有站点。这里展示的例子程序能很容易得成为很多其他spider程序的开端。

那些需要操作大量站点的高级的spider很可能会用到多线程和SQL数据库等技术。不幸的是，Java的内置的HTML解析不是线程安全的，所以开发

这样的spider某种程度上是一件复杂的工作。像这样一些主题在我的《Programming Spiders》和《 Bots and Aggregators 》中有讲述。
作者： Sybex

Listing 1: Finding the bad links (CheckLinks.java)

import java.awt.*;
import javax.swing.*;
import java.net.*;
import java.io.*;

/**
* This example uses a Java spider to scan a Web site
* and check for broken links. Written by Jeff Heaton.
* Jeff Heaton is the author of "Programming Spiders,
* Bots, and Aggregators" by Sybex. Jeff can be contacted
* through his Web site at http://www.jeffheaton.com.
*
* @author Jeff Heaton(http://www.jeffheaton.com)
* @version 1.0
*/
public class CheckLinks extends javax.swing.JFrame implements
Runnable,ISpiderReportable {

/**
* The constructor. Perform setup here.
*/
public CheckLinks()
{
//{{INIT_CONTROLS
setTitle("Find Broken Links");
getContentPane().setLayout(null);
setSize(405,288);
setVisible(false);
label1.setText("Enter a URL:");
getContentPane().add(label1);
label1.setBounds(12,12,84,12);
begin.setText("Begin");
begin.setActionCommand("Begin");
getContentPane().add(begin);
begin.setBounds(12,36,84,24);
getContentPane().add(url);
url.setBounds(108,36,288,24);
errorScroll.setAutoscrolls(true);
errorScroll.setHorizontalScrollBarPolicy(javax.swing.
ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
errorScroll.setVerticalScrollBarPolicy(javax.swing.
ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
errorScroll.setOpaque(true);
getContentPane().add(errorScroll);
errorScroll.setBounds(12,120,384,156);
errors.setEditable(false);
errorScroll.getViewport().add(errors);
errors.setBounds(0,0,366,138);
current.setText("Currently Processing: ");
getContentPane().add(current);
current.setBounds(12,72,384,12);
goodLinksLabel.setText("Good Links: 0");
getContentPane().add(goodLinksLabel);
goodLinksLabel.setBounds(12,96,192,12);
badLinksLabel.setText("Bad Links: 0");
getContentPane().add(badLinksLabel);
badLinksLabel.setBounds(216,96,96,12);
//}}

//{{INIT_MENUS
//}}

//{{REGISTER_LISTENERS
SymAction lSymAction = new SymAction();
begin.addActionListener(lSymAction);
//}}
}

/**
* Main method for the application
*
* @param args Not used
*/
static public void main(String args[])
{
(new CheckLinks()).setVisible(true);
}

/**
* Add notifications.
*/
public void addNotify()
{
// Record the size of the window prior to calling parent's
// addNotify.
Dimension size = getSize();

super.addNotify();

if ( frameSizeAdjusted )
return;
frameSizeAdjusted = true;

// Adjust size of frame according to the insets and menu bar
Insets insets = getInsets();
javax.swing.JMenuBar menuBar = getRootPane().getJMenuBar();
int menuBarHeight = 0;
if ( menuBar != null )
menuBarHeight = menuBar.getPreferredSize().height;
setSize(insets.left + insets.right + size.width, insets.top +
insets.bottom + size.height +
menuBarHeight);
}

// Used by addNotify
boolean frameSizeAdjusted = false;

//{{DECLARE_CONTROLS
javax.swing.JLabel label1 = new javax.swing.JLabel();

/**
* The begin or cancel button
*/
javax.swing.JButton begin = new javax.swing.JButton();

/**
* The URL being processed
*/
javax.swing.JTextField url = new javax.swing.JTextField();

/**
* Scroll the errors.
*/
javax.swing.JScrollPane errorScroll =
new javax.swing.JScrollPane();

/**
* A place to store the errors created
*/
javax.swing.JTextArea errors = new javax.swing.JTextArea();
javax.swing.JLabel current = new javax.swing.JLabel();
javax.swing.JLabel goodLinksLabel = new javax.swing.JLabel();
javax.swing.JLabel badLinksLabel = new javax.swing.JLabel();
//}}

//{{DECLARE_MENUS
//}}

/**
* The background spider thread
*/
protected Thread backgroundThread;

/**
* The spider object being used
*/
protected Spider spider;

/**
* The URL that the spider began with
*/
protected URL base;

/**
* How many bad links have been found
*/
protected int badLinksCount = 0;

/**
* How many good links have been found
*/
protected int goodLinksCount = 0;

/**
* Internal class used to dispatch events
*
* @author Jeff Heaton
* @version 1.0
*/
class SymAction implements java.awt.event.ActionListener {
public void actionPerformed(java.awt.event.ActionEvent event)
{
Object object = event.getSource();
if ( object == begin )
begin_actionPerformed(event);
}
}

/**
* Called when the begin or cancel buttons are clicked
*
* @param event The event associated with the button.
*/
void begin_actionPerformed(java.awt.event.ActionEvent event)
{
if ( backgroundThread==null ) {
begin.setLabel("Cancel");
backgroundThread = new Thread(this);
backgroundThread.start();
goodLinksCount=0;
badLinksCount=0;
} else {
spider.cancel();
}

}

/**
* Perform the background thread operation. This method
* actually starts the background thread.
*/
public void run()
{
try {
errors.setText("");
spider = new Spider(this);
spider.clear();
base = new URL(url.getText());
spider.addURL(base);
spider.begin();
Runnable doLater = new Runnable()
{
public void run()
{
begin.setText("Begin");
}
};
SwingUtilities.invokeLater(doLater);
backgroundThread=null;

} catch ( MalformedURLException e ) {
UpdateErrors err = new UpdateErrors();
err.msg = "Bad address.";
SwingUtilities.invokeLater(err);

}
}

/**
* Called by the spider when a URL is found. It is here
* that links are validated.
*
* @param base The page that the link was found on.
* @param url The actual link address.
*/
public boolean spiderFoundURL(URL base,URL url)
{
UpdateCurrentStats cs = new UpdateCurrentStats();
cs.msg = url.toString();
SwingUtilities.invokeLater(cs);

if ( !checkLink(url) ) {
UpdateErrors err = new UpdateErrors();
err.msg = url+"(on page " + base + ")/n";
SwingUtilities.invokeLater(err);
badLinksCount++;
return false;
}

goodLinksCount++;
if ( !url.getHost().equalsIgnoreCase(base.getHost()) )
return false;
else
return true;
}

/**
* Called when a URL error is found
*
* @param url The URL that resulted in an error.
*/
public void spiderURLError(URL url)
{
}

/**
* Called internally to check whether a link is good
*
* @param url The link that is being checked.
* @return True if the link was good, false otherwise.
*/
protected boolean checkLink(URL url)
{
try {
URLConnection connection = url.openConnection();
connection.connect();
return true;
} catch ( IOException e ) {
return false;
}
}

/**
* Called when the spider finds an e-mail address
*
* @param email The email address the spider found.
*/
public void spiderFoundEMail(String email)
{
}
/**
* Internal class used to update the error information
* in a Thread-Safe way
*
* @author Jeff Heaton
* @version 1.0
*/

class UpdateErrors implements Runnable {
public String msg;
public void run()
{
errors.append(msg);
}
}
/**
* Used to update the current status information
* in a "Thread-Safe" way
*
* @author Jeff Heaton
* @version 1.0
*/

class UpdateCurrentStats implements Runnable {
public String msg;
public void run()
{
current.setText("Currently Processing: " + msg );
goodLinksLabel.setText("Good Links: " + goodLinksCount);
badLinksLabel.setText("Bad Links: " + badLinksCount);
}
}
}

Listing 2: Reporting spider events(ISpiderReportable.java)

import java.net.*;

interface ISpiderReportable {
public boolean spiderFoundURL(URL base,URL url);
public void spiderURLError(URL url);
public void spiderFoundEMail(String email);
}

Listing 3: A reusable spider (Spider.java)

import java.util.*;
import java.net.*;
import java.io.*;
import javax.swing.text.*;
import javax.swing.text.html.*;

/**
* That class implements a reusable spider
*
* @author Jeff Heaton(http://www.jeffheaton.com)
* @version 1.0
*/
public class Spider {

/**
* A collection of URLs that resulted in an error
*/
protected Collection workloadError = new ArrayList(3);

/**
* A collection of URLs that are waiting to be processed
*/
protected Collection workloadWaiting = new ArrayList(3);

/**
* A collection of URLs that were processed
*/
protected Collection workloadProcessed = new ArrayList(3);

/**
* The class that the spider should report its URLs to
*/
protected ISpiderReportable report;

/**
* A flag that indicates whether this process
* should be canceled
*/
protected boolean cancel = false;

/**
* The constructor
*
* @param report A class that implements the ISpiderReportable
* interface, that will receive information that the
* spider finds.
*/
public Spider(ISpiderReportable report)
{
this.report = report;
}

/**
* Get the URLs that resulted in an error.
*
* @return A collection of URL's.
*/
public Collection getWorkloadError()
{
return workloadError;
}

/**
* Get the URLs that were waiting to be processed.
* You should add one URL to this collection to
* begin the spider.
*
* @return A collection of URLs.
*/
public Collection getWorkloadWaiting()
{
return workloadWaiting;
}

/**
* Get the URLs that were processed by this spider.
*
* @return A collection of URLs.
*/
public Collection getWorkloadProcessed()
{
return workloadProcessed;
}

/**
* Clear all of the workloads.
*/
public void clear()
{
getWorkloadError().clear();
getWorkloadWaiting().clear();
getWorkloadProcessed().clear();
}

/**
* Set a flag that will cause the begin
* method to return before it is done.
*/
public void cancel()
{
cancel = true;
}

/**
* Add a URL for processing.
*
* @param url
*/
public void addURL(URL url)
{
if ( getWorkloadWaiting().contains(url) )
return;
if ( getWorkloadError().contains(url) )
return;
if ( getWorkloadProcessed().contains(url) )
return;
log("Adding to workload: " + url );
getWorkloadWaiting().add(url);
}

/**
* Called internally to process a URL
*
* @param url The URL to be processed.
*/
public void processURL(URL url)
{
try {
log("Processing: " + url );
// get the URL's contents
URLConnection connection = url.openConnection();
if ( (connection.getContentType()!=null) &&
!connection.getContentType().toLowerCase().s
tartsWith("text/") ) {
getWorkloadWaiting().remove(url);
getWorkloadProcessed().add(url);
log("Not processing because content type is: " +
connection.getContentType() );
return;
}

// read the URL
InputStream is = connection.getInputStream();
Reader r = new InputStreamReader(is);
// parse the URL
HTMLEditorKit.Parser parse = new HTMLParse().getParser();
parse.parse(r,new Parser(url),true);
} catch ( IOException e ) {
getWorkloadWaiting().remove(url);
getWorkloadError().add(url);
log("Error: " + url );
report.spiderURLError(url);
return;
}
// mark URL as complete
getWorkloadWaiting().remove(url);
getWorkloadProcessed().add(url);
log("Complete: " + url );

}

/**
* Called to start the spider
*/
public void begin()
{
cancel = false;
while ( !getWorkloadWaiting().isEmpty() && !cancel ) {
Object list[] = getWorkloadWaiting().toArray();
for ( int i=0;(i<list.length)&&!cancel;i++ )
processURL((URL)list[i]);
}
}

/**
* A HTML parser callback used by this class to detect links
*
* @author Jeff Heaton
* @version 1.0
*/
protected class Parser
extends HTMLEditorKit.ParserCallback {
protected URL base;

public Parser(URL base)
{
this.base = base;
}

public void handleSimpleTag(HTML.Tag t,
MutableAttributeSet a,int pos)
{
String href = (String)a.getAttribute(HTML.Attribute.HREF);

if( (href==null) && (t==HTML.Tag.FRAME) )
href = (String)a.getAttribute(HTML.Attribute.SRC);

if ( href==null )
return;

int i = href.indexOf('#');
if ( i!=-1 )
href = href.substring(0,i);

if ( href.toLowerCase().startsWith("mailto:") ) {
report.spiderFoundEMail(href);
return;
}

handleLink(base,href);
}

public void handleStartTag(HTML.Tag t,
MutableAttributeSet a,int pos)
{
handleSimpleTag(t,a,pos); // handle the same way

}

protected void handleLink(URL base,String str)
{
try {
URL url = new URL(base,str);
if ( report.spiderFoundURL(base,url) )
addURL(url);
} catch ( MalformedURLException e ) {
log("Found malformed URL: " + str );
}
}
}

/**
* Called internally to log information
* This basic method just writes the log
* out to the stdout.
*
* @param entry The information to be written to the log.
*/
public void log(String entry)
{
System.out.println( (new Date()) + ":" + entry );
}
}

Listing 4: Parsing HTML (HTMLParse.java)

import javax.swing.text.html.*;

public class HTMLParse extends HTMLEditorKit {

public HTMLEditorKit.Parser getParser()
{
return super.getParser();
}
}

Author Bio: Jeff is the author of JSTL: JSP Standard Tag Library (Sams, 2002) and Programming Spiders, Bots, and Aggregators (Sybex, 2002). Jeff is a member of IEEE and a graduate student at Washington University in St. Louis. Jeff can be contacted through his Web site athttp://www.jeffheaton.com

Author Contact Info:
Jeff Heaton
heatonj@heat-on.com
636-530-9829

************************************************************************************翻译：by：shuidao