天天看點
傳回

java網絡爬蟲簡單實作

網絡爬蟲是一個自動提取網頁的程式，它為搜尋引擎從網際網路上下載下傳網頁，是搜尋引擎的重要組成，其基本架構如下圖所示：

java網絡爬蟲簡單實作

傳統爬蟲從一個或若幹初始網頁的URL開始，獲得初始網頁上的URL，在抓取網頁的過程中，不斷從目前頁面上抽取新的URL放入隊列，直到滿足系統的一定停止條件。對于垂直搜尋來說，聚焦爬蟲，即有針對性地爬取特定主題網頁的爬蟲，更為适合。

本文爬蟲程式的核心代碼如下：

Java代碼

     
  1.  public void crawl() throws Throwable {            
    2.       
  2.      while (continueCrawling()) {            
    3.       
  3.          CrawlerUrl url = getNextUrl(); //擷取待爬取隊列中的下一個URL            
    4.       
  4.          if (url != null) {            
    5.       
  5.              printCrawlInfo();             
    6.       
  6.              String content = getContent(url); //擷取URL的文本資訊            
    7.           
  7.              //聚焦爬蟲隻爬取與主題内容相關的網頁，這裡采用正則比對簡單處理            
    8.       
  8.              if (isContentRelevant(content, this.regexpSearchPattern)) {            
    9.       
  9.                  saveContent(url, content); //儲存網頁至本地            
    10.           
  10.                  //擷取網頁内容中的連結，并放入待爬取隊列中            
    11.       
  11.                  Collection urlStrings = extractUrls(content, url);            
    12.       
  12.                  addUrlsToUrlQueue(url, urlStrings);            
    13.       
  13.              } else {            
    14.       
  14.                  System.out.println(url + " is not relevant ignoring ...");            
    15.       
  15.              }            
    16.           
  16.              //延時防止被對方屏蔽            
    17.       
  17.              Thread.sleep(this.delayBetweenUrls);            
    18.       
  18.          }            
    19.       
  19.      }            
    20.       
  20.      closeOutputStream();            
    21.       
  21.  }           
    22.

整個函數由getNextUrl、getContent、isContentRelevant、extractUrls、addUrlsToUrlQueue等幾個核心方法組成，下面将一一介紹。先看getNextUrl：

Java代碼

java網絡爬蟲簡單實作
     
  1.  private CrawlerUrl getNextUrl() throws Throwable {            
    2.       
  2.      CrawlerUrl nextUrl = null;            
    3.       
  3.      while ((nextUrl == null) && (!urlQueue.isEmpty())) {            
    4.       
  4.          CrawlerUrl crawlerUrl = this.urlQueue.remove();            
    5.           
  5.          //doWeHavePermissionToVisit：是否有權限通路該URL，友好的爬蟲會根據網站提供的"Robot.txt"中配置的規則進行爬取            
    6.       
  6.          //isUrlAlreadyVisited：URL是否通路過，大型的搜尋引擎往往采用BloomFilter進行排重，這裡簡單使用HashMap            
    7.       
  7.          //isDepthAcceptable：是否達到指定的深度上限。爬蟲一般采取廣度優先的方式。一些網站會建構爬蟲陷阱（自動生成一些無效連結使爬蟲陷入死循環），采用深度限制加以避免            
    8.       
  8.          if (doWeHavePermissionToVisit(crawlerUrl)            
    9.       
  9.              && (!isUrlAlreadyVisited(crawlerUrl))             
    10.       
  10.              && isDepthAcceptable(crawlerUrl)) {            
    11.       
  11.              nextUrl = crawlerUrl;            
    12.       
  12.              // System.out.println("Next url to be visited is " + nextUrl);            
    13.       
  13.          }            
    14.       
  14.      }            
    15.       
  15.      return nextUrl;            
    16.       
  16.  }          
    17.

更多的關于robot.txt的具體寫法，可參考以下這篇文章：

http://www.bloghuman.com/post/67/

getContent内部使用apache的httpclient 4.1擷取網頁内容，具體代碼如下：

Java代碼

     
  1.  private String getContent(CrawlerUrl url) throws Throwable {            
    2.       
  2.      //HttpClient4.1的調用與之前的方式不同            
    3.       
  3.      HttpClient client = new DefaultHttpClient();            
    4.       
  4.      HttpGet httpGet = new HttpGet(url.getUrlString());            
    5.       
  5.      StringBuffer strBuf = new StringBuffer();            
    6.       
  6.      HttpResponse response = client.execute(httpGet);            
    7.       
  7.      if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {            
    8.       
  8.          HttpEntity entity = response.getEntity();            
    9.       
  9.          if (entity != null) {            
    10.       
  10.              BufferedReader reader = new BufferedReader(            
    11.       
  11.                  new InputStreamReader(entity.getContent(), "UTF-8"));            
    12.       
  12.              String line = null;            
    13.       
  13.              if (entity.getContentLength() > 0) {            
    14.       
  14.                  strBuf = new StringBuffer((int) entity.getContentLength());            
    15.       
  15.                  while ((line = reader.readLine()) != null) {            
    16.       
  16.                      strBuf.append(line);            
    17.       
  17.                  }            
    18.       
  18.              }            
    19.       
  19.          }            
    20.       
  20.          if (entity != null) {            
    21.       
  21.              entity.consumeContent();            
    22.       
  22.          }            
    23.       
  23.      }            
    24.       
  24.      //将url标記為已通路            
    25.       
  25.      markUrlAsVisited(url);            
    26.       
  26.      return strBuf.toString();            
    27.       
  27.  }           
    28.

