Lucene in der Praxis

Um Lucene benutzen zu können, müssen zunächst die entsprechenden Dateien runtergeladen werden, entweder über diese Download-Seite, oder aber direkt über die offizielle Lucene-FTP-Seite. Nachdem die Dateien entpackt wurden, müssen zu der CLASSPATH-Variable die Dateien "lucene-1.2.jar" und, um die Demos ausprobieren zu können, "lucene-demos-1.2.jar" hinzugefügt werden.

Wir wollen uns nun eine kleine Demoanwendung angucken, um zu sehen, wie Lucene in der Praxis funktionieren kann. Die benötigten Java-Quellen können von der Download-Seite heruntergeladen werden.

Ein Beispielprogramm mit Lucene

Nachdem die Quellen (IndexFiles.java und SearchFiles.java) auf übliche Weise kompiliert wurden, wird nun der Index erstellt. Dazu wird IndexFiles ausgeführt und als Argument der Pfad übergeben, dessen Dateien indiziert werden sollen, z. B. "{Lucene-Pfad}/src", um die Lucene-Quelldateien durchsuchen zu können (java IndexFiles {Lucene-Pfad}/src).
Nun wird der Index erstellt. Danach wird SearchFiles ausgeführt (java SearchFiles) und man kann eine Suchanfrage eingeben.
Für diese Mini-Suchmaschine werden also lediglich die drei relativ kurzen Quellen "IndexFiles", "SearchFiles" und "FileDocument" benötigt.

Für das Programmieren eigener Anwendungen, die Lucene nutzen, empfiehlt sich immer wieder ein Blick in die javadoc-Dokumentationen der Lucene-Klassen.

Schauen wir uns zunächst einmal die Datei "IndexFiles.java" an, mit Hilfe derer der Index erstellt wird.

import org.apache.lucene.analysis.de.GermanAnalyzer;
import org.apache.lucene.index.IndexWriter;

import java.io.*;
import java.util.*;

public
class IndexFiles 
{
  public static
  void main(String[] args)
  {
    try
    {
      Date start = new Date();

      IndexWriter writer = new IndexWriter(Const.INDEX_DIR, new GermanAnalyzer(), true);
      indexDocs(writer, new File(args[0]));

      writer.optimize();
      writer.close();
    }
    catch (Exception e)
    {
      System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
    }
  }

  public static void indexDocs(IndexWriter writer, File file)
    throws Exception
  {
    if (file.isDirectory())
    {
      String[] files = file.list();
      for (int i = 0; i < files.length; i++)
      indexDocs(writer, new File(file, files[i]));
    } 
    else
    {
      System.out.println("hinzugefuegt: " + file);
      writer.addDocument(FileDocument.Document(file));
    }
  }
}

Zunächst wird eine Instanz von "IndexWriter" erstellt.

Erstes Argument: Name des Verzeichnisses, in dem der Index erstellt wird.
Zweites Argument: der entsprechende "Analyzer": dieser ist dafür zuständig, den Text zu analysieren und entsprechende Operationen zu unternehmen, wie etwa alles in Kleinschreibung umwandeln, oder unnütze Wörter entfernen, z. B. Artikel oder Konjunktionen. Da dieses sprachspezifisch ist, existieren verschiedene Analyzer. In diesem Fall wurde der deutsche gewählt, offiziell existieren momentan welche für Englisch und Deutsch.
Drittes Argument: gibt an, ob ein neuer Index erstellt (true), oder zu einem bestehenden weitere Dokumente hinzugefügt werden sollen.

Dann wird "indexDocs(...)" aufgerufen:

"indexDocs(...)" (weiter unten) durchläuft rekursiv die Verzeichnisse und Dateien.
wurde eine Datei gefunden, wird diese mittels "addDocument(...)" dem "IndexWriter" hinzugefügt.

Dann die Datei "FileDocument.java"

import java.io.*;
import org.apache.lucene.document.*;

public
class FileDocument
{
  public static
  Document Document(File f)
    throws java.io.FileNotFoundException
  {
    Document doc = new Document();
    doc.add(Field.Text(Const.PATH_FIELD, f.getPath()));
    doc.add(Field.Keyword(Const.MOD_FIELD,
              DateField.timeToString(f.lastModified())));

    FileInputStream is = new FileInputStream(f);
    Reader reader = new BufferedReader(new InputStreamReader(is));
    doc.add(Field.Text(Const.DEF_FIELD, reader));

    return doc;
  }
}

Diese erstellt ein Dokument für eine zu indizierende Datei.
Zunächst wird das Feld "pfad", also der Pfad der Datei hinzugefügt.
Dann wird das "geänderd-Datum" ausgelesen und hinzugefügt (Feld: geaendert).
Dann wird der Dateiinhalt mit Hilfe eines "InputStreamReader" ausgelesen und dem Feld "inhalt" hinzugefügt.
Das entstandene Dokument wird schließlich zurückgeliefert.

Schließlich die Datei "SearchFiles.java".

import java.io.*;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.de.GermanAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.search.*;
import org.apache.lucene.queryParser.QueryParser;

public
class SearchFiles
{
  public static
  void main(String[] args)
  {
    try
    {
      Searcher searcher = new IndexSearcher(Const.INDEX_DIR);
      Analyzer analyzer = new GermanAnalyzer();

      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      // einlesen
      boolean lineEnd=false;
      while (!lineEnd)
      {
        System.out.print("Suchbegriff eingeben (<Enter>, um zu verlassen): ");
        String line = in.readLine();

        if (line.length() == -1)
          lineEnd=true;
        else
        {
          Query query = QueryParser.parse(line, Const.DEF_FIELD, analyzer);
          System.out.println("Suchbegriff: " + query.toString(Const.DEF_FIELD));

          Hits hits = searcher.search(query);
          System.out.println(hits.length() + " Dokumente gefunden");

          final int HITS_PER_PAGE = 10;
          int end = hits.length();
          for (int i=0; i<end; i++)
          {
            Document doc = hits.doc(i);
            String path = doc.get(Const.PATH_FIELD);
            System.out.println(i + ". " + path);
          }
        }
      }
      searcher.close();

    }
    catch (Exception e)
    {
      System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
    }
  }
}

Diese Klasse arbeitet mit einem "IndexSearcher" (durchsucht den Index), Achtung: richtiges Index-Verzeichnis angeben) zusammen, mit einem Analyzer, vorzugsweise der gleiche, wie in "IndexFiles" und einem "QueryParser".
Im Konstruktor des "QueryParser" ("query") wird konstruiert, indem die Eingabe übergeben wird, der Analyzer, um eine Suchanfrage auf die gleiche Weise zu interpretieren, wie die Inhalte der indizierten Dokumente und der Name des Default-Feldes.
Die Suchergebnisse werden zurückgeliefert in einer Sammlung von Dokumenten (Klasse "Hits"), die dann durchlaufen und angezeigt werden.

Lucene in der Praxis

Übersicht: Lucene in der Praxis

Download und Installation von Lucene

Ein Beispielprogramm mit Lucene

Schauen wir uns zunächst einmal die Datei "IndexFiles.java" an, mit Hilfe derer der Index erstellt wird.

Dann die Datei "FileDocument.java"

Schließlich die Datei "SearchFiles.java".