Denkt man heut­zu­ta­ge an eine Such­ma­schi­ne, haben alle zunächst Google im Kopf. Auch Betreiber von Websites nutzen Google in Form der Custom Search Engine (CSE), um Nutzern schnell und einfach eine Such­funk­ti­on für ihre eigenen Inhalte an­zu­bie­ten. Doch selbst­ver­ständ­lich ist das nicht die einzige – und für viele Website-Betreiber auch nicht die beste – Mög­lich­keit, den Besuchern eine Voll­text­su­che an­zu­bie­ten. Statt­des­sen können Sie Lucene verwenden: ein kos­ten­lo­ses Open-Source-Projekt von Apache.

Zahl­rei­che Firmen haben Apache Lucene bei sich ein­ge­bun­den – entweder online oder offline. Die Wikipedia hatte bis vor einigen Jahren Lucene als Such­funk­ti­on im­ple­men­tiert und nutzt in­zwi­schen Solr, das auf Lucene aufbaut, und auch die Suche bei Twitter läuft komplett über Lucene. Aus dem Projekt, das von Doug Cutting Ende der 1990er als Hobby gestartet wurde, hat sich in­zwi­schen eine Software ent­wi­ckelt, von der täglich Millionen von Menschen pro­fi­tie­ren.

Was ist Lucene?

Bei Lucene handelt es sich um eine Pro­gramm­bi­blio­thek, die von der Apache Software Foun­da­ti­on ver­öf­fent­licht wird. Sie ist Open Source und für jeden kostenlos zu benutzen und zu verändern. Ur­sprüng­lich hat man Lucene komplett in Java ge­schrie­ben, in­zwi­schen gibt es aber auch Por­tie­run­gen in andere Pro­gram­mier­spra­chen. Mit Apache Solr und Ela­s­tic­se­arch gibt es mächtige Er­wei­te­run­gen, die der Such­funk­ti­on noch mehr Mög­lich­kei­ten geben.

Lucene ist eine Voll­text­su­che. Das bedeutet ganz simpel ge­spro­chen: Ein Programm durch­sucht eine Reihe von Text­do­ku­men­ten nach einem oder mehreren vom Nutzer be­stimm­ten Begriffen. Darin erkennt man schon, dass Lucene gar nicht aus­schließ­lich im Kontext des World Wide Webs Ver­wen­dung findet – auch wenn die Such­funk­tio­nen hier om­ni­prä­sent sind. Auch für Archive, Bi­blio­the­ken oder sogar den hei­mi­schen Desktop-PC kann man Lucene einsetzen. Lucene durch­sucht nämlich nicht nur HTML-Dokumente, sondern arbeitet z. B. auch mit E-Mail oder sogar PDF-Dateien.

Aus­schlag­ge­bend für die Suche ist ein Index – das Herz von Lucene: Hier sind alle Begriffe aller Dokumente ge­spei­chert. Ein solcher Inverted Index ist prin­zi­pi­ell nur eine Tabelle – zu jedem Begriff ist die ent­spre­chen­de Position ge­spei­chert. Damit man einen Index aufbauen kann, bedarf es zunächst einer Ex­tra­hie­rung. Alle Begriffe müssen aus allen Do­ku­men­ten gezogen und im Index ge­spei­chert werden. Lucene gibt Nutzern die Mög­lich­keit, diese Ex­tra­hie­rung in­di­vi­du­ell zu kon­fi­gu­rie­ren. Ent­wick­ler ent­schei­den sich bei der Kon­fi­gu­ra­ti­on, welche Felder sie in den Index aufnehmen möchten. Um dies zu verstehen, muss man einen Schritt zu­rück­ge­hen.

Die Objekte, mit denen Lucene arbeitet, sind Dokumente in jeglicher Form. Die Dokumente selbst enthalten aber – aus der Sicht­wei­se von Lucene ge­spro­chen – Felder. In diesen stehen z. B. der Name der Autorin, der Titel des Dokuments oder der Dateiname des selbigen. Jedes Feld hat eine ein­deu­ti­ge Be­zeich­nung und einen Wert. So kann das Feld mit der Be­zeich­nung title etwa den Wert „Ge­brauchs­an­wei­sung für Apache Lucene“ haben. Beim Erstellen des Indexes kann man sich also ent­schei­den, welche Metadaten man aufnehmen möchte.

