lucene原理及java实现【容易理解】

时间 2019-11-18

标签 lucene 原理 java 实现容易理解栏目 Java 繁體版

原文原文链接

转自：http://blog.csdn.net/liuhaiabc/article/details/52346493

1、Lucene是什么？

Lucene 是一个高效的，基于Java 的全文检索库。html

因此在了解Lucene以前要费一番工夫了解一下全文检索。java

那么什么叫作全文检索呢？这要从咱们生活中的数听说起。程序员

咱们生活中的数据整体分为两种：结构化数据和非结构化数据。算法

结构化数据：指具备固定格式或有限长度的数据，如数据库，元数据等。
非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等。

固然有的地方还会提到第三种，半结构化数据，如XML，HTML等，当根据须要可按结构化数据来处理，也可抽取出纯文本按非结构化数据来处理。数据库

非结构化数据又一种叫法叫全文数据。apache

按照数据的分类，搜索也分为两种：windows

对结构化数据的搜索：如对数据库的搜索，用SQL语句。再如对元数据的搜索，如利用windows搜索对文件名，类型，修改时间进行搜索等。
对非结构化数据的搜索：如利用windows的搜索也能够搜索文件内容，Linux下的grep命令，再如用Google和百度能够搜索大量内容数据。

对非结构化数据也即对全文数据的搜索主要有两种方法：app

一种是顺序扫描法 (Serial Scanning)：所谓顺序扫描，好比要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每个文档，从头看到尾，若是此文档包含此字符串，则此文档为咱们要找的文件，接着看下一个文件，直到扫描完全部的文件。如利用windows的搜索也能够搜索文件内容，只是至关的慢。若是你有一个80G硬盘，若是想在上面找到一个内容包含某字符串的文件，不花他几个小时，怕是作不到。Linux下的grep命令也是这一种方式。你们可能以为这种方法比较原始，但对于小数据量的文件，这种方法仍是最直接，最方便的。可是对于大量的文件，这种方法就很慢了。ide

有人可能会说，对非结构化数据顺序扫描很慢，对结构化数据的搜索却相对较快（因为结构化数据有必定的结构能够采起必定的搜索算法加快速度），那么把咱们的非结构化数据想办法弄得有必定结构不就好了吗？oop

这种想法很自然，却构成了全文检索的基本思路，也即将非结构化数据中的一部分信息提取出来，从新组织，使其变得有必定结构，而后对此有必定结构的数据进行搜索，从而达到搜索相对较快的目的。

这部分从非结构化数据中提取出的而后从新组织的信息，咱们称之索引。

这种说法比较抽象，举几个例子就很容易明白，好比字典，字典的拼音表和部首检字表就至关于字典的索引，对每个字的解释是非结构化的，若是字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息能够提取出来进行结构化处理，好比读音，就比较结构化，分声母和韵母，分别只有几种能够一一列举，因而将读音拿出来按必定的顺序排列，每一项读音都指向此字的详细解释的页数。咱们搜索时按结构化的拼音搜到读音，而后按其指向的页数，即可找到咱们的非结构化数据——也即对字的解释。

这种先创建索引，再对索引进行搜索的过程就叫全文检索(Full-text Search) 。

下面这幅图来自《Lucene in action》，但却不只仅描述了Lucene的检索过程，而是描述了全文检索的通常过程。

全文检索大致分两个过程，索引建立 (Indexing) 和搜索索引 (Search) 。

索引建立：将现实世界中全部的结构化和非结构化数据提取信息，建立索引的过程。
搜索索引：就是获得用户的查询请求，搜索建立的索引，而后返回结果的过程。

因而全文检索就存在三个重要问题：

1. 索引里面究竟存些什么？(Index)

2. 如何建立索引？(Indexing)

3. 如何对索引进行搜索？(Search)

下面咱们顺序对每一个个问题进行研究。

2、索引里面究竟存些什么

索引里面究竟须要存些什么呢？

首先咱们来看为何顺序扫描的速度慢：

实际上是因为咱们想要搜索的信息和非结构化数据中所存储的信息不一致形成的。

