Lucence.net索引技术 一

1、建立索引 

为了对文档进行索引，Lucene 提供了五个基础的类，他们分别是 Document, Field, IndexWriter, Analyzer, Directory。下面我们分别介绍一下这五个类的用途：

Document

Document 是用来描述文档的，这里的文档可以指一个 HTML 页面，一封电子邮件，或者是一个文本文件。一个 Document 对象由多个 Field 对象组成的。可以把一个 Document 对象想象成数据库中的一个记录，而每个 Field 对象就是记录的一个字段。

Field

Field 对象是用来描述一个文档的某个属性的，比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。 

Analyzer

在一个文档被索引之前，首先需要对文档内容进行分词处理，这部分工作就是由 Analyzer 来做的。Analyzer 类是一个抽象类，它有多个实现。针对不同的语言和应用需要选择适合的 Analyzer。Analyzer 把分词后的内容交给 IndexWriter 来建立索引。 

IndexWriter 

IndexWriter 是 Lucene 用来创建索引的一个核心的类，他的作用是把一个个的 Document 对象加到索引中来。

Directory 

这个类代表了 Lucene 的索引的存储的位置，这是一个抽象类，它目前有两个实现，第一个是 FSDirectory，它表示一个存储在文件系统中的索引的位置。第二个是 RAMDirectory，它表示一个存储在内存当中的索引的位置。

熟悉了建立索引所需要的这些类后，我们就开始对某个目录下面的文本文件建立索引了，清单1给出了对某个目录下的文本文件建立索引的源代码。

清单 1. 对文本文件建立索引

package TestLucene;

import java.io.File;

import java.io.FileReader;

import java.io.Reader;

import java.util.Date;

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

/**

 * This class demonstrate the process of creating index with Lucene

 * for text files

 */

public class TxtFileIndexer {

         public static void main(String[] args) throws Exception{

                   //indexDir is the directory that hosts Lucene‘s index files

        File   indexDir = new File("D://luceneIndex");

        //dataDir is the directory that hosts the text files that to be indexed

        File   dataDir  = new File("D://luceneData");

        Analyzer luceneAnalyzer = new StandardAnalyzer();

        File[] dataFiles  = dataDir.listFiles();

        IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);

        long startTime = new Date().getTime();

        for(int i = 0; i < dataFiles.length; i++){

                 if(dataFiles[i].isFile() && dataFiles[i].getName().endsWith(".txt")){

                           System.out.println("Indexing file " + dataFiles[i].getCanonicalPath());

                           Document document = new Document();

                           Reader txtReader = new FileReader(dataFiles[i]);

                           document.add(Field.Text("path",dataFiles[i].getCanonicalPath()));

                           document.add(Field.Text("contents",txtReader));

                           indexWriter.addDocument(document);

                 }

        }

        indexWriter.optimize();

        indexWriter.close();

        long endTime = new Date().getTime();

        System.out.println("It takes " + (endTime - startTime)

                           + " milliseconds to create index for the files in directory "

                                      + dataDir.getPath());       

         }

}

在清单1中，我们注意到类 IndexWriter 的构造函数需要三个参数，第一个参数指定了所创建的索引要存放的位置，他可以是一个 File 对象，也可以是一个 FSDirectory 对象或者 RAMDirectory 对象。第二个参数指定了 Analyzer 类的一个实现，也就是指定这个索引是用哪个分词器对文挡内容进行分词。第三个参数是一个布尔型的变量，如果为 true 的话就代表创建一个新的索引，为 false 的话就代表在原来索引的基础上进行操作。接着程序遍历了目录下面的所有文本文档，并为每一个文本文档创建了一个 Document 对象。然后把文本文档的两个属性：路径和内容加入到了两个 Field 对象中，接着在把这两个 Field 对象加入到 Document 对象中，最后把这个文档用 IndexWriter 类的 add 方法加入到索引中去。这样我们便完成了索引的创建。接下来我们进入在建立好的索引上进行搜索的部分。

2、搜索文档

利用Lucene进行搜索就像建立索引一样也是非常方便的。在上面一部分中，我们已经为一个目录下的文本文档建立好了索引，现在我们就要在这个索引上进行搜索以找到包含某个关键词或短语的文档。Lucene提供了几个基础的类来完成这个过程，它们分别是呢IndexSearcher, Term, Query, TermQuery, Hits. 下面我们分别介绍这几个类的功能。

Query

这是一个抽象类，他有多个实现，比如TermQuery, BooleanQuery, PrefixQuery. 这个类的目的是把用户输入的查询字符串封装成Lucene能够识别的Query。

Term

Term是搜索的基本单位，一个Term对象有两个String类型的域组成。生成一个Term对象可以有如下一条语句来完成：Term term = new Term(“fieldName”,”queryWord”); 其中第一个参数代表了要在文档的哪一个Field上进行查找，第二个参数代表了要查询的关键词。