Bei der In­di­zie­rung der Dokumente findet zudem eine so­ge­nann­te To­ke­ni­sie­rung statt. Für eine Maschine ist ein Dokument zunächst einmal eine An­samm­lung von In­for­ma­tio­nen. Selbst wenn man sich von der Ebene der Bits löst und sich dem für Menschen lesbaren Inhalt zuwendet, besteht ein Dokument aus einer An­ein­an­der­rei­hung von Zeichen: Buch­sta­ben, Satz­zei­chen, Leer­zei­chen.

Aus dieser Da­ten­men­ge erzeugt man mit der To­ke­ni­sie­rung Segmente, die Begriffe (meistens einzelne Wörter), nach denen schließ­lich gesucht werden kann. Die ein­fachs­te Art, wie eine solche To­ke­ni­sie­rung ablaufen kann, funk­tio­niert mit der White-Space-Methode: Ein Begriff endet dann, wenn ein Leer­zei­chen (ein weißer Zwi­schen­raum) auftritt. Dies ist aber nicht ziel­füh­rend, wenn feste Begriffe aus mehreren Wörtern bestehen, bei­spiels­wei­se der „Heilige Abend“. Dafür kommen zu­sätz­lich Wör­ter­bü­cher zum Einsatz, die man auch in den Lucene-Code im­ple­men­tie­ren kann.

Bei der Analyse der Daten, von der die To­ke­ni­sie­rung ein Teil ist, führt Lucene zudem eine Nor­ma­li­sie­rung durch. Das heißt, die Begriffe werden in eine stan­dar­di­sier­te Form gebracht, indem z. B. alle Groß­buch­sta­ben klein­ge­schrie­ben werden. Zudem schafft Lucene eine Sor­tie­rung. Diese funk­tio­niert über ver­schie­de­ne Al­go­rith­men – z. B. über das TF-IDF-Maß. Als Nutzer möchte man wahr­schein­lich die re­le­van­tes­ten oder neuesten Er­geb­nis­se zuerst erhalten – die Al­go­rith­men der Such­ma­schi­ne er­mög­li­chen dies.

Damit Nutzer überhaupt etwas finden, müssen sie einen Such­be­griff in eine Textzeile eingeben. Den Begriff bzw. die Begriffe nennt man im Kontext von Lucene Query. Das englische Wort für Anfrage deutet an, dass die Eingabe eben nicht nur aus einem Wort oder mehreren bestehen muss, sondern auch Mo­di­fi­ka­to­ren wie AND, OR oder auch + und - sowie Platz­hal­ter enthalten kann. Der Query­Par­ser – eine Klasse innerhalb der Pro­gramm­bi­blio­thek – übersetzt die Eingabe in einen konkreten Such­auf­trag für die Such­ma­schi­ne. Auch beim Query­Par­ser haben Ent­wick­ler Ein­stel­lungs­mög­lich­kei­ten. Den Parser kann man so kon­fi­gu­rie­ren, dass er genau auf die Be­dürf­nis­se der Nutzer zu­ge­schnit­ten ist.

Was Lucene bei Er­schei­nen komplett neu machte: die in­kre­men­tel­le In­di­zie­rung. Vor Lucene war nur das so­ge­nann­te Batch-Indexing möglich. Während man damit nur komplette Indexe im­ple­men­tie­ren kann, lässt sich mit einer in­kre­men­tel­len In­di­zie­rung ein Index ak­tua­li­sie­ren. Einzelne Einträge können hin­zu­ge­fügt oder entfernt werden.

Bild: Schematische Darstellung der Prozesse innerhalb von Apache Lucene
Im Zentrum von Lucene steht der Index

Lucene vs. Google & Co.?