非结构化数据中所存储的信息是每一个文件包含哪些字符串，也即已知文件，欲求字符串相对容易，也便是从文件到字符串的映射。而咱们想搜索的信息是哪些文件包含此字符串，也即已知字符串，欲求文件，也即从字符串到文件的映射。二者偏偏相反。因而若是索引总可以保存从字符串到文件的映射，则会大大提升搜索速度。

因为从字符串到文件的映射是文件到字符串映射的反向过程，因而保存这种信息的索引称为反向索引。

反向索引的所保存的信息通常以下：

假设个人文档集合里面有100篇文档，为了方便表示，咱们为文档编号从1到100，获得下面的结构

左边保存的是一系列字符串，称为词典。

每一个字符串都指向包含此字符串的文档(Document)链表，此文档链表称为倒排表 (Posting List)。

有了索引，便使保存的信息和要搜索的信息一致，能够大大加快搜索的速度。

好比说，咱们要寻找既包含字符串“lucene”又包含字符串“solr”的文档，咱们只须要如下几步：

1. 取出包含字符串“lucene”的文档链表。

2. 取出包含字符串“solr”的文档链表。

3. 经过合并链表，找出既包含“lucene”又包含“solr”的文件。

看到这个地方，有人可能会说，全文检索的确加快了搜索的速度，可是多了索引的过程，二者加起来不必定比顺序扫描快多少。的确，加上索引的过程，全文检索不必定比顺序扫描快，尤为是在数据量小的时候更是如此。而对一个很大量的数据建立索引也是一个很慢的过程。

然而二者仍是有区别的，顺序扫描是每次都要扫描，而建立索引的过程仅仅须要一次，之后即是一劳永逸的了，每次搜索，建立索引的过程没必要通过，仅仅搜索建立好的索引就能够了。

这也是全文搜索相对于顺序扫描的优点之一：一次索引，屡次使用。

3、如何建立索引

全文检索的索引建立过程通常有如下几步：

第一步：一些要索引的原文档(Document)。

为了方便说明索引建立过程，这里特地用两个文件为例：

文件一：Students should be allowed to go out with their friends, but not allowed to drink beer.

文件二：My friend Jerry went to school to see his students but found them drunk which is not allowed.

第二步：将原文档传给分词器(Tokenizer)。

分词器(Tokenizer)会作如下几件事情( 此过程称为Tokenize) ：

1. 将文档分红一个一个单独的单词。

2. 去除标点符号。

3. 去除停词(Stop word) 。

所谓停词(Stop word)就是一种语言中最普通的一些单词，因为没有特别的意义，于是大多数状况下不能成为搜索的关键词，于是建立索引时，这种词会被去掉而减小索引的大小。

英语中停词(Stop word)如：“the”,“a”，“this”等。

对于每一种语言的分词组件(Tokenizer)，都有一个停词(stop word)集合。

通过分词(Tokenizer) 后获得的结果称为词元(Token) 。

在咱们的例子中，便获得如下词元(Token)：

“Students”，“allowed”，“go”，“their”，“friends”，“allowed”，“drink”，“beer”，“My”，“friend”，“Jerry”，“went”，“school”，“see”，“his”，“students”，“found”，“them”，“drunk”，“allowed”。

第三步：将获得的词元(Token)传给语言处理组件(Linguistic Processor)。

语言处理组件(linguistic processor)主要是对获得的词元(Token)作一些同语言相关的处理。

对于英语，语言处理组件(Linguistic Processor) 通常作如下几点：

1. 变为小写(Lowercase) 。

2. 将单词缩减为词根形式，如“cars ”到“car ”等。这种操做称为：stemming 。

3. 将单词转变为词根形式，如“drove ”到“drive ”等。这种操做称为：lemmatization 。

Stemming 和 lemmatization的异同：

