全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程。
对于搜索，按被搜索的资源类型，分为两种：可以分为文本类型和多媒体类型。
全文检索(Full-Text Retrieval)是指以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。
关于全文检索，我们要知道：
1，只处理文本。
2，不处理语义。
3，搜索时英文不区分大小写。
4，结果列表有相关度排序。
在信息检索工具中，全文检索是最具通用性和实用性的。
全文检索与数据库搜索
全文检索不同于数据库的SQL查询。(他们所解决的问题不一样，解决的方案也不一样，所以不应进行对比)。在数据库中的搜索就是使用SQL，如：SELECT * FROM t WHERE content like ‘%ant%’。
这样会有如下问题：
1，匹配效果：如搜索ant会搜索出planting。这样就会搜出很多无关的信息。
2，相关度排序：查出的结果没有相关度排序，不知道我想要的结果在哪一页。我们在使用百度搜索时，一般不需要翻页，为什么？因为百度做了相关度排序：为每一条结果打一个分数，这条结果越符合搜索条件，得分就越高，叫做相关度得分，结果列表会按照这个分数由高到低排列，所以第1页的结果就是我们最想要的结果。
3，全文检索的速度大大快于SQL的like搜索的速度。这是因为查询方式不同造成的，以查字典举例：数据库的like就是一页一页的翻，一行一行的找，而全文检索是先查目录，得到结果所在的页码，再直接翻到这一页。
Lucene简介
全文检索就如同ORM，是一个概念。ORM的框架有很多种：Hibernate、TopLink、iBatis等，我们之前学习的是Hibernate。同样的，全文检索领域中也有多种框架，Lucene就是其中的一个用开源的全文检索框架。
Lucene的主页为：http://lucene.apache.org/
如果信息检索系统在用户发出了检索请求后再去互联网上找答案，根本无法在有限的时间内返回结果。所以要先把要检索的资源集合放到本地，并使用某种特定的结构存储，称为索引，这个索引的集合称为索引库。由于索引库的结构是按照专门为快速查询设计的，所以查询的速度非常快。我们每次搜索都是在本地的索引库中进行。对于全文检索功能的开发，我们要做的有两个方面：索引库管理(维护索引库中的数据)、在索引库中进行搜索。而Lucene就是操作索引库的工具。
索引库是一个目录，里面是一些二进制文件，就如同数据库，所有的数据也是以文件的形式存在文件系统中的。我们不能直接操作这些二进制文件，而是使用Lucene提供的API完成相应的操作，就像操作数据库应使用SQL语句一样。
对索引库的操作可以分为两种：管理与查询。管理索引库使用IndexWriter，从索引库中查询使用IndexSearcher。Lucene的数据结构为Document与Field。Document代表一条数据，Field代表数据中的一个属性。一个Document中有多个Field，Field的值为String型，因为Lucene只处理文本。
我们只需要把在我们的程序中的对象转成Document，就可以交给Lucene管理了，搜索的结果中的数据列表也是Document的集合。
我们需要对文档进行预处理，建立一种便于检索的数据结构，以此来提高信息检索的速度，这种数据结构就是索引。目前广泛使用的一种索引方式是倒排序索引 。
倒排序索引的原理就如同查字典。要先查目录，得到数据对应的页码，在直接翻到指定的页码。不是在文章中找词，而是从目录中找词所在的文章。这需要在索引库中生成一个词汇表(目录)，在词汇表中的每一个条记录都是类似于“词所在文档的编号列表”的结构，记录了每一个出现过的单词，和单词出现的地方(哪些文档)。查询时先查词汇表，得到文档的编号，再直接取出相应的文档。
把数据转成指定格式放到索引库中的操作叫做建立索引。建立索引时，在把数据存到索引库后，再更新词汇表。进行搜索时，先从检索词汇表开始，然后找到相对应的文档。如果查询中仅包含一个关键词，则在词汇表中找到该单词，并取出他对应的文档就可以了。如果查询中包含多个关键词，则需要将各个单词检索出的记录进行合并再取出相应的文档记录。
如果词汇表中有一个词“德玛西亚”对应的文档编号列表为“1”。现在又有添加了一个包含“德玛西亚”的文档，则词汇表中的“德玛西亚”词后对应的编号列表变成了“1,2”。因为关键词的数量受实际语言的限制，所以不用担心词汇表会变的很大。
维护倒排索引有三个操作：添加、删除和更新文档。但是更新操作需要较高的代价。因为文档修改后(即使是很小的修改)，就可能会造成文档中的很多的关键词的位置都发生了变化，这就需要频繁的读取和修改记录，这种代价是相当高的。因此，一般不进行真正的更新操作，而是使用“先删除，再创建”的方式代替更新操作。
Lucene的程序开发
1，jar包下载
登陆http://lucene.apache.org/找到你所需要的包进行下载。
目前最新的版本到6.x本，个人之前有个3.x版本就没有从新下载。
下载后解压的目录图
搭建Lucene的开发环境需要的最少Jar包：
lucene-core-3.0.1.jar(核心包)
contrib\analyzers\common\lucene-analyzers-3.0.1.jar(分词器)
contrib\highlighter\lucene-highlighter-3.0.1.jar(高亮)
contrib\memory\lucene-memory-3.0.1.jar(高亮)
建立索引的执行过程
1，我们做的操作：把数据对象转成相应的Document，其中的属性转为Field。
2，我们做的操作：调用工具IndexWriter的addDocument(doc)，把Document添加到索引库中。
3，Lucene做的操作：把文档存到索引库中，并自动指定一个内部编号，用来唯一标识这条数据。内部编号类似于这条数据的地址，在索引库内部的数据进行调整后，这个编号就可能会改变，同时词汇表中引用的编号也会做相应改变，以保证正确。但我们如果在外面引用了这个编号，前后两次去取，得到的可能不是同一个文档！所以内部编号最好只在内部用。
4，Lucene做的操作：更新词汇表。把文本中的词找出并放到词汇表中，建立与文档的对应关系。要把哪些词放到词汇表中呢，也就是文本中包含哪些词呢？这就用到了一个叫做Analyzer(分词器)的工具。他的作用是把一段文本中的词按规则取出所包含的所有词。对应的是Analyzer类，这是一个抽象类，切分词的具体规则是由子类实现的，所以对于不同的语言(规则)，要用不同的分词器。
从索引库中搜索的执行过程
1， 把要查询字符串转为Query对象。这就像在Hibernate中使用HQL查询时，也要先调用Session.createQuery(hql)转成Hibernate的Query对象一样。把查询字符串转换成Query是使用QueryParser，或使用MultiFieldQueryParser。查询字符串也要先经过Analyzer(分词器)。要求搜索时使用的Analyzer要与建立索引时使用的Analzyer要一致，否则可能搜不出正确的结果。
2， 调用IndexSearcher.search()，进行查询，得到结果。此方法返回值为TopDocs，是包含结果的多个信息的一个对象。其中有totalHits 代表决记录数，ScoreDoc的数组。ScoreDoc是代表一个结果的相关度得分与文档编号等信息的对象。
3， 取出要用到的数据列表。调用IndexSearcher.doc(scoreDoc.doc)以取出指定编号对应的Document数据。在分页时要用到：一次只取一页的数据。
代码示例：
Article.java
package com.my.bean;
public class Article {
private Integer id;
private String title;
private String content;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
HelloWord.java
package com.my.lucene;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
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.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;
import com.my.bean.Article;
public class HelloWord {
// 建立索引(模拟在贴吧中发表了一个文章，会保存到数据库中，并且应该建立索引，以便能搜索到)
@Test
public void createIndex() throws Exception {
// 模拟一条刚保存到数据库中的数据
Article article = new Article();
article.setId(1);
article.setTitle("Lucene是全文检索的框架");
article.setContent("如果信息检索系统在用户发出了检索请求后再去互联网上找答案，根本无法在有限的时间内返回结果。");
// 建立索引 ？
// 1，把Article转成Document
Document doc = new Document();
doc.add(new Field("id", article.getId().toString(), Store.YES,Index.ANALYZED));
doc.add(new Field("title", article.getTitle(), Store.YES,Index.ANALYZED));
doc.add(new Field("content", article.getContent(), Store.YES,Index.ANALYZED));
// 2，建立索引
Directory directory = FSDirectory.open(new File("./indexDir/")); // 索引库文件所在的目录
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
IndexWriter indexWriter = new IndexWriter(directory, analyzer,new MaxFieldLength(10000)); // MaxFieldLength.LIMITED
indexWriter.addDocument(doc);
indexWriter.close();
}
// 搜索
@Test
public void search() throws Exception {
// 搜索条件
String queryString = "lucene";
// String queryString = "compass";
Directory directory = FSDirectory.open(new File("./indexDir/")); // 索引库文件所在的目录
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
// 1，把查询字符串转为Query对象
QueryParser queryParser = new QueryParser(Version.LUCENE_30, "title",analyzer); // 只在title中查询
Query query = queryParser.parse(queryString);
// 2，查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(directory);
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
int count = topDocs.totalHits; // 总结果数
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
// 3，处理结果
List list = new ArrayList();
for (int i = 0; i < scoreDocs.length; i++) {
ScoreDoc scoreDoc = scoreDocs[i];
float score = scoreDoc.score; // 相关度得分
int docId = scoreDoc.doc; // Document数据库的内部编号(是唯一的，由Lucene自动生成的)
// 根据编号取出真正的Document数据
Document doc = indexSearcher.doc(docId);
// 把Document转成Article
Article article = new Article();
article.setId(Integer.parseInt(doc.get("id"))); // 需要转Integer型
article.setTitle(doc.get("title")); // doc.getField("title").stringValue()
article.setContent(doc.get("content"));
list.add(article);
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
}
Lucene核心类
建立索引的核心类
1，IndexWriter
2，Directory
3，Analyzer
4，Document
5，Field
搜索的核心类
1，IndexSearcher
2，Term
3，Query
4，QueryParser与MultiFieldQueryParser
5，TopDocs
6，ScoreDoc
Lucene下载目录的docs目录有以上类的介绍。
7746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