Die Frage scheint be­rech­tigt: Warum sollte man eine eigene Such­ma­schi­ne bauen, wenn es doch auch Google, Bing oder andere Search Engines gibt? Dies lässt sich natürlich nicht einfach be­ant­wor­ten, schließ­lich muss man den in­di­vi­du­el­len An­wen­dungs­wunsch be­trach­ten. Eines ist aber wichtig zum Ver­ständ­nis: Wenn wir von Lucene als Such­ma­schi­ne sprechen, ist das nur eine ver­ein­fach­te Be­zeich­nung.

Tat­säch­lich ist es eine In­for­ma­ti­on Retrieval Library. Lucene ist damit ein System, mit dem In­for­ma­tio­nen gefunden werden können. Das sind Google und andere Such­ma­schi­nen an sich auch, aber diese be­schrän­ken sich auf In­for­ma­tio­nen aus dem World Wide Web. Lucene können Sie in jedem Szenario anwenden und so kon­fi­gu­rie­ren, wie es für Ihren Zweck passend ist. So bauen Sie Lucene z. B. auch in andere An­wen­dun­gen ein.

Fazit

Apaches Lucene ist im Gegensatz zu Web Search Engines keine fertige Software: Um von den Mög­lich­kei­ten des Systems pro­fi­tie­ren zu können, müssen Sie eine eigene Such­ma­schi­ne zunächst pro­gram­mie­ren. Wir zeigen Ihnen die ersten Schritte in unserem Lucene-Tutorial.

Lucene, Solr, Ela­s­tic­se­arch – wo sind die Un­ter­schie­de?

Gerade Ein­stei­ger fragen sich, was denn ei­gent­lich der Un­ter­schied zwischen Apache Lucene auf der einen sowie Apache Solr und Ela­s­tic­se­arch auf der anderen Seite ist. Die beiden Letzteren bauen auf Lucene auf: Bei dem älteren Produkt handelt es sich um eine reine Such­ma­schi­ne. Solr und Ela­s­tic­se­arch hingegen stellen komplette Such­ser­ver dar, die den Umfang von Lucene noch erweitern.

Hinweis

Wenn Sie nur eine Such­funk­ti­on für Ihre Website benötigen, sind Sie wahr­schein­lich mit Solr oder Ela­s­tic­se­arch besser bedient. Diese beiden Systeme sind konkret für den Einsatz im Web ausgelegt.

Apache Lucene – das Tutorial

Lucene basiert in der Ori­gi­nal­ver­si­on auf Java, was es möglich macht, die Such­ma­schi­ne für ver­schie­de­ne Platt­for­men on- und offline ein­zu­set­zen – wenn man weiß, wie es geht. Wir erklären Ihnen Schritt für Schritt, wie Sie eine eigene Such­ma­schi­ne mit Apache Lucene bauen.

Hinweis

In diesem Tutorial befassen wir uns mit Lucene auf der Basis von Java. Der Code wurde unter der Lucene-Version 7.3.1 und der JDK-Version 8 getestet. Wir arbeiten mit Eclipse unter Ubuntu. Einzelne Schritte können unter der Ver­wen­dung von anderen Ent­wick­lungs­um­ge­bun­gen und Be­triebs­sys­te­men anders verlaufen.

In­stal­la­ti­on

Damit Sie mit Apache Lucene arbeiten können, muss Java bei Ihnen in­stal­liert sein. Genau wie Lucene können Sie auch das Java De­ve­lo­p­ment Kit (JDK) kostenlos auf der of­fi­zi­el­len Website down­loa­den. Zudem sollten Sie noch eine Ent­wick­lungs­um­ge­bung in­stal­lie­ren, mit der Sie den Code für Lucene schließ­lich schreiben können. Viele Ent­wick­ler setzen auf Eclipse, aber es gibt noch zahl­rei­che andere Open-Source-Angebote. Im Anschluss können Sie Lucene von der Pro­jekt­sei­te her­un­ter­la­den. Wählen Sie hierfür die Core-Version des Programms.

