`
xiangxingchina
  • 浏览: 520462 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

lucene FilteredQuery

luceneCache 
阅读更多

FilteredQuery包含两个成员变量：

  • Query query：查询对象
  • Filter filter：其有一个函数DocIdSet getDocIdSet(IndexReader reader) 得到一个文档号集合，结果文档必须出自此文档集合，注此处的过滤器所包含的文档号并不是要过滤掉的文档号，而是过滤后需要的文档号。

FilterQuery所得到的结果集同两者取AND查询相同，只不过打分的时候，FilterQuery只考虑query的部分，不考虑filter的部分。

Filter包含很多种如下：

6.1、TermsFilter

其包含一个成员变量Set<Term> terms=new TreeSet<Term>()，所有包含terms集合中任一term的文档全部属于文档号集合。

其getDocIdSet函数如下：

  public DocIdSet getDocIdSet(IndexReader reader) throws IOException

  {

        //生成一个bitset，大小为索引中文档总数

        OpenBitSet result=new OpenBitSet(reader.maxDoc());

        TermDocs td = reader.termDocs();

        try

        {

            //遍历每个term的文档列表，将文档号都在bitset中置一，从而bitset包含了所有的文档号。

            for (Iterator<Term> iter = terms.iterator(); iter.hasNext();)

            {

                Term term = iter.next();

                td.seek(term);

                while (td.next())

                {

                    result.set(td.doc());

                }

            }

        }

        finally

        {

            td.close();

        }

        return result;

  }

 

6.2、BooleanFilter

其 像BooleanQuery相似，包含should的filter，must的filter，not的filter，在getDocIdSet的时候，先 将所有满足should的文档号集合之间取OR的关系，然后同not的文档号集合取NOT的关系，最后同must的文档号集合取AND的关系，得到最后的 文档集合。

其getDocIdSet函数如下：

public DocIdSet getDocIdSet(IndexReader reader) throws IOException

{

  OpenBitSetDISI res = null;

  if (shouldFilters != null) {

    for (int i = 0; i < shouldFilters.size(); i++) {

      if (res == null) {

        res = new OpenBitSetDISI(getDISI(shouldFilters, i, reader), reader.maxDoc());

      } else {

        //将should的filter的文档号全部取OR至bitset中

        DocIdSet dis = shouldFilters.get(i).getDocIdSet(reader);

        if(dis instanceof OpenBitSet) {

          res.or((OpenBitSet) dis);

        } else {

          res.inPlaceOr(getDISI(shouldFilters, i, reader));

        }

      }

    }

  }

  if (notFilters!=null) {

    for (int i = 0; i < notFilters.size(); i++) {

      if (res == null) {

        res = new OpenBitSetDISI(getDISI(notFilters, i, reader), reader.maxDoc());

        res.flip(0, reader.maxDoc());

      } else {

        //将not的filter的文档号全部取NOT至bitset中

        DocIdSet dis = notFilters.get(i).getDocIdSet(reader);

        if(dis instanceof OpenBitSet) {

          res.andNot((OpenBitSet) dis);

        } else {

          res.inPlaceNot(getDISI(notFilters, i, reader));

        }

      }

    }

  }

  if (mustFilters!=null) {

    for (int i = 0; i < mustFilters.size(); i++) {

      if (res == null) {

        res = new OpenBitSetDISI(getDISI(mustFilters, i, reader), reader.maxDoc());

      } else {

        //将must的filter的文档号全部取AND至bitset中

        DocIdSet dis = mustFilters.get(i).getDocIdSet(reader);

        if(dis instanceof OpenBitSet) {

          res.and((OpenBitSet) dis);

        } else {

          res.inPlaceAnd(getDISI(mustFilters, i, reader));

        }

      }

    }

  }

  if (res !=null)

    return finalResult(res, reader.maxDoc());

  return DocIdSet.EMPTY_DOCIDSET;

}

6.3、DuplicateFilter

DuplicateFilter实现了如下的功能：

比 如说我们有这样一批文档，每篇文档都分成多页，每篇文档都有一个id，然而每一页是按照单独的Document进行索引的，于是进行搜索的时候，当一篇文 档的两页都包含关键词的时候，此文档id在结果集中出现两次，这是我们不想看到的，DuplicateFilter就是指定一个域如id，在此域相同的文 档仅取其中一篇。

DuplicateFilter包含以下成员变量：

  • String fieldName：域的名称
  • int keepMode：KM_USE_FIRST_OCCURRENCE表示重复的文档取第一篇，KM_USE_LAST_OCCURRENCE表示重复的文档取最后一篇。
  • int processingMode：
    • PM_FULL_VALIDATION是首先将bitset中所有文档都设为false，当出现同组重复文章的第一篇的时候，将其设为1
    • PM_FAST_INVALIDATION是首先将bitset中所有文档都设为true，除了同组重复文章的第一篇，其他的的全部设为0
    • 两者在所有的文档都包含指定域的情况下，功能一样，只不过后者不用处理docFreq=1的文档，速度加快。
    • 然而当有的文档不包含指定域的时候，后者由于都设为true，则没有机会将其清零，因而会被允许返回，当然工程中应避免这种情况。

其getDocIdSet函数如下：

  public DocIdSet getDocIdSet(IndexReader reader) throws IOException

    {

        if(processingMode==PM_FAST_INVALIDATION)

        {

            return fastBits(reader);

        }

        else

        {

            return correctBits(reader);

        }

    }

  private OpenBitSet correctBits(IndexReader reader) throws IOException

    {

        OpenBitSet bits=new OpenBitSet(reader.maxDoc());

        Term startTerm=new Term(fieldName);

        TermEnum te = reader.terms(startTerm);

        if(te!=null)

        {

            Term currTerm=te.term();

           //如果属于指定的域

            while((currTerm!=null)&&(currTerm.field()==startTerm.field()))

            {

                int lastDoc=-1;

                //则取出包含此term的所有的文档

                TermDocs td = reader.termDocs(currTerm);

                if(td.next())

                {

                    if(keepMode==KM_USE_FIRST_OCCURRENCE)

                    {

                        //第一篇设为true

                        bits.set(td.doc());

                    }

                    else

                    {

                        do

                        {

                            lastDoc=td.doc();

                        }while(td.next());

                        bits.set(lastDoc); //最后一篇设为true

                    }

                }

                if(!te.next())

                {

                    break;

                }

                currTerm=te.term();

            }

        }

        return bits;

    }

private OpenBitSet fastBits(IndexReader reader) throws IOException

    {

        OpenBitSet bits=new OpenBitSet(reader.maxDoc());

        bits.set(0,reader.maxDoc());  //全部设为true

        Term startTerm=new Term(fieldName);

        TermEnum te = reader.terms(startTerm);

        if(te!=null)

        {

            Term currTerm=te.term();

            //如果属于指定的域

            while((currTerm!=null)&&(currTerm.field()==startTerm.field()))

            {

                if(te.docFreq()>1)

                {

                    int lastDoc=-1;

                    //取出所有的文档

                    TermDocs td = reader.termDocs(currTerm);

                    td.next();

                    if(keepMode==KM_USE_FIRST_OCCURRENCE)

                    {

                        //除了第一篇不清零

                        td.next();

                    }

                    do

                    {

                        lastDoc=td.doc();

                        bits.clear(lastDoc); //其他全部清零

                    }while(td.next());

                    if(keepMode==KM_USE_LAST_OCCURRENCE)

                    {

                        bits.set(lastDoc); //最后一篇设为true

                    }                   

                }

                if(!te.next())

                {

                    break;

                }

                currTerm=te.term();

            }

        }

        return bits;

    }

举例，我们索引如下的文件：

File indexDir = new File("TestDuplicateFilter/index");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc = new Document();
doc.add(new Field("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("contents", "page 1: hello world", Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);

doc = new Document();
doc.add(new Field("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("contents", "page 2: hello world", Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);

doc = new Document();
doc.add(new Field("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("contents", "page 3: hello world", Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);

doc = new Document();
doc.add(new Field("id", "2", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("contents", "page 1: hello world", Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);

doc = new Document();
doc.add(new Field("id", "2", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("contents", "page 2: hello world", Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);
writer.close();

如果搜索TermQuery tq = new TermQuery(new Term("contents","hello"))，则结果为：

id : 1
id : 1
id : 1
id : 2
id : 2

如果按如下进行搜索：

File indexDir = new File("TestDuplicateFilter/index");
IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
TermQuery tq = new TermQuery(new Term("contents","hello"));
DuplicateFilter filter = new DuplicateFilter("id");
FilteredQuery query = new FilteredQuery(tq, filter);
TopDocs docs = searcher.search(query, 50);
for (ScoreDoc doc : docs.scoreDocs) {
  Document ldoc = reader.document(doc.doc);
  String id = ldoc.get("id");
  System.out.println("id : " + id);
}

则结果为：

id : 1
id : 2

 

6.4、FieldCacheRangeFilter<T>及FieldCacheTermsFilter

在介绍与FieldCache相关的Filter之前，先介绍FieldCache。

FieldCache缓存的是不是存储域的内容，而是索引域中term的内容，索引中的term是String的类型，然而可以将其他的类型作为String类型索引进去，例如"1"，"2.3"等，然后搜索的时候将这些信息取出来。

FieldCache支持如下类型：

  • byte[] getBytes (IndexReader reader, String field, ByteParser parser)
  • double[] getDoubles(IndexReader reader, String field, DoubleParser parser)
  • float[] getFloats (IndexReader reader, String field, FloatParser parser)
  • int[] getInts (IndexReader reader, String field, IntParser parser)
  • long[] getLongs(IndexReader reader, String field, LongParser parser)
  • short[] getShorts (IndexReader reader, String field, ShortParser parser)
  • String[] getStrings (IndexReader reader, String field)
  • StringIndex getStringIndex (IndexReader reader, String field)

其中StringIndex包含两个成员：

  • String[] lookup：按照字典顺序排列的所有term。
  • int[] order：其中位置表示文档号，order[i]第i篇文档包含的term在lookup中的位置。

FieldCache默认的实现FieldCacheImpl，其中包含成员变量Map<Class<?>,Cache> caches保存从类型到Cache的映射。

private synchronized void init() {

  caches = new HashMap<Class<?>,Cache>(7);

  caches.put(Byte.TYPE, new ByteCache(this));

  caches.put(Short.TYPE, new ShortCache(this));

  caches.put(Integer.TYPE, new IntCache(this));

  caches.put(Float.TYPE, new FloatCache(this));

  caches.put(Long.TYPE, new LongCache(this));

  caches.put(Double.TYPE, new DoubleCache(this));

  caches.put(String.class, new StringCache(this));

  caches.put(StringIndex.class, new StringIndexCache(this));

}

其实现接口getInts 如下，即先得到Integer类型所对应的IntCache然后，再从其中根据reader和由field和parser组成的Entry得到整型值。

public int[] getInts(IndexReader reader, String field, IntParser parser) throws IOException {

  return (int[]) caches.get(Integer.TYPE).get(reader, new Entry(field, parser));

}

各 类缓存的父类Cache包含成员变量Map<Object, Map<Entry, Object>> readerCache，其中key是IndexReader，value是一个Map，此Map的key是Entry，也即是field，value是 缓存的int[]的值。(也即在这个reader的这个field中有一个数组的int，每一项代表一篇文档)。

Cache的get函数如下：

public Object get(IndexReader reader, Entry key) throws IOException {

  Map<Entry,Object> innerCache;

  Object value;

  final Object readerKey = reader.getFieldCacheKey(); //此函数返回this，也即IndexReader本身

  synchronized (readerCache) {

    innerCache = readerCache.get(readerKey); //通过IndexReader得到Map

    if (innerCache == null) { //如果没有则新建一个Map

      innerCache = new HashMap<Entry,Object>();

      readerCache.put(readerKey, innerCache);

      value = null;

    } else {

      value = innerCache.get(key); //此Map的key是Entry，value即是缓存的值

    }

    //如果缓存不命中，则创建此值

    if (value == null) {

      value = new CreationPlaceholder();

      innerCache.put(key, value);

    }

  }

  if (value instanceof CreationPlaceholder) {

    synchronized (value) {

      CreationPlaceholder progress = (CreationPlaceholder) value;

      if (progress.value == null) {

        progress.value = createValue(reader, key); //调用此函数创建缓存值

        synchronized (readerCache) {

          innerCache.put(key, progress.value);

          }

        }

      }

      return progress.value;

  }

  return value;

}

Cache的createValue函数根据类型的不同而不同，我们仅分析IntCache和StringIndexCache的实现.

IntCache的createValue函数如下：

  protected Object createValue(IndexReader reader, Entry entryKey) throws IOException {

    Entry entry = entryKey;

    String field = entry.field;

    IntParser parser = (IntParser) entry.custom;

    int[] retArray = null;

    TermDocs termDocs = reader.termDocs();

    TermEnum termEnum = reader.terms (new Term (field));

    try {

      //依次将域中所有的term都取出来，用IntParser进行解析，缓存retArray[]位置即文档号，retArray[i]即第i篇文档所包含的int值.

      do {

        Term term = termEnum.term();

        if (term==null || term.field() != field) break;

        int termval = parser.parseInt(term.text());

        if (retArray == null)

          retArray = new int[reader.maxDoc()];

        termDocs.seek (termEnum);

        while (termDocs.next()) {

          retArray[termDocs.doc()] = termval;

        }

      } while (termEnum.next());

    } catch (StopFillCacheException stop) {

    } finally {

      termDocs.close();

      termEnum.close();

    }

    if (retArray == null)

      retArray = new int[reader.maxDoc()];

    return retArray;

  }

};

StringIndexCache的createValue函数如下：

protected Object createValue(IndexReader reader, Entry entryKey) throws IOException {

  String field = StringHelper.intern(entryKey.field);

  final int[] retArray = new int[reader.maxDoc()];

  String[] mterms = new String[reader.maxDoc()+1];

  TermDocs termDocs = reader.termDocs();

  TermEnum termEnum = reader.terms (new Term (field));

  int t = 0; 

  mterms[t++] = null;

  try {

    do {

      Term term = termEnum.term();

      if (term==null || term.field() != field) break;

      mterms[t] = term.text(); //mterms[i]保存的是按照字典顺序第i个term所对应的字符串。

      termDocs.seek (termEnum);

      while (termDocs.next()) {

        retArray[termDocs.doc()] = t; //retArray[i]保存的是第i篇文档所包含的字符串在mterms中的位置。

      }

      t++;

    } while (termEnum.next());

  } finally {

    termDocs.close();

    termEnum.close();

  }

  if (t == 0) {

    mterms = new String[1];

  } else if (t < mterms.length) {

    String[] terms = new String[t];

    System.arraycopy (mterms, 0, terms, 0, t);

    mterms = terms;

  }

  StringIndex value = new StringIndex (retArray, mterms);

  return value;

}

FieldCacheRangeFilter的可以是各种类型的Range，其中Int类型用下面的函数生成：

public static FieldCacheRangeFilter<Integer> newIntRange(String field, FieldCache.IntParser parser, Integer lowerVal, Integer upperVal, boolean includeLower, boolean includeUpper) {

  return new FieldCacheRangeFilter<Integer>(field, parser, lowerVal, upperVal, includeLower, includeUpper) {

    @Override

    public DocIdSet getDocIdSet(IndexReader reader) throws IOException {

      final int inclusiveLowerPoint, inclusiveUpperPoint;

      //计算左边界

      if (lowerVal != null) {

        int i = lowerVal.intValue();

        if (!includeLower && i == Integer.MAX_VALUE)

          return DocIdSet.EMPTY_DOCIDSET;

        inclusiveLowerPoint = includeLower ? i : (i + 1);

      } else {

        inclusiveLowerPoint = Integer.MIN_VALUE;

      }

      //计算右边界

      if (upperVal != null) {

        int i = upperVal.intValue();

        if (!includeUpper && i == Integer.MIN_VALUE)

          return DocIdSet.EMPTY_DOCIDSET;

        inclusiveUpperPoint = includeUpper ? i : (i - 1);

      } else {

        inclusiveUpperPoint = Integer.MAX_VALUE;

      }

      if (inclusiveLowerPoint > inclusiveUpperPoint)

        return DocIdSet.EMPTY_DOCIDSET;

      //从cache中取出values，values[i]表示第i篇文档在此域中的值

      final int[] values = FieldCache.DEFAULT.getInts(reader, field, (FieldCache.IntParser) parser);

      return new FieldCacheDocIdSet(reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0)) {

        @Override

        boolean matchDoc(int doc) {

          //仅在文档i所对应的值在区间内的时候才返回。

          return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;

        }

      };

    }

  };

}

FieldCacheRangeFilter同NumericRangeFilter或者TermRangeFilter功能类似，只不过后两者取得docid的bitset都是从索引中取出，而前者是缓存了的，加快了速度。

同样FieldCacheTermsFilter同TermFilter功能类似，也是前者进行了缓存，加快了速度。

6.5、 MultiTermQueryWrapperFilter<Q>

MultiTermQueryWrapperFilter包含成员变量Q query，其getDocIdSet得到满足此query的文档号bitset。

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {

  final TermEnum enumerator = query.getEnum(reader);

  try {

    if (enumerator.term() == null)

      return DocIdSet.EMPTY_DOCIDSET;

    final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc());

    final int[] docs = new int[32];

    final int[] freqs = new int[32];

    TermDocs termDocs = reader.termDocs();

    try {

      int termCount = 0;

      //遍历满足query的所有term

      do {

        Term term = enumerator.term();

        if (term == null)

          break;

        termCount++;

        termDocs.seek(term);

        while (true) {

          //得到每个term的文档号列表，放入bitset

          final int count = termDocs.read(docs, freqs);

          if (count != 0) {

            for(int i=0;i<count;i++) {

              bitSet.set(docs[i]);

            }

          } else {

            break;

          }

        }

      } while (enumerator.next());

      query.incTotalNumberOfTerms(termCount);

    } finally {

      termDocs.close();

    }

    return bitSet;

  } finally {

    enumerator.close();

  }

}

MultiTermQueryWrapperFilter有三个重要的子类：

  • NumericRangeFilter<T>：以NumericRangeQuery作为query
  • PrefixFilter：以PrefixQuery作为query
  • TermRangeFilter：以TermRangeQuery作为query

 

6.6、QueryWrapperFilter

其包含一个查询对象，getDocIdSet会获得所有满足此查询的文档号：

public DocIdSet getDocIdSet(final IndexReader reader) throws IOException {

  final Weight weight = query.weight(new IndexSearcher(reader));

  return new DocIdSet() {

    public DocIdSetIterator iterator() throws IOException {

      return weight.scorer(reader, true, false); //Scorer的next即返回一个个文档号。

    }

  };

}

 

6.7、SpanFilter

6.7.1、SpanQueryFilter 

其包含一个SpanQuery query，作为过滤器，其除了通过getDocIdSet得到文档号之外，bitSpans函数得到的SpanFilterResult还包含位置信息，可以用于在FilterQuery中起过滤作用。

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {

  SpanFilterResult result = bitSpans(reader);

  return result.getDocIdSet();

}

public SpanFilterResult bitSpans(IndexReader reader) throws IOException {

  final OpenBitSet bits = new OpenBitSet(reader.maxDoc());

  Spans spans = query.getSpans(reader);

  List<SpanFilterResult.PositionInfo> tmp = new ArrayList<SpanFilterResult.PositionInfo>(20);

  int currentDoc = -1;

  SpanFilterResult.PositionInfo currentInfo = null;

  while (spans.next())

  {

    //将docid放入bitset

    int doc = spans.doc();

    bits.set(doc);

    if (currentDoc != doc)

    {

      currentInfo = new SpanFilterResult.PositionInfo(doc);

      tmp.add(currentInfo);

      currentDoc = doc;

    }

    //将start和end信息放入PositionInfo

    currentInfo.addPosition(spans.start(), spans.end());

  }

  return new SpanFilterResult(bits, tmp);

}

 

6.7.2、CachingSpanFilter

由Filter的接口DocIdSet getDocIdSet(IndexReader reader)得知，一个docid的bitset是同一个reader相对应的。

有前面对docid的描述可知，其仅对一个打开的reader有意义。

CachingSpanFilter 有一个成员变量Map<IndexReader,SpanFilterResult> cache保存从reader到SpanFilterResult的映射，另一个成员变量SpanFilter filter用于缓存不命中的时候得到SpanFilterResult。

其getDocIdSet如下：

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {

  SpanFilterResult result = getCachedResult(reader);

  return result != null ? result.getDocIdSet() : null;

}

private SpanFilterResult getCachedResult(IndexReader reader) throws IOException {

  lock.lock();

  try {

    if (cache == null) {

      cache = new WeakHashMap<IndexReader,SpanFilterResult>();

    }

    //如果缓存命中，则返回缓存中的结果。

    final SpanFilterResult cached = cache.get(reader);

    if (cached != null) return cached;

  } finally {

    lock.unlock();

  }

  //如果缓存不命中，则用SpanFilter直接从reader中得到结果。

  final SpanFilterResult result = filter.bitSpans(reader);

  lock.lock();

  try {

    //将新得到的结果放入缓存

    cache.put(reader, result);

  } finally {

    lock.unlock();

  }

  return result;


}
分享到：
| ibatis insert 返回对象
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    lucene，lucene教程，lucene讲解

    lucene，lucene教程，lucene讲解。 为了对文档进行索引，Lucene 提供了五个基础的类 public class IndexWriter org.apache.lucene.index.IndexWriter public abstract class Directory org.apache.lucene.store....

    lucene-4.7.0全套jar包

    【Lucene 4.7.0 全套JAR包详解】 Lucene是一个开源全文搜索引擎库，由Apache软件基金会开发并维护。它提供了一个高级、灵活的文本搜索API，允许开发者轻松地在应用程序中实现复杂的搜索功能。这次提供的“lucene-...

    lucene3.0 lucene3.0

    lucene3.0 lucene3.0 lucene3.0 lucene3.0 lucene3.0

    Lucene3.5源码jar包

    本压缩包包含的是Lucene 3.5.0版本的全部源码，对于想要深入理解Lucene工作原理、进行二次开发或者进行搜索引擎相关研究的开发者来说，是一份非常宝贵的学习资源。 Lucene 3.5.0是Lucene的一个重要版本，它在3.x...

    Lucene时间区间搜索

    Lucene是一款强大的全文搜索引擎库，广泛应用于各种数据检索场景。在C#环境下，利用Lucene进行时间区间搜索是提高数据检索效率和精确度的重要手段。本篇将深入探讨如何在C#中实现Lucene的时间区间查询匹配，以及涉及...

    Lucene示例 BM25相似度计算

    在IT领域，搜索引擎技术是至关重要的，而Lucene作为一个开源全文搜索引擎库，广泛应用于各种文本检索系统中。本文将深入探讨Lucene示例中的BM25相似度计算，旨在帮助初学者理解如何利用Lucene 4.7.1版本构建索引、...

    lucene in action英文版 lucene 3.30包

    《Lucene in Action》是关于Apache Lucene的权威指南，这本书深入浅出地介绍了全文搜索引擎的构建和优化。Lucene是一个高性能、全文本搜索库，它允许开发人员在应用程序中轻松实现复杂的搜索功能。这本书主要面向...

    lucene-core-7.7.0-API文档-中文版.zip

    赠送jar包：lucene-core-7.7.0.jar； 赠送原API文档：lucene-core-7.7.0-javadoc.jar； 赠送源代码：lucene-core-7.7.0-sources.jar； 赠送Maven依赖信息文件：lucene-core-7.7.0.pom； 包含翻译后的API文档：lucene...

    计算机专业外文翻译（lucene相关）

    "计算机专业外文翻译（lucene相关）" 本文翻译了论文"Scale-up x Scale-out: A Case Study using Nutch/Lucene"，介绍了计算机专业领域中关于Lucene相关的知识点。 Scale-up vs Scale-out 论文中讨论了两个相对...

    lucene in action 2nd edition, lucene in action 第二版 PDF

    《Lucene in Action 第二版》是一本深入探讨Apache Lucene全文检索库的专业书籍，它在Java开发领域具有很高的权威性。这本书详细介绍了如何利用Lucene进行高效的文本搜索和索引构建，是Java开发者和信息检索爱好者的...

    Annotated Lucene 中文版 Lucene源码剖析

    《Annotated Lucene 中文版 Lucene源码剖析》是一本深入探讨Apache Lucene的书籍，专注于源码解析，帮助读者理解这个强大的全文搜索引擎库的工作原理。Lucene是一款开源的Java库，它提供了高效的文本搜索功能，被...

    lucene所有的jar包

    《全面解析Lucene jar包：从基础到应用》 在信息技术高速发展的今天，搜索引擎已经成为我们获取信息不可或缺的工具。在Java领域，Lucene作为一个强大的全文搜索引擎库，深受开发者喜爱。本文将详细介绍“lucene所有...

    Lucene的原理完整版pdf

    **Lucene原理详解** Lucene是一个高性能、全文检索库，由Apache软件基金会开发并维护，是Java编程语言中广泛使用的搜索引擎库。它提供了一个简单但功能强大的API，用于索引和搜索文本数据，使得开发者可以轻松地在...

    Lucene简介.介绍

    【Lucene 简介】 Lucene 是一个强大的开源全文搜索库，由 Java 编写，主要用于为应用程序添加全文检索功能。它不是一个完整的全文搜索引擎应用，而是一个工具包，允许开发者将其集成到自己的软件中，以实现高效、...

    lucene 2.0 api以及lucene 3.0 api

    **Lucene 2.0 API 和 Lucene 3.0 API 深度解析** Lucene 是一个由 Apache 软件基金会开发的全文搜索引擎库，它为开发者提供了在 Java 应用程序中实现高性能、可扩展的全文搜索功能的能力。Lucene 的 API 设计得相当...

    Lucene与关系型数据库对比

    《Lucene与关系型数据库对比：深度解析与应用探索》 在信息爆炸的时代，数据管理和检索成为了企业乃至个人日常工作中不可或缺的部分。随着技术的发展，不同的数据处理方式应运而生，其中Lucene与关系型数据库作为两...

    lucene可视化工具 Luck-6.5.0

    Lucene 是一个强大的开源全文搜索引擎库，它允许开发者在自己的应用程序中实现高级的搜索功能。而 Luck 是 Lucene 的一个可视化工具，版本为 6.5.0，它为 Lucene 的索引提供了直观的界面，帮助用户更好地理解和调试 ...

    Lucene 5 主要jar包

    Apache Lucene是一个开源全文搜索引擎库，它为Java开发者提供了强大的文本搜索功能。在这个"Lucene 5 主要jar包"中，我们找到了一系列与Lucene 5.0.0相关的jar文件，这些文件是构建和运行基于Lucene的搜索应用程序的...

    lucene 4.7.2 Demo

    《Lucene 4.7.2 Demo：Java全文搜索引擎的核心技术探索》 Lucene，作为Apache软件基金会的一个开源项目，是Java平台上的一个全文搜索引擎库。它的主要功能是提供高效、可扩展的文本检索和分析能力。在4.7.2这个版本...

    Lucene资料大全(包括Lucene_in_Action书等)

    标题"Lucene资料大全(包括Lucene_in_Action书等)"表明这是一个包含全面Lucene学习资源的集合，其中最显著的是《Lucene_in_Action》这本书。这是一本广泛认可的关于Apache Lucene的权威指南，通常被简称为LIA，它深入...

Magicbox
Global site tag (gtag.js) - Google Analytics