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
[e-mail]
636-530-9829

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