Sie brauchen Lucene nicht zu in­stal­lie­ren. Entpacken Sie den Download einfach an einen ge­wünsch­ten Ort. Sie erstellen an­schlie­ßend in Eclipse oder einer anderen Ent­wick­lungs­um­ge­bung ein neues Projekt und fügen Lucene als Library hinzu. Für dieses Beispiel verwenden wir drei Bi­blio­the­ken, die alle im In­stal­la­ti­ons­pa­ket enthalten sind:

  • …/lucene-7.3.1/core/lucene-core-7.3.1.jar
  • …/lucene-7.3.1/query­par­ser/lucene-query­par­ser-7.3.1.jar
  • …/lucene-7.3.1/analysis/common/lucene-analyzers-common-7.3.1.jar

Sollten Sie eine andere Version verwenden oder die Ord­ner­struk­tur verändert haben, müssen Sie die Angaben ent­spre­chend anpassen.

Bild: Hinzufügen von Bibliotheken in Eclipse
Fügen Sie Ihrem Projekt die be­nö­tig­ten Bi­blio­the­ken hinzu.
Tipp

Ohne grund­le­gen­de Kennt­nis­se in Java und Pro­gram­mier­ar­beit im All­ge­mei­nen sind die folgenden Schritte nur schwer nach­zu­voll­zie­hen. Wenn Sie al­ler­dings schon Ba­sis­wis­sen in dieser Pro­gram­mier­spra­che besitzen, ist die Arbeit mit Lucene eine gute Mög­lich­keit, Ihre Fä­hig­kei­ten aus­zu­bau­en.

In­de­xie­rung

Das Kernstück einer Such­ma­schi­ne, die auf Lucene basiert, ist der Index. Ohne einen Index können Sie keine Such­funk­ti­on anbieten. Deshalb ist dies der erste Schritt: Wir erstellen eine Java-Klasse für die In­de­xie­rung.

Bevor wir aber den ei­gent­li­chen In­de­xie­rungs­me­cha­nis­mus bauen, erstellen wir zwei Klassen, die Ihnen als Hilfe für die weiteren dienen. Sowohl die Index-Klasse als auch die Such-Klasse greifen später auf die beiden zurück.

package tutorial;
public class LuceneConstants {
    public static final String CONTENTS = "contents";
    public static final String FILE_NAME = "filename";
    public static final String FILE_PATH = "filepath";
    public static final int MAX_SEARCH = 10;

Diese In­for­ma­tio­nen sind später wichtig, wenn es darum geht, Felder genau zu bestimmen.

package tutorial;
import java.io.File;
import java.io.FileFilter;
public class TextFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        return pathname.getName().toLowerCase().endsWith(".txt");
    }
}

Hiermit im­ple­men­tie­ren wir einen Filter, der unsere Dokumente richtig einliest. An dieser Stelle erkennen Sie auch schon, dass unsere Such­ma­schi­ne später nur für txt-Dateien funk­ti­ons­tüch­tig ist. Alle anderen Formate ignoriert das einfache Beispiel.

Bild: Textdateien als Suchkorpus für Apache Lucene
In unserem Beispiel dienen einfache Text­da­tei­en als Korpus für die Suche.
Hinweis

Zu Beginn einer Klasse im­por­tie­ren Sie zunächst andere Klassen. Diese sind entweder bereits Teil Ihrer Java-In­stal­la­ti­on oder stehen Ihnen durch die Ein­bin­dung der externen Bi­blio­the­ken zur Verfügung.

Nun erstellen Sie die ei­gent­li­che Klasse für die In­de­xie­rung.

