Lucene-2.2.0 源代码阅读学习(41)

当执行Hits htis = search(query);这一行代码的时候，到底中间经过了怎样的过程，最终使得我们获取到了含有检索结果的集合Hits hits呢？

这里，以最简单的检索为例，追踪并理解Lucene(2.2.0版本)获取到检索结果的过程。

1、IndexSearcher继承自Searcher类的最简单的search方法，如下所示：

public final Hits search(Query query) throws IOException {
    return search(query, (Filter)null);
}

这里，调用了Searcher类的带有两个参数的search方法，返回Hits，如下所示：

public Hits search(Query query, Filter filter) throws IOException {
    return new Hits(this, query, filter);
}

这时，是通过根据传递进来的Query、Filter(简单地考虑，Filter=null)和实例化的Searcher来构造一个Hits的，其实，没有那么简单，想也能想得到，一定是在Hits类中，通过Searcher实例进行了具体的检索过程。

Hits类拥有如下成员：

private Weight weight;
private Searcher searcher;
private Filter filter = null;
private Sort sort = null;

private int length;      // 检索到的匹配的Document的个数
private Vector hitDocs = new Vector();   // 最终将检索命中的Document(封装到Hit中，包含了一个Document的丰富信息)放到hitDocs中，取出来呈现给检索的用户

private HitDoc first;         // head of LRU cache
private HitDoc last;          // tail of LRU cache
private int numDocs = 0;      // number cached
private int maxDocs = 200;    // max to cache

2、在Hits类中，只有构造好了含有检索结果的Hits才是最终的检索目标，如下所示：

Hits(Searcher s, Query q, Filter f) throws IOException {
    weight = q.weight(s);
    searcher = s;
    filter = f;
    getMoreDocs(50); // 缓存检索结果50*2=100个
}

因为一个Query实例需要被多次使用，故而使用Weight来记录Query的状态。重点看在Hits类调用getMoreDocs方法，该方法实现如下：

private final void getMoreDocs(int min) throws IOException {
    if (hitDocs.size() > min) {    // hitDocs.size() <min=50，说明缓存的结果数量小于预计要加入到缓存中的结果的数量，因此不执行该if分支，无需改变min(缓存容量)的大小
      min = hitDocs.size();
    }

    int n = min * 2; // 由50变成100，目的是：直接扩充缓存为原来的2倍，缓存双倍的检索结果以备用户直接从缓存中提取检索结果；间接地一次性为HitQueue(优先级队列)分配大小，防止频繁分配增加系统开销
    TopDocs topDocs = (sort == null) ? searcher.search(weight, filter, n) : searcher.search(weight, filter, n, sort);
    length = topDocs.totalHits;
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;

    float scoreNorm = 1.0f;
   
    if (length > 0 && topDocs.getMaxScore() > 1.0f) {
      scoreNorm = 1.0f / topDocs.getMaxScore();
    }

    int end = scoreDocs.length < length ? scoreDocs.length : length;
    for (int i = hitDocs.size(); i < end; i++) {
      hitDocs.addElement(new HitDoc(scoreDocs[i].score * scoreNorm,
                                    scoreDocs[i].doc));
    }
}

第一次调用该方法的时候，作为Hits类的一个成员private Vector hitDocs = new Vector();，它是用作缓存检索结果的。

当sort == null)的时候，执行searcher.search(weight, filter, n)，这时，又回到了IndexSearcher类中，执行含有三个参数的重载search方法(见下文)，返回检索结果存放于TopDocs topDocs中。关于TopDocs有必要熟悉一下：

public class TopDocs implements java.io.Serializable {
public int totalHits;
public ScoreDoc[] scoreDocs;
private float maxScore;
public float getMaxScore() {
      return maxScore;
}
public void setMaxScore(float maxScore) {
      this.maxScore=maxScore;
}
TopDocs(int totalHits, ScoreDoc[] scoreDocs, float maxScore) {
    this.totalHits = totalHits;
    this.scoreDocs = scoreDocs;
    this.maxScore = maxScore;
}
}

totalHits成员是本次查询Query检索到的Hits的总数；maxScore成员是最大分数。

ScoreDoc[]成员就是从所有满足查询Query的得分不为0的Document的数组，根据要求选择前n个Docunent返回，它包含Document的编号和得分这两个成员：

package org.apache.lucene.search;
public class ScoreDoc implements java.io.Serializable {
public float score;
public int doc;
public ScoreDoc(int doc, float score) {
    this.doc = doc;
    this.score = score;
}
}

