• NONE：域信息不会写入倒排表，索引阶段无法通过该域名进行搜索；
• DOCS：文档写入倒排表，但由于不记录词频信息，因此出现多次也仅当一次处理；
• DOCS\_AND\_FREQS：文档和词频写入倒排表；
• DOCS\_AND\_FREQS\_AND\_POSITIONS：文档、词频及位置写入倒排表；
• DOCS\_AND\_FREQS\_AND\_POSITIONS\_AND\_OFFSETS：文档、词频、位置及偏移写入倒排表。

// 构建倒排表if (fieldType.indexOptions() != IndexOptions.NONE) { fp = getOrAddField(fieldName, fieldType, true); boolean first = fp.fieldGen != fieldGen; // field具体的索引、分词操作 fp.invert(field, first); if (first) { fields[fieldCount++] = fp; fp.fieldGen = fieldGen; } } else { verifyUnIndexedFieldType(fieldName, fieldType); }// 存储该field的storeField if (fieldType.stored()) { if (fp == null) { fp = getOrAddField(fieldName, fieldType, false); } if (fieldType.stored()) { String value = https://www.it610.com/article/field.stringValue(); if (value != null && value.length()> IndexWriter.MAX_STORED_STRING_LENGTH) { throw new IllegalArgumentException("stored field \"" + field.name() + "\" is too large (" + value.length() + " characters) to store"); } try { storedFieldsConsumer.writeField(fp.fieldInfo, field); } catch (Throwable th) { throw AbortingException.wrap(th); } } }// 建立DocValue（通过文档查询文档下包含了哪些词） DocValuesType dvType = fieldType.docValuesType(); if (dvType == null) { throw new NullPointerException("docValuesType must not be null (field: \"" + fieldName + "\")"); } if (dvType != DocValuesType.NONE) { if (fp == null) { fp = getOrAddField(fieldName, fieldType, false); } indexDocValue(fp, dvType, field); } if (fieldType.pointDimensionCount() != 0) { if (fp == null) { fp = getOrAddField(fieldName, fieldType, false); } indexPoint(fp, field); }

// invert：对Field进行分词处理首先需要将Field转化为TokenStream try (TokenStream stream = tokenStream = field.tokenStream(docState.analyzer, tokenStream)) // TokenStream在不同分词器下实现不同，根据不同分词器返回相应的TokenStream if (tokenStream != null) { return tokenStream; } else if (readerValue() != null) { return analyzer.tokenStream(name(), readerValue()); } else if (stringValue() != null) { return analyzer.tokenStream(name(), stringValue()); }public final TokenStream tokenStream(final String fieldName, final Reader reader) { // 通过复用策略，如果TokenStreamComponents中已经存在Component则复用。 TokenStreamComponents components = reuseStrategy.getReusableComponents(this, fieldName); final Reader r = initReader(fieldName, reader); // 如果Component不存在，则根据分词器创建对应的Components。 if (components == null) { components = createComponents(fieldName); reuseStrategy.setReusableComponents(this, fieldName, components); } // 将java.io.Reader输入流传入Component中。 components.setReader(r); return components.getTokenStream(); }

• StopAnalyzer：停用词分词器，用于过滤词汇中特定字符串或单词。
• StandardAnalyzer：标准分词器，能够根据数字、字母等进行分词，支持词表过滤替代StopAnalyzer功能，支持中文简单分词。
• CJKAnalyzer：能够根据中文语言习惯对中文分词提供了比较好的支持。

// 标准分词器创建Component过程，涵盖了标准分词处理器、Term转化小写、常用词过滤三个功能 protected TokenStreamComponents createComponents(final String fieldName) { final StandardTokenizer src = https://www.it610.com/article/new StandardTokenizer(); src.setMaxTokenLength(maxTokenLength); TokenStream tok = new StandardFilter(src); tok = new LowerCaseFilter(tok); tok = new StopFilter(tok, stopwords); return new TokenStreamComponents(src, tok) { @Override protected void setReader(final Reader reader) { src.setMaxTokenLength(StandardAnalyzer.this.maxTokenLength); super.setReader(reader); } }; }

// 以LowerCaseFilter为例，通过其下的increamentToken将Token中的字符转化为小写 public final boolean incrementToken() throws IOException { if (input.incrementToken()) { CharacterUtils.toLowerCase(termAtt.buffer(), 0, termAtt.length()); return true; } else return false; }