package tutorial;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Indexer {
    private IndexWriter writer;
    public Indexer(String indexDirectoryPath) throws IOException {
        Directory indexDirectory = 
            FSDirectory.open(Paths.get(indexDirectoryPath));
        StandardAnalyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
        writer = new IndexWriter(indexDirectory, iwc);
    }
    public void close() throws CorruptIndexException, IOException {
        writer.close();
    }
    private Document getDocument(File file) throws IOException {
        Document document = new Document();
        TextField contentField = new TextField(LuceneConstants.CONTENTS, new FileReader(file));
        TextField fileNameField = new TextField(LuceneConstants.FILE_NAME,
            file.getName(),TextField.Store.YES);
        TextField filePathField = new TextField(LuceneConstants.FILE_PATH,
            file.getCanonicalPath(),TextField.Store.YES);
        document.add(contentField);
        document.add(fileNameField);
        document.add(filePathField);
        return document;
    }    
    private void indexFile(File file) throws IOException {
        System.out.println("Indexing "+file.getCanonicalPath());
        Document document = getDocument(file);
        writer.addDocument(document);
    }
    public int createIndex(String dataDirPath, FileFilter filter) 
        throws IOException {
        File[] files = new File(dataDirPath).listFiles();
        for (File file : files) {
            if(!file.isDirectory()
                && !file.isHidden()
                && file.exists()
                && file.canRead()
                && filter.accept(file)
            ){
                indexFile(file);
            }
        }
        return writer.numDocs();
    }
}

Im Verlauf des Codes werden ver­schie­de­ne Schritte durch­ge­führt: Sie stellen den In­dex­Wri­ter mithilfe des Stan­dard­Ana­ly­zers ein. Lucene bietet un­ter­schied­li­che Analyse-Klassen, die Sie alle in der ent­spre­chen­den Bi­blio­thek finden.

Tipp

In der Do­ku­men­ta­ti­on von Apache Lucene finden Sie alle Klassen, die im Download enthalten sind.

Des Weiteren liest das Programm Dateien ein und legt Felder für die In­de­xie­rung fest. Zum Ende des Codes werden schließ­lich die Index-Dateien erzeugt.

Bild: Indexdateien von Apache Lucene
Lucene erzeugt aus den Aus­gangs­do­ku­men­ten mehrere In­dex­da­tei­en.

Such­funk­ti­on

Natürlich bringt Ihnen der Index allein nichts. Sie müssen also auch noch eine Such­funk­ti­on eta­blie­ren.

package tutorial;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Searcher {
    
     IndexSearcher indexSearcher;
     QueryParser queryParser;
     Query query;
     
     public Searcher(String indexDirectoryPath) 
            throws IOException {
            Directory indexDirectory = 
                 FSDirectory.open(Paths.get(indexDirectoryPath));
            IndexReader reader = DirectoryReader.open(indexDirectory);
            indexSearcher = new IndexSearcher(reader);
            queryParser = new QueryParser(LuceneConstants.CONTENTS,
                 new StandardAnalyzer());
     }
     
     public TopDocs search( String searchQuery) 
            throws IOException, ParseException {
            query = queryParser.parse(searchQuery);
            return indexSearcher.search(query, LuceneConstants.MAX_SEARCH);
     }
     public Document getDocument(ScoreDoc scoreDoc) 
            throws CorruptIndexException, IOException {
            return indexSearcher.doc(scoreDoc.doc);    
     }
}

Zwei von Lucene im­por­tier­te Klassen sind innerhalb des Codes besonders wichtig: In­dex­Se­ar­cher und Query­Par­ser. Während ersteres den er­stell­ten Index durch­sucht, ist Query­Par­ser dafür zuständig, die Such­an­fra­ge überhaupt in eine für die Maschine ver­ständ­li­che In­for­ma­ti­on zu trans­fe­rie­ren.

Nun haben Sie sowohl eine Klasse zur In­de­xie­rung als auch eine, um den Index zu durch­su­chen, aber einen konkreten Such­auf­trag können Sie mit beiden noch nicht durch­füh­ren. Deshalb brauchen Sie nun noch eine fünfte Klasse.

package tutorial;
import java.io.IOException;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
public class LuceneTester {
    