相同之处：Stemming和lemmatization都要使词汇成为词根形式。
二者的方式不一样：
- Stemming采用的是“缩减”的方式：“cars”到“car”，“driving”到“drive”。
- Lemmatization采用的是“转变”的方式：“drove”到“drove”，“driving”到“drive”。
二者的算法不一样：
- Stemming主要是采起某种固定的算法来作这种缩减，如去除“s”，去除“ing”加“e”，将“ational”变为“ate”，将“tional”变为“tion”。
- Lemmatization主要是采用保存某种字典的方式作这种转变。好比字典中有“driving”到“drive”，“drove”到“drive”，“am, is, are”到“be”的映射，作转变时，只要查字典就能够了。
Stemming和lemmatization不是互斥关系，是有交集的，有的词利用这两种方式都能达到相同的转换。

语言处理组件(linguistic processor)的结果称为词(Term) 。

在咱们的例子中，通过语言处理，获得的词(Term)以下：

“student”，“allow”，“go”，“their”，“friend”，“allow”，“drink”，“beer”，“my”，“friend”，“jerry”，“go”，“school”，“see”，“his”，“student”，“find”，“them”，“drink”，“allow”。

也正是由于有语言处理的步骤，才能使搜索drove，而drive也能被搜索出来。

第四步：将获得的词(Term)传给索引组件(Indexer)。

索引组件(Indexer)主要作如下几件事情：

1. 利用获得的词(Term)建立一个字典。

在咱们的例子中字典以下：

Term	Document ID
student	1
allow	1
go	1
their	1
friend	1
allow	1
drink	1
beer	1
my	2
friend	2
jerry	2
go	2
school	2
see	2
his	2
student	2
find	2
them	2
drink	2
allow	2

2. 对字典按字母顺序进行排序。

Term	Document ID
allow	1
allow	1
allow	2
beer	1
drink	1
drink	2
find	2
friend	1
friend	2
go	1
go	2
his	2
jerry	2
my	2
school	2
see	2
student	1
student	2
their	1
them	2

3. 合并相同的词(Term) 成为文档倒排(Posting List) 链表。

在此表中，有几个定义：

Document Frequency 即文档频次，表示总共有多少文件包含此词(Term)。
Frequency 即词频率，表示此文件中包含了几个此词(Term)。

因此对词(Term) “allow”来说，总共有两篇文档包含此词(Term)，从而词(Term)后面的文档链表总共有两项，第一项表示包含“allow”的第一篇文档，即1号文档，此文档中，“allow”出现了2次，第二项表示包含“allow”的第二个文档，是2号文档，此文档中，“allow”出现了1次。

到此为止，索引已经建立好了，咱们能够经过它很快的找到咱们想要的文档。

并且在此过程当中，咱们惊喜地发现，搜索“drive”，“driving”，“drove”，“driven”也可以被搜到。由于在咱们的索引中，“driving”，“drove”，“driven”都会通过语言处理而变成“drive”，在搜索时，若是您输入“driving”，输入的查询语句一样通过咱们这里的一到三步，从而变为查询“drive”，从而能够搜索到想要的文档。

4、如何对索引进行搜索？

到这里彷佛咱们能够宣布“咱们找到想要的文档了”。

然而事情并无结束，找到了仅仅是全文检索的一个方面。不是吗？若是仅仅只有一个或十个文档包含咱们查询的字符串，咱们的确找到了。然而若是结果有一千个，甚至成千上万个呢？那个又是您最想要的文件呢？

打开Google吧，好比说您想在微软找份工做，因而您输入“Microsoft job”，您却发现总共有22600000个结果返回。好大的数字呀，忽然发现找不到是一个问题，找到的太多也是一个问题。在如此多的结果中，如何将最相关的放在最前面呢？

固然Google作的很不错，您一下就找到了jobs at Microsoft。想象一下，若是前几个所有是“Microsoft does a good job at software industry…”将是多么可怕的事情呀。

如何像Google同样，在成千上万的搜索结果中，找到和查询语句最相关的呢？

如何判断搜索出的文档和查询语句的相关性呢？

这要回到咱们第三个问题：如何对索引进行搜索？

搜索主要分为如下几步：

第一步：用户输入查询语句。

查询语句同咱们普通的语言同样，也是有必定语法的。

不一样的查询语句有不一样的语法，如SQL语句就有必定的语法。