對于垂直型應用來說，資料的準确性往往更為重要。聚焦型爬蟲的主要特點是，隻收集和主題相關的資料，這就是isContentRelevant方法的作用。這裡或許要使用分類預測技術，為簡單起見，采用正則比對來代替。其主要代碼如下：

Java代碼

     
  1.  public static boolean isContentRelevant(String content,            
    2.       
  2.  Pattern regexpPattern) {            
    3.       
  3.      boolean retValue = false;            
    4.       
  4.      if (content != null) {            
    5.       
  5.          //是否符合正規表達式的條件            
    6.       
  6.          Matcher m = regexpPattern.matcher(content.toLowerCase());            
    7.       
  7.          retValue = m.find();            
    8.       
  8.      }            
    9.       
  9.      return retValue;            
    10.       
  10.  }           
    11.

extractUrls的主要作用，是從網頁中擷取更多的URL，包括内部連結和外部連結，代碼如下：

Java代碼

     
  1.  http://developer.51cto.com/art/201103/248141.htm       
    2.       
  2.  public List extractUrls(String text, CrawlerUrl crawlerUrl) {            
    3.       
  3.      Map urlMap = new HashMap();            
    4.       
  4.      extractHttpUrls(urlMap, text);            
    5.       
  5.      extractRelativeUrls(urlMap, text, crawlerUrl);            
    6.       
  6.      return new ArrayList(urlMap.keySet());            
    7.       
  7.  }            
    8.           
  8.  //處理外部連結            
    9.       
  9.  private void extractHttpUrls(Map urlMap, String text) {            
    10.       
  10.      Matcher m = httpRegexp.matcher(text);            
    11.       
  11.      while (m.find()) {            
    12.       
  12.          String url = m.group();            
    13.       
  13.          String[] terms = url.split("a href=\"");            
    14.       
  14.          for (String term : terms) {            
    15.       
  15.              // System.out.println("Term = " + term);            
    16.       
  16.              if (term.startsWith("http")) {            
    17.       
  17.                  int index = term.indexOf("\"");            
    18.       
  18.                  if (index > 0) {            
    19.       
  19.                      term = term.substring(0, index);            
    20.       
  20.                  }            
    21.       
  21.                  urlMap.put(term, term);            
    22.       
  22.                  System.out.println("Hyperlink: " + term);            
    23.       
  23.              }            
    24.       
  24.          }            
    25.       
  25.      }            
    26.       
  26.  }            
    27.           
  27.  //處理内部連結            
    28.       
  28.  private void extractRelativeUrls(Map urlMap, String text,            
    29.       
  29.          CrawlerUrl crawlerUrl) {            
    30.       
  30.      Matcher m = relativeRegexp.matcher(text);            
    31.       
  31.      URL textURL = crawlerUrl.getURL();            
    32.       
  32.      String host = textURL.getHost();            
    33.       
  33.      while (m.find()) {            
    34.       
  34.          String url = m.group();            
    35.       
  35.          String[] terms = url.split("a href=\"");            
    36.       
  36.          for (String term : terms) {            
    37.       
  37.              if (term.startsWith("/")) {            
    38.       
  38.                  int index = term.indexOf("\"");            
    39.       
  39.                  if (index > 0) {            
    40.       
  40.                      term = term.substring(0, index);            
    41.       
  41.                  }            
    42.       
  42.                  String s = "http://" + host + term;            
    43.       
  43.                  urlMap.put(s, s);            
    44.       
  44.                  System.out.println("Relative url: " + s);            
    45.       
  45.              }            
    46.       
  46.          }            
    47.       
  47.      }            
    48.           
  48.  }           
    49.

如此，便建構了一個簡單的網絡爬蟲程式，可以使用以下程式來測試它：

Java代碼

     
  1.  public static void main(String[] args) {            
    2.       
  2.      try {            
    3.       
  3.          String url = "http://www.amazon.com";            
    4.       
  4.          Queue urlQueue = new LinkedList();            
    5.       
  5.          String regexp = "java";            
    6.       
  6.          urlQueue.add(new CrawlerUrl(url, 0));            
    7.       
  7.          NaiveCrawler crawler = new NaiveCrawler(urlQueue, 100, 5, 1000L,            
    8.       
  8.                  regexp);            
    9.       
  9.          // boolean allowCrawl = crawler.areWeAllowedToVisit(url);            
    10.       
  10.          // System.out.println("Allowed to crawl: " + url + " " +            
    11.       
  11.          // allowCrawl);            
    12.       
  12.          crawler.crawl();            
    13.       
  13.      } catch (Throwable t) {            
    14.       
  14.          System.out.println(t.toString());            
    15.       
  15.          t.printStackTrace();            
    16.       
  16.      }            
    17.       
  17.  }           
    18.

當然，你可以為它賦予更為進階的功能，比如多線程、更智能的聚焦、結合Lucene建立索引等等。更為複雜的情況，可以考慮使用一些開源的蜘蛛程式，比如Nutch或是Heritrix等等，就不在本文的讨論範圍了。

java 爬蟲 網絡爬蟲
上一篇: Python系列爬蟲之Scrapy實戰 | 中國地震台網爬蟲前言開發工具環境搭建資料爬取
下一篇: 實作簡易Java網絡爬蟲

繼續閱讀