Lucene 源码剖析 一 索引文件概述

1           Lucene是什么

Apache Lucene是一个高性能（high-performance）的全能的全文检索（full-featured text search engine）的搜索引擎框架库，完全（entirely）使用Java开发。它是一种技术（technology），适合于（suitable for）几乎（nearly）任何一种需要全文检索（full-text search）的应用，特别是跨平台（cross-platform）的应用。

 

 

Lucene 通过一些简单的接口（simple API）提供了强大的特征（powerful features）：

 

可扩展的高性能的索引能力（Scalable, High-Performance Indexing）

•                超过 20M/ 分钟的处理能力（ Pentium M 1.5GHz ）
•               很少的 RAM 内存需求，只需要 1MB heap
•               增量索引（ incremental indexing ）的速度与批量索引（ batch indexing ）的速度一样快
•                索引的大小粗略（ roughly ）为被索引的文本大小的 20-30%

  

强大的精确的高效率的检索算法（< /strong>Powerful, Accurate and Efficient Search Algorithms）

•               分级检索（ ranked searching ）能力，最好的结果优先推出在前面
•               很多强大的 query 种类： phrase queries, wildcard queries, proximity queries, range queries 等
•               支持域检索（ fielded searching ），如标题、作者、正文等
•               支持日期范围检索（ date-range searching ）
•               可以按任意域排序（ sorting by any field ）
•               支持多个索引的检索（ multiple-index searching ）并合并结果集（ merged results ）
•               允许更新和检索（ update and searching ）并发进行（ simultaneous ）

     

跨平台解决方案（Cross-Platform Solution）

•               以 Open Source 方式提供并遵循 Apache License ，允许你可以在即包括商业应用也包括 Open Source 程序中使用 Lucene
•               100%-pure Java （纯 Java 实现）
•                提供其他开发语言的实现版本并且它们的索引文件是兼容的

 

Lucene API被分成（divide into）如下几种包（package）

   

•                     org.apache.lucene.analysis     

定义了一个抽象的Analyser API，用于将text文本从一个java.io.Reader转换成一个TokenStream，即包括一些Tokens的枚举容器（enumeration）。一个TokenStream的组成（compose）是通过在一个Tokenizer的输出的结果上再应用TokenFilters生成的。一些少量的Analysers实现已经提供，包括StopAnalyzer和基于语法（gramar-based）分析的StandardAnalyzer。     

•                    org.apache.lucene.document  

提供一个简单的Document类，一个document只不过包括一系列的命名了（named）的Fields（域），它们的内容可以是文本（strings）也可以是一个java.io.Reader的实例。     

•                      org.apache.lucene.index         

提供两个主要类，一个是IndexWriter用于创建索引并添加文档（document），另一个是IndexReader用于访问索引中的数据。      

•                     org.apache.lucene.search        

提供数据结构（data structures）来呈现（represent）查询（queries）：TermQuery用于单个的词（individual words），PhraseQuery用于短语，BooleanQuery用于通过boolean关系组合（combinations）在一起的queries。而抽象的Searcher用于转变queries为命中的结果（hits）。IndexSearcher实现了在一个单独（single）的IndexReader上检索。      

•                      org.apache.lucene.queryParser      

使用JavaCC实现一个QueryParser。     

•                      org.apache.lucene.store          

定义了一个抽象的类用于存储呈现的数据(storing persistent data)，即Directory（目录），一个收集器（collection）包含了一些命名了的文件（named files），它们通过一个IndexOutput来写入，以及一个IndexInput来读取。提供了两个实现，FSDirectory使用一个文件系统目录来存储文件，而另一个RAMDirectory则实现了将文件当作驻留内存的数据结构（memory-resident data structures）。      

•                      org.apache.lucene.util              

包含了一小部分有用（handy）的数据结构，如BitVector和PriorityQueue等。

     

2           Hello World!