查询语句的语法根据全文检索系统的实现而不一样。最基本的有好比：AND, OR, NOT等。

举个例子，用户输入语句：lucene AND learned NOT hadoop。

说明用户想找一个包含lucene和learned然而不包括hadoop的文档。

第二步：对查询语句进行词法分析，语法分析，及语言处理。

因为查询语句有语法，于是也要进行语法分析，语法分析及语言处理。

1. 词法分析主要用来识别单词和关键字。

如上述例子中，通过词法分析，获得单词有lucene，learned，hadoop, 关键字有AND, NOT。

若是在词法分析中发现不合法的关键字，则会出现错误。如lucene AMD learned，其中因为AND拼错，致使AMD做为一个普通的单词参与查询。

2. 语法分析主要是根据查询语句的语法规则来造成一棵语法树。

若是发现查询语句不知足语法规则，则会报错。如lucene NOT AND learned，则会出错。

如上述例子，lucene AND learned NOT hadoop造成的语法树以下：

3. 语言处理同索引过程当中的语言处理几乎相同。

如learned变成learn等。

通过第二步，咱们获得一棵通过语言处理的语法树。

第三步：搜索索引，获得符合语法树的文档。

此步骤有分几小步：

首先，在反向索引表中，分别找出包含lucene，learn，hadoop的文档链表。
其次，对包含lucene，learn的链表进行合并操做，获得既包含lucene又包含learn的文档链表。
而后，将此链表与hadoop的文档链表进行差操做，去除包含hadoop的文档，从而获得既包含lucene又包含learn并且不包含hadoop的文档链表。
此文档链表就是咱们要找的文档。

第四步：根据获得的文档和查询语句的相关性，对结果进行排序。

虽然在上一步，咱们获得了想要的文档，然而对于查询结果应该按照与查询语句的相关性进行排序，越相关者越靠前。

如何计算文档和查询语句的相关性呢？

不如咱们把查询语句看做一片短小的文档，对文档与文档之间的相关性(relevance)进行打分(scoring)，分数高的相关性好，就应该排在前面。

那么又怎么对文档之间的关系进行打分呢？这可不是一件容易的事情！

下面看一下如何判断文档之间的关系：

首先，一个文档有不少词(Term)组成，如search, lucene, full-text, this, a, what等。

其次对于文档之间的关系，不一样的Term重要性不一样，好比对于本篇文档，search, Lucene, full-text就相对重要一些，this, a , what可能相对不重要一些。因此若是两篇文档都包含search, Lucene，fulltext，这两篇文档的相关性好一些，然而就算一篇文档包含this, a, what，另外一篇文档不包含this, a, what，也不能影响两篇文档的相关性。

于是判断文档之间的关系，首先找出哪些词(Term)对文档之间的关系最重要，如search, Lucene, fulltext。而后判断这些词(Term)之间的关系。

找出词(Term) 对文档的重要性的过程称为计算词的权重(Term weight) 的过程。

计算词的权重(term weight)有两个参数，第一个是词(Term)，第二个是文档(Document)。

词的权重(Term weight)表示此词(Term)在此文档中的重要程度，越重要的词(Term)有越大的权重(Term weight)，于是在计算文档之间的相关性中将发挥更大的做用。

判断词(Term) 之间的关系从而获得文档相关性的过程应用一种叫作向量空间模型的算法(Vector Space Model) 。

下面仔细分析一下这两个过程：

1. 计算权重(Term weight)的过程。

影响一个词(Term)在一篇文档中的重要性主要有两个因素：

Term Frequency (tf)：即此Term在此文档中出现了多少次。tf 越大说明越重要。
Document Frequency (df)：即有多少文档包含次Term。df 越大说明越不重要。

容易理解吗？词(Term)在文档中出现的次数越多，说明此词(Term)对该文档越重要，如“搜索”这个词，在本文档中出现的次数不少，说明本文档主要就是讲这方面的事的。然而在一篇英语文档中，this出现的次数更多，就说明越重要吗？不是的，这是由第二个因素进行调整，第二个因素说明，有越多的文档包含此词(Term), 说明此词(Term)太普通，不足以区分这些文档，于是重要性越低。