接着，根据返回的TopDocs topDocs取得其长度length = topDocs.totalHits;用来计算得分标准化因子，以对检索结果按照得分进行排序，并把相关的检索结果缓存到hitDocs中。

3、在IndexSearcher类中，根据searcher.search(weight, filter, n)，执行public TopDocs search(Weight weight, Filter filter, final int nDocs)方法，如下所示：

public TopDocs search(Weight weight, Filter filter, final int nDocs)
       throws IOException {

    if (nDocs <= 0) // nDocs=n=2*50=100
      throw new IllegalArgumentException("nDocs must be > 0");

    TopDocCollector collector = new TopDocCollector(nDocs);
    search(weight, filter, collector);
    return collector.topDocs();
}

上面，构造了一个TopDocCollector实例，使用如下构造方法：

public TopDocCollector(int numHits) {
    this(numHits, new HitQueue(numHits));
}

调用重载的构造方法TopDocCollector(int numHits, PriorityQueue hq)，初始化一个Hit的优先级队列，大小为100。其实，关于Hit的优先级队列就是这样的：对于ScoreDoc hitA和ScoreDoc hitB，如果hitA.score>=hitB.score，则选择hitA入队列。

根据构造的TopDocCollector collector，再次调用IndexSearcher类的另一个不同的重载的search方法search(weight, filter, collector);，将检索结果存放到了TopDocCollector collector中，最后根据TopDocCollector collector返回TopDocs。

关于search(weight, filter, collector);调用，实现如下所示：

public void search(Weight weight, Filter filter,
                     final HitCollector results) throws IOException {
    HitCollector collector = results;
    if (filter != null) {    // 我们一直设定Filter=null，该分支不执行
      final BitSet bits = filter.bits(reader);
      collector = new HitCollector() {
          public final void collect(int doc, float score) {
            if (bits.get(doc)) {                  // skip docs not in bits
              results.collect(doc, score);
            }
          }
        };
    }

    Scorer scorer = weight.scorer(reader);
    if (scorer == null)
      return;
    scorer.score(collector);
}

先看Scorer scorer，通过weight的scorer方法获取到一个Scorer，在内部类org.apache.lucene.search.TermQuery.TermWeight中可以看到TermWeight的score方法如何实现的：

    public Scorer scorer(IndexReader reader) throws IOException {
      TermDocs termDocs = reader.termDocs(term);

      if (termDocs == null)
        return null;

      return new TermScorer(this, termDocs, similarity,reader.norms(term.field()));
    }

通过IndexReader reader获取到一个TermDocs，其中TermDocs是与检索相关的(即查询中使用Term构造了查询)包含Term的所有<document, frequency>对，document为Document的编号，frequency为Term在该Document中出现的频率(次数)。

执行reader.termDocs(term);时，调用了IndexReader类的termDocs方法，如下所示：

public TermDocs termDocs(Term term) throws IOException {
    ensureOpen();
    TermDocs termDocs = termDocs();
    termDocs.seek(term);
    return termDocs;
}

TermScorer是Scorer的子类，它有如下一些成员：

private Weight weight;
private TermDocs termDocs;
private byte[] norms;
private float weightValue;
private int doc;

private final int[] docs = new int[32];         // buffered doc numbers
private final int[] freqs = new int[32];        // buffered term freqs
private int pointer;
private int pointerMax;

private static final int SCORE_CACHE_SIZE = 32;
private float[] scoreCache = new float[SCORE_CACHE_SIZE];

通过这些成员，我们能够知道返回一个TermScorer对象都包含哪些内容，从而为使用Scorer scorer = weight.scorer(reader);便于理解。

weight.scorer(reader) 返回的是一个Scorer，它是用来迭代得分与查询匹配的Docuemnt的。

最后，执行scorer.score(collector);，最终的检索结果可以直接从一个HitCollector collector中提取出来，返回最终的检索结果。

Scorer类的score方法如下：

public void score(HitCollector hc) throws IOException {
    while (next()) {
      hc.collect(doc(), score());
    }
}

再看TopDocCollector(extends HitCollector)类的collect方法的实现：

public void collect(int doc, float score) {
    if (score > 0.0f) {
      totalHits++;
      if (hq.size() < numHits || score >= minScore) {
        hq.insert(new ScoreDoc(doc, score));
        minScore = ((ScoreDoc)hq.top()).score; // maintain minScore
      }
    }
}

根据Document的编号和得分，调整Hit的优先级队列，获得满足条件的Docuemt的集合，最终构造出ScoreDoc，实际上是得到了一个ScoreDoc[]数组，从而访问TopDocs的这个ScoreDoc[]成员，就返回了最终检索的结果集合。