     String indexDir = "/home/Index/";
     String dataDir = "/home/Data/";
     Indexer indexer;
     Searcher searcher;
     public static void main(String[] args) {
            LuceneTester tester;
            try {
                 tester = new LuceneTester();
                 tester.createIndex();
                 tester.search("YourSearchTerm");
            } catch (IOException e) {
                 e.printStackTrace();
            } catch (ParseException e) {
                 e.printStackTrace();
            }
     }
     private void createIndex() throws IOException {
            indexer = new Indexer(indexDir);
            int numIndexed;
            long startTime = System.currentTimeMillis();    
            numIndexed = indexer.createIndex(dataDir, new TextFileFilter());
            long endTime = System.currentTimeMillis();
            indexer.close();
            System.out.println(numIndexed+" File indexed, time taken: "
                 +(endTime-startTime)+" ms");        
     }
     private void search(String searchQuery) throws IOException, ParseException {
            searcher = new Searcher(indexDir);
            long startTime = System.currentTimeMillis();
            TopDocs hits = searcher.search(searchQuery);
            long endTime = System.currentTimeMillis();
     
            System.out.println(hits.totalHits +
                 " documents found. Time :" + (endTime - startTime));
            for(ScoreDoc scoreDoc : hits.scoreDocs) {
                 Document doc = searcher.getDocument(scoreDoc);
                        System.out.println("File: "
                        + doc.get(LuceneConstants.FILE_PATH));
            }    
     }
}

Min­des­tens drei Einträge in dieser finalen Klassen müssen Sie anpassen, denn hier geben Sie die Pfade zu den Ori­gi­nal­do­ku­men­ten und zu den In­dex­da­tei­en an sowie schließ­lich auch das Suchwort.

  • String indexDir: Hier fügen Sie den Pfad zu dem Ordner ein, in dem Sie die In­dex­da­tei­en speichern möchten.
  • String dataDir: An dieser Stelle erwartet der Quelltext den Pfad zum Ordner, in dem die zu durch­su­chen­den Dokumente ge­spei­chert sind.
  • tester.search: Hier tragen Sie Ihren Such­be­griff ein.

Da es sich in allen drei Fällen um Strings handelt, müssen Sie die Ausdrücke in An­füh­rungs­zei­chen setzen. Auch in Windows verwenden Sie für die Pfade normale Schräg­stri­che statt Back­slas­hes.

Um das Programm zu testen, kopieren Sie einige Klartext-Dateien in das als dataDir an­ge­ge­be­ne Ver­zeich­nis. Achten Sie darauf, dass die Da­tei­endun­gen „.txt“ lauten. Nun können Sie das Programm starten – in Eclipse etwa klicken Sie dafür den grünen Pfeil-Button in der Me­nü­leis­te an.

Hinweis

Bei dem vor­ge­stell­ten Pro­gramm­code handelt es sich nur um ein Demo-Projekt, um die Wir­kungs­wei­se von Lucene zu prä­sen­tie­ren. Bei­spiels­wei­se fehlt in diesem Programm eine grafische Be­nut­zer­ober­flä­che: Den Such­be­griff müssen Sie direkt in den Quelltext eintragen und das Ergebnis erhalten Sie nur über die Konsole.

Bild: Quellcode in Eclipse und Ergebnis einer Lucene-Suchanfrage in der Konsole
Eclipse stellt das Ergebnis Ihrer Suche in der Konsole dar.

Lucene Query Syntax