这也如咱们程序员所学的技术，对于程序员自己来讲，这项技术掌握越深越好（掌握越深说明花时间看的越多，tf越大），找工做时越有竞争力。然而对于全部程序员来讲，这项技术懂得的人越少越好（懂得的人少df小），找工做越有竞争力。人的价值在于不可替代性就是这个道理。

道理明白了，咱们来看看公式：

这仅仅只term weight计算公式的简单典型实现。实现全文检索系统的人会有本身的实现，Lucene就与此稍有不一样。

2. 判断Term之间的关系从而获得文档相关性的过程，也即向量空间模型的算法(VSM)。

咱们把文档看做一系列词(Term)，每个词(Term)都有一个权重(Term weight)，不一样的词(Term)根据本身在文档中的权重来影响文档相关性的打分计算。

因而咱们把全部此文档中词(term)的权重(term weight) 看做一个向量。

Document = {term1, term2, …… ,term N}

Document Vector = {weight1, weight2, …… ,weight N}

一样咱们把查询语句看做一个简单的文档，也用向量来表示。

Query = {term1, term 2, …… , term N}

Query Vector = {weight1, weight2, …… , weight N}

咱们把全部搜索出的文档向量及查询向量放到一个N维空间中，每一个词(term)是一维。

如图：

咱们认为两个向量之间的夹角越小，相关性越大。

因此咱们计算夹角的余弦值做为相关性的打分，夹角越小，余弦值越大，打分越高，相关性越大。

有人可能会问，查询语句通常是很短的，包含的词(Term)是不多的，于是查询向量的维数很小，而文档很长，包含词(Term)不少，文档向量维数很大。你的图中二者维数怎么都是N呢？

在这里，既然要放到相同的向量空间，天然维数是相同的，不一样时，取两者的并集，若是不含某个词(Term)时，则权重(Term Weight)为0。

5、java实现

目前Lucene已经更新到6.5版本，自从4.9版本就须要1.7以上的JDK，因此若是还用1.6甚至是1.5的小盆友，请参考低版本，因为我用的1.7，所以在使用Lucene5.5。

废话很少说直接上实现的代码，里面包含注解:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;

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.Store;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.poi.POIXMLDocument;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;

