Lucene的多域查詢、結果中查詢、查詢結果分頁、高亮查詢結果和結果評分

1.針對多個域的一次性查詢

1.1.三種方案    

    使用lucene構造搜索引擎的時候，如果要針對多個域進行一次性查詢，一般來說有三種方法：

    第一種實現方法是創建多值的全包含域的文本進行索引，這個方案最簡單。但是這個防范有個缺點：你不能直接對每個域的加權進行控制。

    第二種方法是使用MultiFieldQueryParser，它是QueryParser的子類，它會在后台程序中實例化一個QueryParser對象，用來針對每個域進行查詢表達式的解析，然后使用BooleanQuery將查詢結果合並起來。當程序向BooleanQuery添加查詢子句時，默認操作符OR被用於最簡單的解析方法中。為了實現更好的控制，布爾操作符可以使用BooleanClause的常量指定給每個域。如果需要指定的話可以使用BooleanClause.Occur.MUST，如果禁止指定可以使用BooleanClause.Occur.MUST_NOT，或者普通情況為BooleanClause.Occur.SHOULD。下面的程序展示的是如何創建MultiFieldQueryParser類的方法：

// 在這四個域中檢索
String[] fields = { "phoneType", "name", "category", "price" };
Query query = new MultiFieldQueryParser(Version.LUCENE_36, fields, analyzer).parse(keyword);

    第三種方法就是使用高級DisjunctionMaxQuery類，它會封裝一個或者多個任意的查詢，將匹配的文檔進行OR操作。

1.2.方案選擇

    以上三種方案中，並不是第三種方案最好，也不是第一種方案就最差。哪種實現方式更適合你的應用程序呢？答案是“看情況”，因為這里存在一些取舍。全包含域是一個簡單的解決方案——但這個方案只能對搜索結果進行簡單的排序並且可能浪費磁盤空間（程序可能對同樣的文本索引兩次），但這個方案可能會獲得最好的搜索性能。

    MultiFieldQueryParser生成的BooleanQuery會計算所有查詢所匹配的文檔評分的總和（DisjunctionMaxQuery則只選取最大評分），然后它能夠實現針對每個域的加權。你必須對以上3中解決方案都進行測試，同時需要一起考慮搜索性能和搜索相關性，然后再找出最佳方案。

 

2.在結果中查詢

2.1.兩種方案

    在檢索結果中再次進行檢索，是一個很常見的需求，一般有兩種方案可以選擇：

    ①使用QueryFilter把第一個查詢當作一個過濾器處理；

    ②用BooleanQuery把前后兩個查詢結合起來，並且使用BooleanClause.Occur.MUST。

    針對第一種方法，我需要解釋一下。QueryFilter在Lucene的2.x版本中是存在的，但是在3.x中，lucene的API中這個類已經被廢棄了，無法再找到。如果你的項目使用的是lucene是3.x，但是你又一定要使用QueryFilter，那么你必須自己創建一個QueryFilter類，然后將2.x中QueryFilter的源代碼復制過來。你可能會說，直接在工程中同時使用lucene2.x和3.x的核心jar文件不就行了嗎。但遺憾的是，一個工程下，是不能同時使用不同版本的lucene的。

2.2.QueryFilter方案

上文已經說了，如果一定要使用QueryFilter，由於lucene2.x中沒有QueryFilter的API，所以自己要寫一個QueryFilter，QueryFilter的源代碼在lucene2.x中是這樣的：

import org.apache.lucene.search.CachingWrapperFilter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.QueryWrapperFilter;

public class QueryFilter extends CachingWrapperFilter {

    /**
     * Constructs a filter which only matches documents matching
     * <code>query</code>.
     */
    public QueryFilter(Query query) {
        super(new QueryWrapperFilter(query));
    }

    public boolean equals(Object o) {
        return super.equals((QueryFilter) o);
    }

    public int hashCode() {
        return super.hashCode() ^ 0x923F64B9;
    }
}

第一種方案的例子程序如下：

//簡單實現對keyword的搜索
 public static void search(String keyword) throws IOException, ParseException {
         QueryParser queryParser = new QueryParser("content",new SimpleAnalyzer());
         Query query = queryParser.parse(keyword.trim());
         QueryFilter filter = new QueryFilter(query);
         //檢索
         search(query, filter);
 }

 //在搜索oldKeyword的結果集中搜索newKeyword
 public static void searchInResult(String newKeyword, String oldKeyword) throws ParseException, IOException {
         QueryParser queryParser = new QueryParser("content",new SimpleAnalyzer());
         Query query = queryParser.parse(newKeyword.trim());
         Query oldQuery = queryParser.parse(oldKeyword.trim());
         QueryFilter oldFilter = new QueryFilter(oldQuery);
         CachingWrapperFilter filter = new CachingWrapperFilter(oldFilter);
         //檢索
         search(query, filter);
 }

 private static void search(Query query, Filter filter) throws IOException, ParseException {
         IndexSearcher ins = new IndexSearcher("d:/tesindex");
         Hits hits = ins.search(query, filter);
         for (int i = 0; i < hits.length(); i++) {
                 Document doc = hits.doc(i);
                 System.out.println(doc.get("content"));
         }
 }

2.3.BooleanQuery方案

    使用BooleanQuery來實現在結果中檢索的過程是這樣的，首先通過關鍵字keyword1正常檢索，當用戶需要在檢索結果中再通過關鍵字keyword2檢索的時候，通過構建BooleanQuery，來實現對在結果中檢索的效果。這里要注意，這兩個關鍵字都要使用BooleanClause.Occur.MUST。