Such­ma­schi­nen – auch die, die Sie aus dem Web kennen – lassen meist nicht nur die Suche nach einem einzelnen Begriff zu. Mit be­stimm­ten Methoden können Sie Begriffe an­ein­an­der­rei­hen, nach Phrasen suchen oder einzelne Wörter aus­schlie­ßen. Selbst­ver­ständ­lich bietet auch Apache Lucene diese Mög­lich­kei­ten: Mit der Lucene Query Syntax suchen Sie nach komplexen Aus­drü­cken – auch in mehreren Feldern.

  • Single Term: Einen einfachen Begriff geben Sie so ein, wie dieser lautet. Anders als Google und Co. geht Lucene davon aus, dass Sie wissen, wie der Begriff ge­schrie­ben wird. Sollten Sie einen Schreib­feh­ler einbauen, erhalten Sie auch ein negatives Ergebnis. Beispiel: Auto
     
  • Phrase: Als Phrasen gelten fest­ge­leg­te Wort­fol­gen. Dabei sind nicht nur die einzelnen Begriffe innerhalb der Phrase ent­schei­dend, sondern auch die Rei­hen­fol­ge, in der diese stehen. Beispiel: "Mein Auto ist rot"
     
  • Wildcard Searches: Mit Platz­hal­tern ersetzen Sie einen oder mehrere Zeichen in Ihrer Such­an­fra­ge. Wildcards lassen sich sowohl am Ende als auch in der Mitte eines Begriffs einsetzen, al­ler­dings nicht am Anfang.
     
    • ?: Das Fra­ge­zei­chen steht genau für ein Zeichen. Beispiel: Au?o
       
    • *: Das Sternchen ersetzt gar keinen oder unendlich viele Zeichen. So lassen sich z. B. auch andere Formen eines Begriffs suchen, etwa der Plural. Beispiel: Auto*
       
  • Regular Ex­pres­si­on Searches: Mit regulären Aus­drü­cken suchen Sie nach mehreren Begriffen gleich­zei­tig, die teilweise Ge­mein­sam­kei­ten haben und teilweise von­ein­an­der abweichen. Im Gegensatz zu Wildcards de­fi­nie­ren Sie genau, welche Ab­wei­chun­gen be­rück­sich­tigt werden sollen. Dafür nutzen Sie Schräg­stri­che und eckige Klammern. Beispiel: /[MS]ein/
     
  • Fuzzy Searches: Eine unscharfe Suche führen Sie dann durch, wenn Sie bei­spiels­wei­se eine Feh­ler­to­le­ranz haben möchten. Mithilfe der Damerau-Le­vensht­ein-Distanz (eine Formel, die Ähn­lich­kei­ten bewertet), stellen Sie ein, wie groß die Ab­wei­chung sein darf. Hierfür nutzen Sie die Tilde. Distanzen von 0 bis 2 sind zu­ge­las­sen. Beispiel: Auto~1
     
  • Proximity Searches: Auch wenn Sie eine Näherung bei Phrasen zulassen möchten, nutzen Sie die Tilde. So können Sie bei­spiels­wei­se angeben, dass Sie zwei Begriffe auch dann suchen, wenn zwischen diesen 5 andere Wörter vorkommen. Beispiel: "Auto rot"~5
     
  • Range Searches: Bei dieser Form der Anfrage suchen Sie in einem be­stimm­ten Bereich zwischen zwei Begriffen. Während eine solche Suche für den ge­ne­rel­len Inhalt eines Dokuments wenig sinnvoll ist, kann sie sehr nützlich im Umgang mit be­stimm­ten Feldern wie Autoren oder Titeln sein. Die Sor­tie­rung funk­tio­niert nach einer le­xi­ko­gra­fi­schen Ordnung. Während Sie einen in­klu­si­ven Bereich mit eckigen Klammern ver­deut­li­chen, schließen Sie mit ge­schweif­ten Klammern den durch die beiden Such­be­grif­fe be­stimm­ten Bereich aus der Anfrage aus. Die beiden Begriffe grenzen Sie mit TO ab. Beispiel: [Allende TO Borges] bzw. {Byron TO Shelley}
     
  • Boosting: Lucene gibt Ihnen die Mög­lich­keit, einzelnen Begriffen oder Phrasen mehr Relevanz bei der Suche zu geben als anderen. Damit be­ein­flus­sen Sie die Sor­tie­rung der Er­geb­nis­se. Den Boosting-Faktor legen Sie mit dem Zir­kum­flex gefolgt von einem Wert fest. Beispiel: Auto^2 rot
     
  • Boolean Operators: Mit logischen Ope­ra­to­ren stellen Sie Ver­bin­dun­gen zwischen Begriffen innerhalb einer Such­an­fra­ge her. Die Ope­ra­to­ren müssen immer in Groß­buch­sta­ben ge­schrie­ben werden, damit Lucene diese nicht als normale Such­be­grif­fe wertet.
     
    • AND: Bei einer Und-Ver­knüp­fung müssen zwingend beide Begriffe im Dokument vorkommen, damit dieses als Ergebnis auftaucht. Statt dem Ausdruck können Sie auch zwei auf­ein­an­der­fol­gen­de kauf­män­ni­sche Und-Zeichen verwenden. Beispiel: Auto && rot
       
    • OR: Die Oder-Ver­knüp­fung ist der Stan­dard­fall, wenn Sie einfach zwei Begriffe nach­ein­an­der einfügen. Einer der beiden Begriffe muss zwingend vorkommen, es können aber auch beide gemeinsam im Dokument enthalten sein. Sie erstellen die Oder-Ver­knüp­fung mit OR, || oder indem Sie gar keinen Operator eingeben. Beispiel: Auto rot
       
    • +: Mit dem Plus-Zeichen bauen Sie einen be­stimm­ten Fall der Oder-Ver­knüp­fung auf. Setzen Sie das Zeichen direkt vor ein Wort, muss dieser Begriff vorkommen, während der andere optional ist. Beispiel: +Auto rot
       
    • NOT: Die Nicht-Ver­knüp­fung schließt bestimmte Begriffe oder Phrasen aus der Suche aus. Sie können den Operator durch ein Aus­ru­fe­zei­chen ersetzen oder ein Minus direkt vor den aus­zu­schlie­ßen­den Begriff setzen. Den NOT-Operator dürfen Sie nicht mit nur einem einzigen Begriff bzw. nur einer Phrase verwenden. Beispiel: Auto rot -blau
       
  • Grouping: Mit Klammern lassen sich Begriffe innerhalb von Such­an­fra­gen grup­pie­ren. So erstellen Sie kom­ple­xe­re Eingaben, mit denen Sie z. B. einen Begriff zwingend mit einem von zwei Begriffen koppeln: Auto UND (rot ODER blau)
     
  • Escaping Special Cha­rac­ters: Um Zeichen, die für die Lucene Query Syntax ver­wend­bar sind, in Such­be­grif­fen zu nutzen, kom­bi­nie­ren Sie diese mit einem Backslash. So bauen Sie etwa ein Fra­ge­zei­chen in eine Such­an­fra­ge ein, ohne dass der Parser dieses als Wildcard in­ter­pre­tiert: "Wo ist mein Auto\?"

