स्टेमिंग विश्लेषक

Question

के साथ ल्यूसीन हाइलाइटर मैं मिलान किए गए खोज परिणामों के टुकड़ों को हाइलाइट करने के लिए लुसीन हाइलाइटर क्लास का उपयोग कर रहा हूं और यह अच्छी तरह से काम करता है। मैं मानक विश्लेषक के साथ अंग्रेजी विश्लेषक के साथ खोज करने से स्विच करना चाहता हूं, जो शर्तों के दायरे में प्रदर्शन करेगा।

खोज परिणाम अच्छे हैं, लेकिन अब हाइलाइटर हमेशा एक मैच नहीं ढूंढता है। यहाँ है कि मैं क्या कर रहा हूँ पर देख रहे हैं का एक उदाहरण है:

document field text 1: Everyone likes goats. 

document field text 2: I have a goat that eats everything. 

EnglishAnalyzer का उपयोग करना और "बकरी" के लिए खोज, दोनों दस्तावेजों मिलान किया जाता है, लेकिन हाइलाइटर केवल एक मिलान टुकड़ा खोजने के लिए से दस्तावेज़ 2. है में सक्षम है वहाँ दोनों दस्तावेजों के लिए हाइलाइटर रिटर्न डेटा रखने का एक तरीका?

मैं समझता हूं कि टोकन टोकन के लिए अलग हैं, लेकिन वही टोकन अभी भी वहां हैं, इसलिए ऐसा लगता है कि उस स्थान पर जो भी टोकन मौजूद है, उसे हाइलाइट करना उचित लगता है।

यदि यह मदद करता है, तो यह लुसीन 3.5 का उपयोग कर रहा है।

Answer 1

मुझे इस समस्या का समाधान मिला। FastVectorHighlighter का उपयोग करने के लिए मैंने Highlighter कक्षा का उपयोग करने से बदल दिया। ऐसा लगता है कि मैं कुछ गति सुधार भी लेगा (शब्द वेक्टर डेटा के भंडारण की कीमत पर)। बाद में इस प्रश्न में आने वाले किसी के लाभ के लिए, यहां एक यूनिट परीक्षण दिखाया गया है कि यह सब कैसे काम करता है:

package com.sample.index; 

import org.apache.lucene.analysis.Analyzer; 
import org.apache.lucene.analysis.en.EnglishAnalyzer; 
import org.apache.lucene.document.Document; 
import org.apache.lucene.document.Field; 
import org.apache.lucene.index.IndexReader; 
import org.apache.lucene.index.IndexWriter; 
import org.apache.lucene.index.IndexWriterConfig; 
import org.apache.lucene.queryParser.ParseException; 
import org.apache.lucene.queryParser.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.search.vectorhighlight.*; 
import org.apache.lucene.store.RAMDirectory; 
import org.apache.lucene.util.Version; 
import org.junit.Before; 
import org.junit.Test; 

import java.io.IOException; 
import java.util.ArrayList; 
import java.util.List; 

import static junit.framework.Assert.assertEquals; 

public class TestIndexStuff { 
    public static final String FIELD_NORMAL = "normal"; 
    public static final String[] PRE_TAGS = new String[]{"["}; 
    public static final String[] POST_TAGS = new String[]{"]"}; 
    private IndexSearcher searcher; 
    private Analyzer analyzer = new EnglishAnalyzer(Version.LUCENE_35); 

    @Before 
    public void init() throws IOException { 
     RAMDirectory idx = new RAMDirectory(); 
     IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_35, analyzer); 

     IndexWriter writer = new IndexWriter(idx, config); 
     addDocs(writer); 
     writer.close(); 

     searcher = new IndexSearcher(IndexReader.open(idx)); 
    } 

    private void addDocs(IndexWriter writer) throws IOException { 
     for (String text : new String[] { 
       "Pretty much everyone likes goats.", 
       "I have a goat that eats everything.", 
       "goats goats goats goats goats"}) { 
      Document doc = new Document(); 
      doc.add(new Field(FIELD_NORMAL, text, Field.Store.YES, 
        Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS)); 
      writer.addDocument(doc); 
     } 
    } 

    private FastVectorHighlighter makeHighlighter() { 
     FragListBuilder fragListBuilder = new SimpleFragListBuilder(200); 
     FragmentsBuilder fragmentBuilder = new SimpleFragmentsBuilder(PRE_TAGS, POST_TAGS); 
     return new FastVectorHighlighter(true, true, fragListBuilder, fragmentBuilder); 
    } 

    @Test 
    public void highlight() throws ParseException, IOException { 
     Query query = new QueryParser(Version.LUCENE_35, FIELD_NORMAL, analyzer) 
        .parse("goat"); 
     FastVectorHighlighter highlighter = makeHighlighter(); 
     FieldQuery fieldQuery = highlighter.getFieldQuery(query); 

     TopDocs topDocs = searcher.search(query, 10); 
     List<String> fragments = new ArrayList<String>(); 
     for (ScoreDoc scoreDoc : topDocs.scoreDocs) { 
      fragments.add(highlighter.getBestFragment(fieldQuery, searcher.getIndexReader(), 
        scoreDoc.doc, FIELD_NORMAL, 10000)); 
     } 

     assertEquals(3, fragments.size()); 
     assertEquals("[goats] [goats] [goats] [goats] [goats]", fragments.get(0).trim()); 
     assertEquals("Pretty much everyone likes [goats].", fragments.get(1).trim()); 
     assertEquals("I have a [goat] that eats everything.", fragments.get(2).trim()); 
    } 
}