try (TokenStream stream = tokenStream = field.tokenStream(docState.analyzer, tokenStream)) { // reset TokenStream stream.reset(); invertState.setAttributeSource(stream); termsHashPerField.start(field, first); // 分析并获取Token属性 while (stream.incrementToken()) { …… try { // 构建倒排表 termsHashPerField.add(); } catch (MaxBytesLengthExceededException e) { …… } catch (Throwable th) { throw AbortingException.wrap(th); } } …… }

synchronized long deleteTerms(final Term... terms) throws IOException { // TODO why is this synchronized? final DocumentsWriterDeleteQueue deleteQueue = this.deleteQueue; // 文档删除操作是将删除的词信息添加到删除队列中，根据flush策略进行删除 long seqNo = deleteQueue.addDelete(terms); flushControl.doOnDelete(); lastSeqNo = Math.max(lastSeqNo, seqNo); if (applyAllDeletes(deleteQueue)) { seqNo = -seqNo; } return seqNo; }

private boolean applyAllDeletes(DocumentsWriterDeleteQueue deleteQueue) throws IOException { // 判断是否满足删除条件 --> onDelete if (flushControl.getAndResetApplyAllDeletes()) { if (deleteQueue != null) { ticketQueue.addDeletes(deleteQueue); } // 指定执行删除操作的event putEvent(ApplyDeletesEvent.INSTANCE); // apply deletes event forces a purge return true; } return false; }

public void onDelete(DocumentsWriterFlushControl control, ThreadState state) { // 判断并设置是否满足删除条件 if ((flushOnRAM() && control.getDeleteBytesUsed() > 1024*1024*indexWriterConfig.getRAMBufferSizeMB())) { control.setApplyAllDeletes(); if (infoStream.isEnabled("FP")) { infoStream.message("FP", "force apply deletes bytesUsed=" + control.getDeleteBytesUsed() + " vs ramBufferMB=" + indexWriterConfig.getRAMBufferSizeMB()); } } }

• maxBufferedDocs：文档收集到一定数量时触发Flush操作。
• ramBufferSizeMB：文档内容达到限定值时触发Flush操作。

@Override public void onInsert(DocumentsWriterFlushControl control, ThreadState state) { // 根据文档数进行Flush if (flushOnDocCount() && state.dwpt.getNumDocsInRAM() >= indexWriterConfig .getMaxBufferedDocs()) { // Flush this state by num docs control.setFlushPending(state); // 根据内存使用量进行Flush } else if (flushOnRAM()) {// flush by RAM final long limit = (long) (indexWriterConfig.getRAMBufferSizeMB() * 1024.d * 1024.d); final long totalRam = control.activeBytes() + control.getDeleteBytesUsed(); if (totalRam >= limit) { if (infoStream.isEnabled("FP")) { infoStream.message("FP", "trigger flush: activeBytes=" + control.activeBytes() + " deleteBytes=" + control.getDeleteBytesUsed() + " vs limit=" + limit); } markLargestWriterPending(control, state, totalRam); } } }

• TieredMergePolicy：先通过OneMerge打分机制对IndexWriter提供的段集进行排序，然后在排序后的段集中选取部分（可能不连续）段来生成一个待合并段集，即非相邻的段文件（Non-adjacent Segment）。
• LogMergePolicy：定长的合并方式，通过maxLevel、LEVEL\_LOG\_SPAN、levelBottom参数将连续的段分为不同的层级，再通过mergeFactor从每个层级中选取段进行合并。

private synchronized boolean updatePendingMerges(MergePolicy mergePolicy, MergeTrigger trigger, int maxNumSegments) throws IOException {final MergePolicy.MergeSpecification spec; // 查询需要合并的段 if (maxNumSegments != UNBOUNDED_MAX_MERGE_SEGMENTS) { assert trigger == MergeTrigger.EXPLICIT || trigger == MergeTrigger.MERGE_FINISHED : "Expected EXPLICT or MERGE_FINISHED as trigger even with maxNumSegments set but was: " + trigger.name(); spec = mergePolicy.findForcedMerges(segmentInfos, maxNumSegments, Collections.unmodifiableMap(segmentsToMerge), this); newMergesFound = spec != null; if (newMergesFound) { final int numMerges = spec.merges.size(); for(int i=0; i

2）通过ConcurrentMergeScheduler类中的merge方法创建用户合并的线程MergeThread并启动。

@Override public synchronized void merge(IndexWriter writer, MergeTrigger trigger, boolean newMergesFound) throws IOException { …… while (true) { …… // 取出注册的后选段 OneMerge merge = writer.getNextMerge(); boolean success = false; try { // 构建用于合并的线程MergeThread final MergeThread newMergeThread = getMergeThread(writer, merge); mergeThreads.add(newMergeThread); updateIOThrottle(newMergeThread.merge, newMergeThread.rateLimiter); if (verbose()) { message("launch new thread [" + newMergeThread.getName() + "]"); } // 启用线程 newMergeThread.start(); updateMergeThreads(); success = true; } finally { if (!success) { writer.mergeFinish(merge); } } } }

3）通过doMerge方法执行merge操作；

public void merge(MergePolicy.OneMerge merge) throws IOException { …… try { // 用于处理merge前缓存任务及新段相关信息生成 mergeInit(merge); // 执行段之间的merge操作 mergeMiddle(merge, mergePolicy); mergeSuccess(merge); success = true; } catch (Throwable t) { handleMergeException(t, merge); } finally { // merge完成后的收尾工作 mergeFinish(merge) } …… }

五、Lucene搜索功能实现 5.1 加载索引库 Lucene想要执行搜索首先需要将索引段加载到内存中，由于加载索引库的操作非常耗时，因此仅有当索引库产生变化时需要重新加载索引库。

文章图片

加载索引库分为加载段信息和加载文档信息两个部分：
1）加载段信息：

• 通过segments.gen文件获取段中最大的generation，获取段整体信息；
• 读取.si文件，构造SegmentInfo对象，最后汇总得到SegmentInfos对象。

2）加载文档信息：

• 读取段信息，并从.fnm文件中获取相应的FieldInfo，构造FieldInfos；
• 打开倒排表的相关文件和词典文件；
• 读取索引的统计信息和相关norms信息；
• 读取文档文件。

文章图片

5.2 封装 索引库加载完成后需要IndexReader封装进IndexSearch，IndexSearch通过用户构造的Query语句和指定的Similarity文本相似度算法（默认BM25）返回用户需要的结果。通过IndexSearch.search方法实现搜索功能。
搜索：Query包含多种实现，包括BooleanQuery、PhraseQuery、TermQuery、PrefixQuery等多种查询方法，使用者可根据项目需求构造查询语句
排序：IndexSearch除了通过Similarity计算文档相关性分值排序外，也提供了BoostQuery的方式让用户指定关键词分值，定制排序。Similarity相关性算法也包含很多种不同的相关性分值计算实现，此处暂不做赘述，读者有需要可自行网上查阅。
六、总结 Lucene作为全文索引工具包，为中小型项目提供了强大的全文检索功能支持，但Lucene在使用的过程中存在诸多问题：

• 由于Lucene需要将检索的索引库通过IndexReader读取索引信息并加载到内存中以实现其检索能力，当索引量过大时，会消耗服务部署机器的过多内存。
• 搜索实现比较复杂，需要对每个Field的索引、分词、存储等信息一一设置，使用复杂。
• Lucene不支持集群。

Lucene使用时存在诸多限制，使用起来也不那么方便，当数据量增大时还是尽量选择ElasticSearch等分布式搜索服务器作为搜索功能的实现方案。

作者：vivo互联网服务器团队-Qian Yulun

推荐阅读

• 

  性价比高的男士面膜 男士面膜哪个牌子好
• 

  女性气血不足的6个表现 气血不足的症状有哪些表现女人？
• 

  如何办早教中心？
• 

  洗衣机免拆和拆洗哪种好哪种更适合你,大概率是这几个问题
• 

  电子商务发展现状分析
• 

  苹果6屏幕上的悬浮按钮怎么设置
• 

  睡上下铺对孩子的影响 睡上下铺有风水讲究吗
• 

  yoosee安卓版,如何安装智能家居产品?
• 

  建立空间站有什么用处呢?为什么不多建立几个空间站?
• 

  儿童吃蚝油对身体有害吗
• 

  大学的国际班什么意思可靠吗 大学的国际班的意思
• 

  冰皮月饼放冷冻还是冷藏
• 

  苹果总部
• 

  pcb板是什么材料？PCB板是什么东西
• 

  etc怎么充值缴费 etc怎么充值
• 

  附演出内容 2023淮安元旦文旅惠民演出直播观看入口
• 

  一举两得的举是什么意思 一举两得的举什么意思是什么
• 

  女生与女生聊天技巧
• 

  Presto调优总结
• 

  肺癌|肺癌早期能活多久？医生：看治疗情况

• 《深度倾听》第5天──「RIA学习力」便签输出第16期
• Quartz|Quartz 源码解析(四) —— QuartzScheduler和Listener事件监听
• Java内存泄漏分析系列之二（jstack生成的Thread|Java内存泄漏分析系列之二：jstack生成的Thread Dump日志结构解析）
• [源码解析]|[源码解析] NVIDIA HugeCTR，GPU版本参数服务器---(3)
• Android系统启动之init.rc文件解析过程
• 小程序有哪些低成本获客手段——案例解析
• 深度解读（《秘密》（八）—健康的秘密）
• 影响深度思考的9种思维定式
• Spring源码解析_属性赋值
• Android下的IO库-Okio源码解析(一)|Android下的IO库-Okio源码解析(一) 入门