//創建BooleanQuery
BooleanQuery booleanQuery = new BooleanQuery();
//多域檢索，在這四個域中檢索
String[] fields = { "phoneType", "name", "category","free" };
Query multiFieldQuery = new MultiFieldQueryParser(Version.LUCENE_36, fields, analyzer).parse(keyword);
//將multiFieldQuery添加到BooleanQuery中
booleanQuery.add(multiFieldQuery, BooleanClause.Occur.MUST);
//如果osKeyword不為空
if(osKeyword != null && !osKeyword.equals("") && !osKeyword.equals("null")){
    TermQuery osQuery = new TermQuery(new Term("phoneType",osKeyword));
    //將osQuery添加到BooleanQuery中
    booleanQuery.add(osQuery, BooleanClause.Occur.MUST);
}

3.檢索結果分頁

3.1.兩種方案

    通過關鍵字的檢索，當lucene返回多條記錄的時候，往往一個頁面是無法容納所有檢索結果的，這自然而然就該分頁了。我這里給出兩種方案，這兩種方法我都是用過。

    第一種方法，就是講檢索結果全部封裝在一個Collection中，例如List中，將這個結果傳到前台，如jsp頁面。然后在這個list中進行分頁顯示；

    第二種方法，是使用lucene自帶的分頁工具public TopDocs topDocs(int start,int howMany)。

    我認為，第一種方法不涉及二次查詢，這樣的話就避免了在查詢上的浪費。但是當檢索的結果數據量很大，這樣一次性傳輸這么多數據到客戶端，而用戶檢索后得到的結果往往只會查看第一頁的內容，很少去查看第二頁、第三頁以及后面的內容，所以一次性將全部結果傳到前台，這樣的浪費是很大的。

    第二種方法，雖然每次翻頁都意味着一次查詢，表面上浪費了資源，但是由於lucene的高效，這樣的浪費對整個系統的影響是微乎其微的，但是這個方法避免了方法一中的缺陷。

3.2.分頁實現

/**
     * 對搜索返回的前n條結果進行分頁顯示
     * @param keyWord       查詢關鍵詞
     * @param pageSize      每頁顯示記錄數
     * @param currentPage   當前頁
     */
    public void paginationQuery(String keyWord,int pageSize,int currentPage) throws ParseException, CorruptIndexException, IOException {
        String[] fields = {"title","content"};
        QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_36,fields,analyzer);
        Query query = queryParser.parse(keyWord);

        IndexReader indexReader  = IndexReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        //TopDocs 搜索返回的結果
        TopDocs topDocs = indexSearcher.search(query, 100);//只返回前100條記錄
        int totalCount = topDocs.totalHits; // 搜索結果總數量
        ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 搜索返回的結果集合

        //查詢起始記錄位置
        int begin = pageSize * (currentPage - 1) ;
        //查詢終止記錄位置
        int end = Math.min(begin + pageSize, scoreDocs.length);

        //進行分頁查詢
        for(int i=begin;i<end;i++) {
            int docID = scoreDocs[i].doc;
            Document doc = indexSearcher.doc(docID);
            int id = NumericUtils.prefixCodedToInt(doc.get("id"));
            String title = doc.get("title");
            System.out.println("id is : "+id);
            System.out.println("title is : "+title);
        }
    }

4.高亮檢索結果

    針對檢索結果的高亮實現方法，在lucene中提供了響應的工具，這里使用lucene-highlighter-3.6.2.jar來實現對檢索結果的高亮顯示。

public void search(String fieldName, String keyword)throws CorruptIndexException, IOException, ParseException {
    searcher = new IndexSearcher(indexPath);
    QueryParser queryParse = new QueryParser(fieldName, analyzer); // 構造QueryParser，解析用戶輸入的檢索關鍵字
    Query query = queryParse.parse(keyword);
    Hits hits = searcher.search(query);
    for (int i = 0; i < hits.length(); i++) {
        Document doc = hits.doc(i);
        String text = doc.get(fieldName);
        SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<font color='red'>", "</font>");
        Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));
        highlighter.setTextFragmenter(new SimpleFragmenter(text.length()));
        if (text != null) {
            TokenStream tokenStream = analyzer.tokenStream(fieldName,new StringReader(text));
            String highLightText = highlighter.getBestFragment(tokenStream,text);
            System.out.println("高亮顯示第 " + (i + 1) + " 條檢索結果如下所示：");
            System.out.println(highLightText);
        }
    }
    searcher.close();
}

上文的一行判斷語句很重要：if(text != null)，如果text為空，那么顯示結果不但沒有被高亮，而且得到的原始結果也會被過濾。可以再代碼中加上，如果text==null，則讓將原始檢索結果賦給text，從而將結果顯示出來。

 

5.檢索結果的評分

    lucene的評分是有一套自己的機制的，輸入某一個關鍵字，lucene會對命中的記錄進行評分，默認情況下，分數越高的結果會排在結果的越前面。如果在創建索引的時候，沒有對某個域進行加權，那么默認分數的上限是5分，如果有對域做加權，檢索結果的評分可能會出現大於5分的情況。

    我們可以使用explain()來看看lucene對檢索結果的評分情況：

//評分
Explanation explanation = indexSearcher.explain(query, docID);
System.out.println(explanation.toString());

在后台打印出來的信息如下：

2.4342022 = (MATCH) weight(name:books in 71491), product of:
       0.2964393 = queryWeight(name:books), product of:
         8.21147 = idf(docFreq=109, maxDocs=149037)
         0.036100637 = queryNorm