TermQuery

TermQuery是抽象类Query的一个子类，它同时也是Lucene支持的最为基本的一个查询类。生成一个TermQuery对象由如下语句完成：

TermQuery termQuery = new TermQuery(new Term(“fieldName”,”queryWord”));

它的构造函数只接受一个参数，那就是一个Term对象。

IndexSearcher 

IndexSearcher是用来在建立好的索引上进行搜索的。它只能以只读的方式打开一个索引，所以可以有多个IndexSearcher的实例在一个索引上进行操作。

Hits

Hits是用来保存搜索的结果的。

介绍完这些搜索所必须的类之后，我们就开始在之前所建立的索引上进行搜索了，清单2给出了完成搜索功能所需要的代码。

清单2 ：在建立好的索引上进行搜索

package TestLucene;

import java.io.File;

import org.apache.lucene.document.Document;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.TermQuery;

import org.apache.lucene.store.FSDirectory;

/**

 * This class is used to demonstrate the

 * process of searching on an existing

 * Lucene index

 *

 */

public class TxtFileSearcher {

         public static void main(String[] args) throws Exception{

             String queryStr = "lucene";

             //This is the directory that hosts the Lucene index

        File indexDir = new File("D://luceneIndex");

        FSDirectory directory = FSDirectory.getDirectory(indexDir,false);

        IndexSearcher searcher = new IndexSearcher(directory);

        if(!indexDir.exists()){

                 System.out.println("The Lucene index is not exist");

                 return;

        }

        Term term = new Term("contents",queryStr.toLowerCase());

        TermQuery luceneQuery = new TermQuery(term);

        Hits hits = searcher.search(luceneQuery);

        for(int i = 0; i < hits.length(); i++){

                 Document document = hits.doc(i);

                 System.out.println("File: " + document.get("path"));

        }

         }

}

在清单2中，类IndexSearcher的构造函数接受一个类型为Directory的对象，Directory是一个抽象类，它目前有两个子类：FSDirctory和RAMDirectory. 我们的程序中传入了一个FSDirctory对象作为其参数，代表了一个存储在磁盘上的索引的位置。构造函数执行完成后，代表了这个IndexSearcher以只读的方式打开了一个索引。然后我们程序构造了一个Term对象，通过这个Term对象，我们指定了要在文档的内容中搜索包含关键词”lucene”的文档。接着利用这个Term对象构造出TermQuery对象并把这个TermQuery对象传入到IndexSearcher的search方法中进行查询，返回的结果保存在Hits对象中。最后我们用了一个循环语句把搜索到的文档的路径都打印了出来。

好了，我们的搜索应用程序已经开发完毕，怎么样，利用Lucene开发搜索应用程序是不是很简单。

• IndexSearcher——该对象内包含了很多search方法的重载，搜素一个索引，主要就是使用该对象的实例。
• Query——该类是一个抽象类，其派生类产生的对象，是对各种形式搜索的封装。
  • TermQuery——匹配那些包含单个查询词语（term）的文档。可以使用BooleanQuery进行组合。
  • BooleanQuery——匹配由其他查询（TermQuery或PhraseQuery或者BooleanQuery）布尔组合后形成的查询的文档。
  • FuzzyQuery——模糊查询。
  • RangeQuery——范围查询。
  • 还有很多……
• QueryParser——将人类语言翻译成上述某种Query对象。
• TopDocs——搜索结果的容器。TopFieldDocs是其派生类，也是存放搜索结果的容器。
• 
  

Lucene是允许对索引的并发操作的，具体操作时，要遵循三条简单而严格的规则：

• 任意数量只读操作可以并行。
• 对于一个处于写状态的索引来说，也允许任意只读操作并行。
• 索引的写操作不可以并行，只能有一个实例线程修改索引。

Lucene的并发规则非常简单，而且，这样的规则基本符合我们的直觉思维，因而非常容易记忆。事实上，Lucene并不强制遵守这些规则，但是违背规则，将带来不可预测的风险，例如索引损坏。

实际操作中，一个好的做法是对于执行写操作的对象，使其单一实例化，也就是使用Singleton设计模式。Lucene的索引操作对象，都被设计为线程安全的形式，多个线程可以直接调用，而不需要额外的同步操作。这一点相当体贴。

实际上，可能没有人会故意去不遵守Lucene的并发规则，造成这样的状况，往往是意外，所以，Lucene提供了一套锁，来保护索引。

Lucene的锁以文件的形式保存在磁盘上，一共有两种锁，一种是write.lock，另一种是commit.lock。

要完成最基本的搜索过程，Lucene需要以下几个对象的合作：