public class LuceneTest {
private static LuceneTest indexManager;
private static String content="";
private static String INDEX_DIR = "e:\\luceneIndex";
private static String DATA_DIR = "e:\\luceneData";
private static Analyzer analyzer = null;
private static Directory directory = null;
private static IndexWriter indexWriter = null;

public static void main(String[] arg){
File fileIndex = new File(INDEX_DIR);
if(deleteDir(fileIndex)){
fileIndex.mkdir();
}else{
fileIndex.mkdir();
}
createIndex(DATA_DIR);
searchIndex("man");
}

/**
* 建立当前文件目录的索引
* @param path 当前文件目录
* @return 是否成功
*/
public static boolean createIndex(String path){

  Date date1 = new Date();
List<File> fileList = getFileList(path);
for (File file : fileList) {
  content = "";
//获取文件后缀
String type = file.getName().substring(file.getName().lastIndexOf(".")+1);
if("txt".equalsIgnoreCase(type)){
content += txt2String(file);
}else if("doc".equalsIgnoreCase(type)){
content += doc2String(file);
}else if("xls".equalsIgnoreCase(type)){
content += xls2String(file);
}
System.out.println("name :"+file.getName());
System.out.println("path :"+file.getPath());
System.out.println("content :"+content);
System.out.println();

try{
  //词法分析器Analyzer
  analyzer = new StandardAnalyzer();
  //本地文件存储
directory = FSDirectory.open(Paths.get(INDEX_DIR));
//内存存储
//Directory directory = new RAMDirectory();

File indexFile = new File(INDEX_DIR);
if (!indexFile.exists()) {
indexFile.mkdirs();
}
//建立IndexWriter，进行索引文件的写入
IndexWriterConfig config = new IndexWriterConfig(analyzer);
indexWriter = new IndexWriter(directory, config);

//内容提取，进行索引的存储。
Document document = new Document();
document.add(new TextField("filename", file.getName(), Store.YES));
document.add(new TextField("content", content, Store.YES));
document.add(new TextField("path", file.getPath(), Store.YES));
indexWriter.addDocument(document);
indexWriter.commit();
closeWriter();
}catch(Exception e){
  e.getStackTrace();
}

}
Date date2 = new Date();
System.out.println("建立索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
return true;
}
/**
* 查找索引，返回符合条件的文件
* @param text 查找的字符串
* @return 符合条件的文件List
*/
public static void searchIndex(String text){
  Date date1 = new Date();
try{
  //打开存储位置
directory = FSDirectory.open(Paths.get(INDEX_DIR));
analyzer = new StandardAnalyzer();
DirectoryReader ireader = DirectoryReader.open(directory);
//建立搜索器
IndexSearcher isearcher = new IndexSearcher(ireader);

QueryParser parser = new QueryParser("content", analyzer);
Query query = parser.parse(text);

ScoreDoc[] hits = isearcher.search(query, null, 1000).scoreDocs;

for (int i = 0; i < hits.length; i++) {
Document hitDoc = isearcher.doc(hits[i].doc);
System.out.println("____________________________");
System.out.println(hitDoc.get("filename"));
System.out.println(hitDoc.get("content"));
System.out.println(hitDoc.get("path"));
System.out.println("____________________________");
}
ireader.close();
directory.close();
}catch(Exception e){
e.printStackTrace();
}
Date date2 = new Date();
System.out.println("查看索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
}
/**
* 删除文件目录下的全部文件
* @param file 要删除的文件目录
* @return 若是成功，返回true.
*/
public static boolean deleteDir(File file){
if(file.isDirectory()){
File[] files = file.listFiles();
for(int i=0; i<files.length; i++){
deleteDir(files[i]);
}
}
file.delete();
return true;
}
/**
* 过滤目录下的文件
* @param dirPath 想要获取文件的目录
* @return 返回文件list
*/
public static List<File> getFileList(String dirPath) {
File[] files = new File(dirPath).listFiles();
List<File> fileList = new ArrayList<File>();
for (File file : files) {
if (isTxtFile(file.getName())) {
fileList.add(file);
}
}
return fileList;
}
/**
* 判断是否为目标文件，目前支持txt xls doc格式
* @param fileName 文件名称
* @return 若是是文件类型知足过滤条件，返回true；不然返回false
*/
public static boolean isTxtFile(String fileName) {
if (fileName.lastIndexOf(".txt") > 0) {
return true;
}else if (fileName.lastIndexOf(".xls") > 0) {
return true;
}else if (fileName.lastIndexOf(".doc") > 0) {
return true;
}
return false;
}
/**
* 读取txt文件的内容
* @param file 想要读取的文件对象
* @return 返回文件内容
*/
public static String txt2String(File file){
String result = "";
try{
BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
String s = null;
while((s = br.readLine())!=null){//使用readLine方法，一次读一行
result = result + "\n" +s;
}
br.close();
}catch(Exception e){
e.printStackTrace();
}
return result;
}
/**
* 读取doc文件内容
* @param file 想要读取的文件对象
* @return 返回文件内容
*/
public static String doc2String(File file){
String result = "";
try{
FileInputStream fis = new FileInputStream(file);
//适合office2007以上
OPCPackage pack = POIXMLDocument.openPackage(file.getPath());
XWPFDocument docx = new XWPFDocument(pack) ;
List<XWPFParagraph> paras = docx.getParagraphs();
for (XWPFParagraph para : paras) {
  result += para.getText().trim();
}
//只适合office2003
// HWPFDocument doc = new HWPFDocument(fis);
// Range rang = doc.getRange();
// result += rang.text();
// fis.close();
}catch(Exception e){
e.printStackTrace();
}
return result;
}
/**
* 读取xls文件内容
* @param file 想要读取的文件对象
* @return 返回文件内容
*/
public static String xls2String(File file){
String result = "";
try{
FileInputStream fis = new FileInputStream(file);
StringBuilder sb = new StringBuilder();
jxl.Workbook rwb = Workbook.getWorkbook(fis);
Sheet[] sheet = rwb.getSheets();
for (int i = 0; i < sheet.length; i++) {
Sheet rs = rwb.getSheet(i);
for (int j = 0; j < rs.getRows(); j++) {
Cell[] cells = rs.getRow(j);
for(int k=0;k<cells.length;k++)
sb.append(cells[k].getContents());
}
}
fis.close();
result += sb.toString();
}catch(Exception e){
e.printStackTrace();
}
return result;
}
public static void closeWriter() throws Exception {
if (indexWriter != null) {
indexWriter.close();
}
}

/**
* 建立索引管理器
* @return 返回索引管理器对象
*/
public LuceneTest getManager(){
if(indexManager == null){
this.indexManager = new LuceneTest();
}
return indexManager;
}

}

要上传jar包以下图：

6、内存索引库和文件索引库结合

在lucene索引库的建立的时候，咱们有两种不一样的索引库建立方式

1.文件索引库

final Path docDir = Paths. get ( "index" );

Directory directory=FSDirectory.open(Paths.get("index"));

这样建立的索引库是在本地磁盘上建立一个 index文件夹，而且将索引放在 index中，也称为文件索引库
优势：将索引持久化到磁盘上，能长久保存。
缺点：相比较内存索引库，读取慢

2.内存索引

Directory directory = new RAMDirectory();

只须要一句代码，就建立了一个内存索引库
优势：读取快
缺点：不具有持久化能力，结束时候内存索引库便会删除

3.两种索引库的结合

根据两种索引库的特色咱们能够将两种索引库结合起来，设计的思路是在程序启动时，将文件索引库中的索引拷贝到内存索引库中，而后让程序与内存索引库交互，当交互完毕后再将内存索引库的索引持久化到文件索引库。

/**
* 1.建立两个索引库
* 2.建立两个IndexWriter
* 3.把文件索引库中的内容放到内存索引库中
* 4.让内存索引库和客户端进行交互
* 5.把内存索引库的内容放到文件索引库
*/
final Path docDir = Paths.get("index");
//建立文件索引库
Directory fileDirectory=FSDirectory.open(Paths.get("index"));
//建立内存索引库
Directory ramDirectory = new RAMDirectory(FSDirectory.open(Paths.get("index")), null);

Analyzer analyzer = new StandardAnalyzer();
IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
//操做文件的IndexWriter
IndexWriter fileIndexWriter = new IndexWriter(fileDirectory, iwc);
//操做内存的IndexWriter
Analyzer analyzer1 = new StandardAnalyzer();
IndexWriterConfig iwc1 = new IndexWriterConfig(analyzer1);
IndexWriter ramIndexWriter=new IndexWriter(ramDirectory, iwc1);

Article article = new Article();
article.setAid(1L);
article.setTitle("lucene是一个全文检索引擎");
article.setContent("baidu,google都是很好的全文检索引擎");

// 建立document
Document document = new Document();
Field idField = new Field("aid", article.getAid().toString(),
TextField.TYPE_STORED);
Field titleField = new Field("title", article.getTitle().toString(),
TextField.TYPE_STORED);
Field contentField = new Field("content", article.getContent()
.toString(), TextField.TYPE_STORED);
document.add(idField);
document.add(titleField);
document.add(contentField);

//把document放到内存当中 ramIndexWriter.addDocument(document); ramIndexWriter.close(); //把内存索引库的内容合并到文件索引库 fileIndexWriter.addIndexes(ramDirectory); fileIndexWriter.close();

	t1	t2	t3	t4	t5	t6	t7	t8	t9	t10	t11
D1	0	0	.477	0	.477	.176	0	0	0	.176	0
D2	0	.176	0	.477	0	0	0	0	.954	0	.176
D3	0	.176	0	0	0	.176	0	0	0	.176	.176
Q	0	0	0	0	0	.176	0	0	.477	0	.176