`
wutao8818
  • 浏览: 618303 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

lucene几个类的含义2

阅读更多
索引文件里的文件命名有什么规律

引用

_9.cfs
_9.cfx
segments_k
segments.gen


private final synchronized String newSegmentName(){
  return "_"+Integer.toString(segmentInfos.counter++,Character.MAX_RADIX);
}


将segmentInfos.counter加1后转为36进制。前面加下划线。所以segmentInfos.counter的值表示了segment中总共文档的数量。

文档倒排。这是建立索引内存消耗最大的时刻。除了词条,还需要存储词条位置,频率等信息

package org.apache.lucene.index;

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.IOException;
import java.io.Reader;
import org.apache.lucene.document.Fieldable;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;

/**
 * Holds state for inverting all occurrences of a single
 * field in the document.  This class doesn't do anything
 * itself; instead, it forwards the tokens produced by
 * analysis to its own consumer
 * (InvertedDocConsumerPerField).  It also interacts with an
 * endConsumer (InvertedDocEndConsumerPerField).
 */

final class DocInverterPerField extends DocFieldConsumerPerField {

  final private DocInverterPerThread perThread;
  final private FieldInfo fieldInfo;
  final InvertedDocConsumerPerField consumer;
  final InvertedDocEndConsumerPerField endConsumer;
  final DocumentsWriter.DocState docState;
  final FieldInvertState fieldState;

  public DocInverterPerField(DocInverterPerThread perThread, FieldInfo fieldInfo) {
    this.perThread = perThread;
    this.fieldInfo = fieldInfo;
    docState = perThread.docState;
    fieldState = perThread.fieldState;
    this.consumer = perThread.consumer.addField(this, fieldInfo);
    this.endConsumer = perThread.endConsumer.addField(this, fieldInfo);
  }

  void abort() {
    consumer.abort();
    endConsumer.abort();
  }

  public void processFields(final Fieldable[] fields,
                            final int count) throws IOException {

    fieldState.reset(docState.doc.getBoost());

    final int maxFieldLength = docState.maxFieldLength;

    final boolean doInvert = consumer.start(fields, count);

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

      final Fieldable field = fields[i];

      // TODO FI: this should be "genericized" to querying
      // consumer if it wants to see this particular field
      // tokenized.
      if (field.isIndexed() && doInvert) {

        if (fieldState.length > 0)
          fieldState.position += docState.analyzer.getPositionIncrementGap(fieldInfo.name);

        if (!field.isTokenized()) {		  // un-tokenized field
          String stringValue = field.stringValue();
          final int valueLength = stringValue.length();
          perThread.singleTokenTokenStream.reinit(stringValue, 0, valueLength);
          fieldState.attributeSource = perThread.singleTokenTokenStream;
          perThread.localTokenStream.reset();
          consumer.start(field);

          boolean success = false;
          try {
            consumer.add();
            success = true;
          } finally {
            if (!success)
              docState.docWriter.setAborting();
          }
          fieldState.offset += valueLength;
          fieldState.length++;
          fieldState.position++;
        } else {                                  // tokenized field
          final TokenStream stream;
          final TokenStream streamValue = field.tokenStreamValue();

          if (streamValue != null) 
            stream = streamValue;
          else {
            // the field does not have a TokenStream,
            // so we have to obtain one from the analyzer
            final Reader reader;			  // find or make Reader
            final Reader readerValue = field.readerValue();

            if (readerValue != null)
              reader = readerValue;
            else {
              String stringValue = field.stringValue();
              if (stringValue == null)
                throw new IllegalArgumentException("field must have either TokenStream, String or Reader value");
              perThread.stringReader.init(stringValue);
              reader = perThread.stringReader;
            }
          
            // Tokenize field and add to postingTable
            stream = docState.analyzer.reusableTokenStream(fieldInfo.name, reader);
          }

          // reset the TokenStream to the first token
          stream.reset();

          try {
            int offsetEnd = fieldState.offset-1;
            
            boolean useNewTokenStreamAPI = stream.useNewAPI();
            Token localToken = null;
            
            if (useNewTokenStreamAPI) {
              fieldState.attributeSource = stream;
            } else {              
              fieldState.attributeSource = perThread.localTokenStream;
              localToken = perThread.localToken;
            }         
            
            consumer.start(field);

            OffsetAttribute offsetAttribute = (OffsetAttribute) fieldState.attributeSource.addAttribute(OffsetAttribute.class);
            PositionIncrementAttribute posIncrAttribute = (PositionIncrementAttribute) fieldState.attributeSource.addAttribute(PositionIncrementAttribute.class);
            
            for(;;) {

              // If we hit an exception in stream.next below
              // (which is fairly common, eg if analyzer
              // chokes on a given document), then it's
              // non-aborting and (above) this one document
              // will be marked as deleted, but still
              // consume a docID
              Token token = null;


/** 
token.termText 切出的词
token.startOffset 词的起始位置
token.endOffset 词的结束位置
*/

              if (useNewTokenStreamAPI) {
                if (!stream.incrementToken()) break;
              } else {
                token = stream.next(localToken);
                if (token == null) break;
                perThread.localTokenStream.set(token);
              }
              
              final int posIncr = posIncrAttribute.getPositionIncrement();
              fieldState.position += posIncr - 1;
              if (posIncr == 0)
                fieldState.numOverlap++;

              boolean success = false;
              try {
                // If we hit an exception in here, we abort
                // all buffered documents since the last
                // flush, on the likelihood that the
                // internal state of the consumer is now
                // corrupt and should not be flushed to a
                // new segment:
                consumer.add();
                success = true;
              } finally {
                if (!success)
                  docState.docWriter.setAborting();
              }
              fieldState.position++;
              offsetEnd = fieldState.offset + offsetAttribute.endOffset();
              if (++fieldState.length >= maxFieldLength) {
                if (docState.infoStream != null)
                  docState.infoStream.println("maxFieldLength " +maxFieldLength+ " reached for field " + fieldInfo.name + ", ignoring following tokens");
                break;
              }
            }
            fieldState.offset = offsetEnd+1;
          } finally {
            stream.close();
          }
        }

        fieldState.boost *= field.getBoost();
      }
    }

    consumer.finish();
    endConsumer.finish();
  }
}


分享到:
评论

相关推荐

    lucene源码和程序

    在Lucene中,主要涉及以下几个核心概念: 1. **文档(Document)**:在Lucene中,文档是信息的基本单位,可以代表网页、电子邮件或者其他形式的数据。文档由一系列字段(Field)组成,每个字段有名称和内容,比如...

    lucene_demo例子

    这些示例通常会涵盖以下几个关键知识点: 1. **安装与配置**:Lucene的下载、构建环境的搭建,包括引入相应的Maven或Gradle依赖,以及设置Java开发环境。 2. **索引创建**:Lucene是如何通过Analyzer分析文本,将...

    Lucene加庖丁解牛测试类

    在“Lucene加庖丁解牛测试类”中,我们可以从以下几个方面进行实践: 1. **索引构建**:测试类应包含创建索引的代码,这通常涉及Analyzer的选择(如StandardAnalyzer)、Document的构建以及IndexWriter的使用。...

    lucene 入门

    Lucene 的核心组件包括以下几个部分: 1. **索引(Indexing)**:Lucene 首先将非结构化的文本数据转化为结构化的索引,以便于快速检索。这个过程包括分词(Tokenization)、词干提取(Stemming)、停用词处理...

    Lucene中文分词器组件

    在Lucene中,常见的中文分词器组件有以下几个: 1. **IK Analyzer**:IK Analyzer是一个开源的、基于Java实现的中文分词工具,支持多种分词模式,包括精确模式、全模式、最短路径模式等。它可以根据实际需求进行...

    lucene1.0.doc

    Lucene的核心组件包括以下几个部分: 1. 文档(Document):代表要索引的数据源,可以是网页、文章、数据库记录等。 2. 字段(Field):文档中的数据被划分为不同的字段,每个字段具有特定的含义和处理方式。 3. ...

    Lucene检索算法的改进.pdf

    文章详细阐述了一个改进后的系统模型,该模型主要包括以下几个关键步骤: 1. **天网源数据**:指原始的网页数据来源,是整个检索系统的基础。 2. **数据转换**:通过网页分析器和XML转换器将原始网页数据转换成...

    lucene文档--

    Lucene的核心概念包括以下几个方面: 1. **索引**:在Lucene中,索引是将非结构化的文本数据转化为可搜索的形式。它通过分词器(Tokenizer)将文本拆分成单词,然后对这些单词创建倒排索引。倒排索引是一种数据结构...

    一个例子教你学懂搜索引擎(lucene)

    在给定的文件“luceneTest”中,可能包含了示例代码或者配置文件,这通常包括以下几个步骤: 1. 初始化索引目录:创建一个FSDirectory对象,指定用于存储索引的物理路径。 2. 创建索引写入器:使用...

    Lucene 原理与代码分析完整版1

    在索引中,主要存储的是以下几个关键元素: 1. **文档(Document)**:这是索引的基本单位,可以是一篇文章、一封邮件或其他任何包含文本的数据。在Lucene中,文档由一系列字段(Field)组成,每个字段都有其特定的...

    PanGu.Lucene.Analyzer.rar

    Pangu分析器的核心功能包括以下几个方面: 1. **中文分词**:中文不同于英文,单词之间没有明显的边界。Pangu分析器采用了先进的分词算法,能够准确识别和切割中文词语,如使用字典匹配、基于统计的模型等方法。 2...

    lucene索引

    创建索引是 Lucene 的核心步骤,包括以下几个阶段: #### 2.1 初始化索引目录 首先,需要创建一个索引目录,这可以是本地文件系统、网络共享目录,甚至是内存中的索引。 ```java Directory directory = ...

    java拼车网雏形(Ext2.0+SSH+oracle10g+lucene2.4)

    【标题】"java拼车网雏形(Ext2.0+SSH+oracle10g+lucene2.4)" 涉及的核心技术是Java Web开发中的几个关键组件,包括ExtJS 2.0前端框架,Spring、Struts2和Hibernate(SSH)后端框架,Oracle 10g数据库以及Lucene ...

    java大数据作业_7Flume、Kafka、Sqoop、Lucene

    建立索引的过程通常包括以下几个步骤: 1. **创建索引器**:首先需要创建一个 IndexWriter 对象,用于管理索引的写入操作。 2. **文档解析**:将要索引的文档转换为 Document 对象,每个文档包含多个 Field。 3. **...

    我自己的demo例子

    从提供的文件名"sample.ck.paper.lucene3"来看,我们可以推断出几个关键信息: 1. **sample**:这个词通常用来表示示例或样例,这与标题中的“demo例子”相吻合,表明这是一个用来演示或教学的例子。 2. **ck**:...

    Manning Taming Text How to Find, Organize, and Manipulate It. Jan.2013.pdf

    2. 描述部分提到的关键词“lucene solr search NLP”指向了文档讨论的几个核心主题: - Lucene:这是由Apache软件基金会支持的一个高性能的、可伸缩的全文检索库,广泛用于搜索引擎和文档检索系统。它以Java编写,...

    Solr-ik分词

    在Solr中配置Ik分词器,通常需要以下几个步骤: 1. 下载ikanalyzer-solr5版本的分词器库,并将其添加到Solr的lib目录下,确保Solr启动时能够加载到这个库。 2. 在Solr的schema.xml文件中,定义一个字段类型(Field...

    重复数字统计器 .e文件

    使用ES配合“重复数字统计器.e”有以下几个优点: 1. **分布式存储**:ES具有强大的横向扩展能力,能轻松处理PB级别的数据。 2. **实时分析**:ES的实时索引和搜索功能,使得用户可以在数据输入的同时获得统计结果。...

    Android 智能问答机器人的实现

    博客实例代码中的"zhy_robot_01"可能包含以下几个关键部分: 1. **用户界面(UI)设计**:包括输入框供用户输入问题,以及显示答案的区域。可以使用Android Studio提供的布局设计工具创建。 2. **事件监听器**:监听...

    基于HDFS、ElasticSearch、Spark和TensorFlow的文本分析中台基础架构.pptx

    该文本分析中台的基础架构主要包括以下几个部分: 1. **数据收集层**:通过日志采集工具(如 Flume、Logstash 等)将各类文本数据收集起来,存储至 HDFS。 2. **数据处理层**:利用 Spark 进行数据预处理,包括数据...

Global site tag (gtag.js) - Google Analytics