下面是一段简单的代码展示如何使用Lucene来进行索引和检索（使用JUnit来检查结果是否是我们预期的）：

 

 

    // Store the index in memory:
    Directory directory = new RAMDirectory();
    // To store an index on disk, use this instead:
    //Directory directory = FSDirectory.getDirectory(”/tmp/testindex”);
    IndexWriter iwriter = new IndexWriter(directory, analyzer, true);
    iwriter.setMaxFieldLength(25000);
    Document doc = new Document();
    String text = “This is the text to be indexed.“;
    doc.add(new Field(“fieldname“, text, Field.Store.YES,
        Field.Index.TOKENIZED));
    iwriter.addDocument(doc);
    iwriter.optimize();
    iwriter.close();
    
    // Now search the index:
    IndexSearcher isearcher = new IndexSearcher(directory);
    // Parse a simple query that searches for ”text”:
    QueryParser parser = new QueryParser(“fieldname“, analyzer);
    Query query = parser.parse(“text“);
    Hits hits = isearcher.search(query);
    assertEquals(1, hits.length());
    // Iterate through the results:
    for (int i = 0; i < hits.length(); i++) {
      Document hitDoc = hits.doc(i);
      assertEquals(“This is the text to be indexed.“, hitDoc.get(“fieldname“));
    }
    isearcher.close();
    directory.close(); 

为了使用Lucene，一个应用程序需要做如下几件事：

1.          通过添加一系列Fields来创建一批Documents对象。

2.          创建一个IndexWriter对象，并且调用它的AddDocument()方法来添加进Documents。

3.          调用QueryParser.parse()处理一段文本（string）来建造一个查询（query）对象。

4.          创建一个IndexReader对象并将查询对象传入到它的search()方法中。

   

   

3           Lucene Roadmap

      

 

           

            

 

5           索引是如何存储的

  

5.1   数据存储类Directory

    

    Directory及相关类负责文档索引的存储。

      

     

5.1.1       org.apache.lucene.store.Directory

   

一个Directory对象是一系列统一的文件列表（a flat list of files）。文件可以在它们被创建的时候一次写入，一旦文件被创建，它再次打开后只能用于读取（read）或者删除（delete）操作。并且同时在读取和写入的时候允许随机访问（random access）。

  

在这里并不直接使用Java I/O API，但是更确切地说，所有I/O操作都是通过这个API处理的。这使得读写操作方式更统一起来，如基于内存的索引（RAM-based indices）的实现（即RAMDirectory）、通过JDBC存储在数据库中的索引、将一个索引存储为一个文件的实现（即FSDirectory）。

  

Directory的锁机制是一个LockFactory的实例实现的，可以通过调用Directory实例的setLockFactory()方法来更改。

  

 

  

5.1.2       org.apache.lucene.store.FSDirectory

    

FSDirectory类直接实现Directory抽象类为一个包含文件的目录。目录锁的实现使用缺省的SimpleFSLockFactory，但是可以通过两种方式修改，即给getLockFactory()传入一个LockFactory实例，或者通过调用setLockFactory()方法明确制定LockFactory类。

  

目录将被缓存（cache）起来，对一个指定的符合规定的路径（canonical path）来说，同样的FSDirectory实例通常通过getDirectory()方法返回。这使得同步机制（synchronization）能对目录起作用。

  

 

  

5.1.3       org.apache.lucene.store.RAMDirectory

    

RAMDirectory类是一个驻留内存的（memory-resident）Directory抽象类的实现。目录锁的实现使用缺省的SingleInstanceLockFactory，但是可以通过setLockFactory()方法修改。

  

 

 

   

5.1.4       org.apache.lucene.store.IndexInput

    

IndexInput类是一个为了从一个目录（Directory）中读取文件的抽象基类，是一个随机访问（random-access）的输入流（input stream），用于所有Lucene读取Index的操作。BufferedIndexInput是一个实现了带缓冲的IndexInput的基础实现。

  

 

   

5.1.5       org.apache.lucene.store.IndexOutput

    

IndexOutput类是一个为了写入文件到一个目录（Directory）中的抽象基类，是一个随机访问（random-access）的输出流（output stream），用于所有Lucene写入Index的操作。BufferedIndexOutput是一个实现了带缓冲的IndexOutput的基础实现。RAMOuputStream是一个内存驻留（memory-resident）的IndexOutput的实现类。