Apache Lucene: Wie TokenStream verwendet wird, um ein Token beim Indizieren manuell zu akzeptieren oder abzulehnen

Question

Ich bin auf der Suche nach einer Möglichkeit, einen benutzerdefinierten Index mit Apache Lucene zu schreiben (PyLucene, um genau zu sein, aber eine Java-Antwort ist in Ordnung).

Was ich tun möchte, ist Folgendes: Wenn Sie ein Dokument zum Index hinzufügen, wird es von Lucene in Tokens umgewandelt, Stoppwörter entfernt. Dies geschieht normalerweise mit der Analyzer, wenn ich mich nicht irre.

Was ich gerne implementieren würde, ist das Folgende: Bevor Lucene einen bestimmten Begriff speichert, möchte ich eine Suche durchführen (zB in einem Wörterbuch) um zu überprüfen, ob der Begriff beibehalten oder verwerfen wird (wenn der Begriff ist in meinem Wörterbuch, ich behalte es, sonst verwerfe ich es).

Wie soll ich fortfahren?

ist hier (in Python) meine benutzerdefinierten Implementierung der Analyzer:

class CustomAnalyzer(PythonAnalyzer): 

    def createComponents(self, fieldName, reader): 

     source = StandardTokenizer(Version.LUCENE_4_10_1, reader) 
     filter = StandardFilter(Version.LUCENE_4_10_1, source) 
     filter = LowerCaseFilter(Version.LUCENE_4_10_1, filter) 
     filter = StopFilter(Version.LUCENE_4_10_1, filter, 
          StopAnalyzer.ENGLISH_STOP_WORDS_SET) 

     ts = tokenStream.getTokenStream() 
     token = ts.addAttribute(CharTermAttribute.class_) 
     offset = ts.addAttribute(OffsetAttribute.class_) 

     ts.reset() 

     while ts.incrementToken(): 
      startOffset = offset.startOffset() 
      endOffset = offset.endOffset() 
      term = token.toString() 
      # accept or reject term 

     ts.end() 
     ts.close() 

      # How to store the terms in the index now ? 

     return ???? 

im Voraus Vielen Dank für Ihre Unterstützung!

EDIT 1: Nachdem ich in Lucenes Dokumentation gegraben hatte, dachte ich, es hätte etwas mit der TokenStreamComponents zu tun. Sie gibt einen TokenStream zurück, mit dem Sie die Token-Liste des zu indexierenden Felds durchlaufen können.

Jetzt gibt es etwas mit der Attributes zu tun, die ich nicht verstehe. Genauer gesagt kann ich die Token lesen, habe aber keine Ahnung, wie ich danach weitermachen soll.

EDIT 2: Ich fand diese post wo sie die Verwendung von CharTermAttribute erwähnen. Jedoch (in Python obwohl) kann ich nicht auf CharTermAttribute zugreifen oder erhalten. Irgendwelche Gedanken?

EDIT3: Ich kann jetzt auf jeden Begriff zugreifen, siehe Update-Code-Snippet. Nun, was zu tun ist, ist eigentlich Speicherung der gewünschten Begriffe ...

Answer 1

Die Art, wie ich versuchte, das Problem zu lösen, war falsch. Diese post und femtoRgon Antwort war die Lösung.

Indem ich einen Filter definiere, der sich auf PythonFilteringTokenFilter erstreckt, kann ich die Funktion accept() verwenden (wie sie zum Beispiel im StopFilter verwendet wird).

Hier ist das entsprechende Codefragment:

class MyFilter(PythonFilteringTokenFilter): 

    def __init__(self, version, tokenStream): 
    super(MyFilter, self).__init__(version, tokenStream) 
    self.termAtt = self.addAttribute(CharTermAttribute.class_) 


    def accept(self): 
    term = self.termAtt.toString() 
    accepted = False 
    # Do whatever is needed with the term 
    # accepted = ... (True/False) 
    return accepted 

Dann append nur die Filter zu den anderen Filter (wie in dem Code der Frage snipped):

filter = MyFilter(Version.LUCENE_4_10_1, filter)