• IndexSearcher——这个对象主要用来检索IndexWriter生成的索引文件，所以IndexSearcher构造的时候，使用一个包含了索引所在目录的Directory对象来构造。IndexSearcher提供的是一种对索引文件的只读访问，里面提供了多种搜索方法。在我第一次的笔记里代码中用到的search方法，接受一个Query对象和一个HitCollector对象，返回值为空。搜索结果被填充到 HitCollector中。
• Term——该对象是一个和Field相似的对象，包含一个名字和值对。但是目前，在代码里还没有遇到过这个对象，虽然书里提到在建立索引和搜索的过程中都会用到这个东西，但是实际上，我并没有看到。
• Query——Query类是一个抽象类，在Lucene的内部有许多的实现，虽然说，书中也提到了最基本的Query是TermQuery，但是看了看内部的代码，在笔记1中提到的代码内部，实际上用到是BooleanQuery，而不是TermQuery。
• TermQuery——最基本的Query，上面也提到了，用来匹配文档中包含的特定的域的特定的值，暂时也没有碰到过。
• Hits——这个对象本来应该是一个简单的容器，用来包含搜索得到的排序结果的，但是实际上，在笔记1中的代码里，已经看不到这个东西了，Lucene已经不推荐使用这个东西，现在用到的东西是HitCollector似乎是一个更高级的容器了，在代码中我们看到，我们从这个对象中去除了一个Document的数组，包含的元素正是搜索结果。
• QueryParser——这个对象在书中没有提到，实际上，我觉得必须要有的，本质上就是把一个字符串转换成一个Query对象，实际上，这个东西应该是设计得非常的复杂的，因为搜索引擎一般都提供了很丰富的搜索语法，Lucene也是一样的。构造QueryParser的时候，还可以指定专门的Analyzer。

使用Lucene建立索引，有三个主要步骤。

提取文本。Lucene只能对纯文本建立索引，所以，任何需要建立索引的资料，都要进行过滤处理，从中提取到纯文本。比如对于Word和PDF，我们都要使用相关API将其中的纯文本提取出来，而对于XML和HTML，则意味着要过滤掉所有的tag。

文本分析。要建立索引，首先要将文本分解成一个个片段，一般就是单词，当然也可能是词组，句子等。分割好的东西，可能还要进行归一化处理，以确保最大程度上的检索能力，比如，全部变成小写字母，以后搜索的时候，就能忽略大小写。这个过程对于字母文字，有个步骤，就是回归原型，像英文、德文、法文这些我稍微有点了解的语言里，一般都有“数”，“格”，“态”的变化，而同一个词的变化形式，应该被视为是一个词，而不是不同的词。对于汉语这样的没有变形的语言，这方面就非常方便了，但是汉语却有着另一个不方便的地方，就是汉语的最小单位不是字，而是词。也即汉语需要进行分词处理。英文单词使用空格分隔，分词要简单得多得多。除却这些步骤，还有一个共同的步骤就是删除stop words，简单说就是无意义词，一般来说就是数词，量词，助词，介词，代词等等虚词。

将索引写入磁盘。Lucene将分析好的文本使用一种叫做倒排索引的数据结构写入到磁盘中。倒排索引（inverted index）的建立，完全是为了搜索的方便。如果说，“正排索引”可以回答你一个问题，“这个文档中，包含了哪些关键词？”，那么“倒排索引”回答了你一个相反的问题，就是“哪些文档，包含了关键词X？”。倒排索引是当今所有主流搜索引擎的核心结构，而这些搜索引擎之所以不同，是因为在建立倒排索引时所附加的独特的参数，比如著名的Google PageRank。这些参数决定了最终搜索结果的排序。

要完成最基本的建立索引的过程，Lucene需要以下几个对象的合作：

• IndexWriter——Lucene内部用来创建索引的最重要的组件。可以创建新索引，或者从文档增量地创建索引。
• Directory——Directory是一个抽象类，用于表达索引存放的目录，在lucene内部提供了两个实现，一个是FSDirectory，一个是RAMDirectory，顾名思义了。Directory可能在内部提供了锁的机制，使得建立索引和搜索可以同时进行。
• Analyzer——又是一个抽象类，是IndexWriter的构成组件之一，主要用来分析文本，包括分词，去除stop words等等功能。在构建一个项目的时候，选取或者创建正确的分析器是至关重要的。
• Document——是Lucene处理的对象，一个Document是一组Field的集合
• Field——Lucene建立的索引中，每个Document都包含一个或者多个命名的域，被包装在Field类中，Field有多种的类型，Keyword，UnIndexed，Unstored，Text

按照书中的说法，在进行一个最简单的建立索引的过程时候，必须要用到这几个类，但是上一次的笔记中，我也帖了我敲的代码，貌似则个 Directory是没有直接在Indexer的代码中提到的，不过，我进IndexWriter的构造函数看了一下，其实是用到的，如果我们在构造一个 IndexWriter的时候，没有传递一个Directory给它，而是只传了一个路径，那么会默认使用FSDirectory对像的，这是一种使用了简单锁机制的Directory对象。

 来源：http://blog.csdn.net/liuzhenwen/article/details/4463261