Apache Lucene: Vor- und Nachteile

Lucene ist ein mächtiges Werkzeug, um im Web, in Archiven oder in An­wen­dun­gen eine Such­funk­ti­on zu eta­blie­ren. Fans von Lucene genießen es, durch die In­de­xie­rung eine sehr schnelle Such­ma­schi­ne bauen zu können, die zudem sehr de­tail­liert an die eigenen An­for­de­run­gen angepasst werden kann. Da es sich um ein Open-Source-Projekt handelt, ist Lucene nicht nur kostenlos verfügbar, sondern wird auch von einer großen Community stetig wei­ter­ent­wi­ckelt.

So kann man es außer in Java in­zwi­schen auch in PHP, Python und anderen Pro­gram­mier­spra­chen verwenden. Und damit kommt man auch zum ei­gent­lich einzigen Nachteil: Pro­gram­mier­kennt­nis­se sind definitiv nötig. Die Voll­text­su­che ist somit nicht für jeden das Richtige. Wer nur eine Such­funk­ti­on für seine Website braucht, ist bei anderen Angeboten si­cher­lich besser auf­ge­ho­ben.

Vorteile Nachteile
Verfügbar für ver­schie­de­ne Pro­gram­mier­spra­chen Benötigt Pro­gram­mier­kennt­nis­se
Open Source  
Schnell und schlank  
Ranked Searching  
Komplexe Such­an­fra­gen möglich  
Sehr flexibel  
Zum Hauptmenü