在进入Lucene之前，对上述索引创建和搜索过程所一个总结，如图：
此图参照http://www.lucene.com.cn/about.htm 中文章《开放源代码的全文检索引擎Lucene》
![[图]索引创建和搜索过程](https://static.oschina.net/uploads/img/201712/20142200_Oo0Q.jpg)
1. 索引过程：
1) 有一系列被索引文件
2) 被索引文件经过语法分析和语言处理形成一系列词(Term) 。
3) 经过索引创建形成词典和反向索引表。
4) 通过索引存储将索引写入硬盘。
2. 搜索过程：
a) 用户输入查询语句。
b) 对查询语句经过语法分析和语言分析得到一系列词(Term) 。
c) 通过语法分析得到一个查询树。
d) 通过索引存储将索引读入到内存。
e) 利用查询树搜索索引，从而得到每个词(Term) 的文档链表，对文档链表进行交，差，并得到结果文档。
f) 将搜索到的结果文档对查询的相关性进行排序。
g) 返回查询结果给用户。
Lucene 是一个基于 Java 的全文信息检索工具包，它不是一个完整的搜索应用程序，而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目。也是目前最为流行的基于 Java 开源全文检索工具包。
全文检索的实现机制
Lucene的API接口设计的比较通用，输入输出结构都很像数据库的表==>记录==>字段，所以很多传统的应用的文件、数据库等都可以比较方便的映射到Lucene的存储结构/接口中。总体上看：可以先把Lucene当成一个支持全文索引的数据库系统
全文检索 ≠ like "%keyword%"
通常比较厚的书籍后面常常附关键词索引表（比如：北京：12, 34页， 上海：3,77页……），它能够帮助读者比较快地找到相关内容的页码。而数据库索引能够大大提高查询的速度原理也是一样，想像一下通过书后面的索引查找的速度要比一页一页地翻内容高多少倍……而索引之所以效率高，另外一个原因是它是排好序的。对于检索系统来说核心是一个排序问题。
由于数据库索引不是为全文索引设计的，因此，使用like "%keyword%"时，数据库索引是不起作用的，在使用like查询时，搜索过程又变成类似于一页页翻书的遍历过程了，所以对于含有模糊查询的数据库服务来说，LIKE对性能的危害是极大的。如果是需要对多个关键词进行模糊匹配：like"%keyword1%" and like "%keyword2%" ...其效率也就可想而知了。
所以建立一个高效检索系统的关键是建立一个类似于科技索引一样的反向索引机制，将数据源（比如多篇文章）排序顺序存储的同时，有另外一个排好序的关键词列表，用于存储关键词==>文章映射关系，利用这样的映射关系索引：[关键词==>出现关键词的文章编号，出现次数（甚至包括位置：起始偏移量，结束偏移量），出现频率]，检索过程就是把模糊查询变成多个可以利用索引的精确查询的逻辑组合的过程。从而大大提高了多关键词查询的效率，所以，全文检索问题归结到最后是一个排序问题。
由此可以看出模糊查询相对数据库的精确查询是一个非常不确定的问题，这也是大部分数据库对全文检索支持有限的原因。Lucene最核心的特征是通过特殊的索引结构实现了传统数据库不擅长的全文索引机制，并提供了扩展接口，以方便针对不同应用的定制。
可以通过一下表格对比一下数据库的模糊查询：
| Lucene全文索引引擎 | 数据库 | |
| 索引 | 将数据源中的数据都通过全文索引一一建立反向索引 | 对于LIKE查询来说，数据传统的索引是根本用不上的。数据需要逐个便利记录进行GREP式的模糊匹配，比有索引的搜索速度要有多个数量级的下降。 |
| 匹配效果 | 通过词元(term)进行匹配，通过语言分析接口的实现，可以实现对中文等非英语的支持。 | 使用：like "%net%" 会把netherlands也匹配出来， 多个关键词的模糊匹配：使用like "%com%net%"：就不能匹配词序颠倒的xxx.net..xxx.com |
| 匹配度 | 有匹配度算法，将匹配程度（相似度）比较高的结果排在前面。 | 没有匹配程度的控制：比如有记录中net出现5词和出现1次的，结果是一样的。 |
| 结果输出 | 通过特别的算法，将最匹配度最高的头100条结果输出，结果集是缓冲式的小批量读取的。 | 返回所有的结果集，在匹配条目非常多的时候（比如上万条）需要大量的内存存放这些临时结果集。 |
| 可定制性 | 通过不同的语言分析接口实现，可以方便的定制出符合应用需要的索引规则（包括对中文的支持） | 没有接口或接口复杂，无法定制 |
| 结论 | 高负载的模糊查询应用，需要负责的模糊查询的规则，索引的资料量比较大 | 使用率低，模糊匹配规则简单或者需要模糊查询的资料量少 |
全文检索和数据库应用最大的不同在于：让最相关的头100条结果满足98%以上用户的需求
Lucene的创新之处：
大部分的搜索（数据库）引擎都是用B树结构来维护索引，索引的更新会导致大量的IO操作，Lucene在实现中，对此稍微有所改进：不是维护一个索引文件，而是在扩展索引的时候不断创建新的索引文件，然后定期的把这些新的小索引文件合并到原先的大索引中（针对不同的更新策略，批次的大小可以调整），这样在不影响检索的效率的前提下，提高了索引的效率。
Lucene和其他一些全文检索系统/应用的比较：
| Lucene | 其他开源全文检索系统 | |
| 增量索引和批量索引 | 可以进行增量的索引(Append)，可以对于大量数据进行批量索引，并且接口设计用于优化批量索引和小批量的增量索引。 | 很多系统只支持批量的索引，有时数据源有一点增加也需要重建索引。 |
| 数据源 | Lucene没有定义具体的数据源，而是一个文档的结构，因此可以非常灵活的适应各种应用（只要前端有合适的转换器把数据源转换成相应结构）， | 很多系统只针对网页，缺乏其他格式文档的灵活性。 |
| 索引内容抓取 | Lucene的文档是由多个字段组成的，甚至可以控制那些字段需要进行索引，那些字段不需要索引，近一步索引的字段也分为需要分词和不需要分词的类型： 需要进行分词的索引，比如：标题，文章内容字段 不需要进行分词的索引，比如：作者/日期字段 | 缺乏通用性，往往将文档整个索引了 |
| 语言分析 | 通过语言分析器的不同扩展实现： 可以过滤掉不需要的词：an the of 等， 西文语法分析：将jumps jumped jumper都归结成jump进行索引/检索 非英文支持：对亚洲语言，阿拉伯语言的索引支持 | 缺乏通用接口实现 |
| 查询分析 | 通过查询分析接口的实现，可以定制自己的查询语法规则： 比如： 多个关键词之间的 + - and or关系等 | |
| 并发访问 | 能够支持多用户的使用 |
它可以当作一个缓存的方式减少数据的压力。下面基于配置上下代码来提高理解。
我们使用IDEA+gradle+spring boot
首选在build.gradle加入lucene引用
dependencies {
compile "org.apache.lucene:lucene-core:6.5.1"
compile "org.apache.lucene:lucene-analyzers-common:6.5.1"
compile "org.apache.lucene:lucene-analyzers-smartcn:6.5.1"
compile "org.apache.lucene:lucene-highlighter:6.5.1"
compile "org.apache.lucene:lucene-queryparser:6.5.1"
}
一些需要知道的概念
1 analyzer
Analyzer是分析器，它的作用是把一个字符串按某种规则划分成一个个词语，并去除其中的无效词语，这里说的无效词语是指英文中的“of”、“the”，中文中的“的”、“地”等词语，这些词语在文章中大量出现，但是本身不包含什么关键信息，去掉有利于缩小索引文件、提高效率、提高命中率。
分词的规则千变万化，但目的只有一个：按语义划分。这点在英文中比较容易实现，因为英文本身就是以单词为单位的，已经用空格分开；而中文则必须以某种方法将连成一片的句子划分成一个个词语。具体划分方法下面再详细介绍，这里只需了解分析器的概念即可。
2 document
用户提供的源是一条条记录，它们可以是文本文件、字符串或者数据库表的一条记录等等。一条记录经过索引之后，就是以一个Document的形式存储在索引文件中的。用户进行搜索，也是以Document列表的形式返回。
3 field
一个Document可以包含多个信息域，例如一篇文章可以包含“标题”、“正文”、“最后修改时间”等信息域，这些信息域就是通过Field在Document中存储的。
Field有两个属性可选：存储和索引。通过存储属性你可以控制是否对这个Field进行存储；通过索引属性你可以控制是否对该Field进行索引。这看起来似乎有些废话，事实上对这两个属性的正确组合很重要，下面举例说明：还是以刚才的文章为例子，我们需要对标题和正文进行全文搜索，所以我们要把索引属性设置为真，同时我们希望能直接从搜索结果中提取文章标题，所以我们把标题域的存储属性设置为真，但是由于正文域太大了，我们为了缩小索引文件大小，将正文域的存储属性设置为假，当需要时再直接读取文件；我们只是希望能从搜索解果中提取最后修改时间，不需要对它进行搜索，所以我们把最后修改时间域的存储属性设置为真，索引属性设置为假。上面的三个域涵盖了两个属性的三种组合，还有一种全为假的没有用到，事实上Field不允许你那么设置，因为既不存储又不索引的域是没有意义的。
4 term
term是搜索的最小单位，它表示文档的一个词语，term由两部分组成：它表示的词语和这个词语所出现的field。
5 tocken
tocken是term的一次出现，它包含trem文本和相应的起止偏移，以及一个类型字符串。一句话中可以出现多次相同的词语，它们都用同一个term表示，但是用不同的tocken，每个tocken标记该词语出现的地方。
6 segment
添加索引时并不是每个document都马上添加到同一个索引文件，它们首先被写入到不同的小文件，然后再合并成一个大索引文件，这里每个小文件都是一个segment。
然后加入基类
class SearchEngine {
Directory directory;
private IndexWriter publicIndexWriter;
private DirectoryReader publicDirectoryReader;
boolean indexReady;
private PerFieldAnalyzerWrapper analyzerWrapper;
PerFieldAnalyzerWrapper getAnalyzerWrapper() {
if (analyzerWrapper == null) {
analyzerWrapper = new PerFieldAnalyzerWrapper(new myzd.utils.PinyinAnalyzer());
}
return analyzerWrapper;
}
void addNewAnalyzer(String fieldName, Analyzer analyzer) {
PerFieldAnalyzerWrapper wrapper = getAnalyzerWrapper();
Map<String, Analyzer> map = new HashMap<>();
try {
Field field = wrapper.getClass().getDeclaredField("fieldAnalyzers");
field.setAccessible(true);
if (!field.get(wrapper).equals(new HashMap<>())) {
map = (Map<String, Analyzer>) field.get(wrapper);
}
map.put(fieldName, analyzer);
} catch (Exception e) {
log.warn("addNewAnalyzer", e);
}
analyzerWrapper = new PerFieldAnalyzerWrapper(new myzd.utils.PinyinAnalyzer(), map);
}
IndexWriter getIndexWriter() {
if (publicIndexWriter == null || !publicIndexWriter.isOpen()) {
try {
IndexWriterConfig config = new IndexWriterConfig(getAnalyzerWrapper());
publicIndexWriter = new IndexWriter(directory, config);
} catch (IOException e) {
log.warn("getIndexWriter-IOException", e);
}
}
return publicIndexWriter;
}
DirectoryReader getDirectoryReader() {
try {
if (publicDirectoryReader == null || !publicDirectoryReader.isCurrent()) {
publicDirectoryReader = DirectoryReader.open(directory);
}
} catch (IOException e) {
log.warn("getDirectoryReader-IOException", e);
}
return publicDirectoryReader;
}
void addDocument(Document document) {
try {
long startTime = System.currentTimeMillis();
IndexWriter indexWriter = getIndexWriter();
indexWriter.addDocument(document);
indexWriter.commit();
long useTime = System.currentTimeMillis() - startTime;
log.info(String.format("Add Index success ,time %s ms, ObjectName is %s", useTime, getName()));
} catch (IOException e) {
log.warn("addDocument-IOException", e);
}
}
String getName() {
return getClass().getSimpleName();
}
}
建立索引的步骤
1.创建Directory
2.创建IndexWriter
3.创建Document对象
4.为Document添加Field
接下来我们通过一个列子来继续了解
directory = new RAMDirectory();//这个方法是建立在内存中的索引
addNewAnalyzer("doctorSearchName", new StandardAnalyzer());
//通过新线程建立数据库中所有推荐医生的索引
new Thread(() -> {
log.info("Create DoctorSearchEngines Index Start");
long startTime = System.currentTimeMillis();
List<RecommendedDoctor> recommendedDoctorArrayList = recommendedDoctorMapper.getAllDoctors();
List<Integer> idList = new ArrayList<>();
recommendedDoctorArrayList.forEach(recommendedDoctor -> idList.add(recommendedDoctor.getDoctorId()));
List<DoctorResponse> doctorResponsesList = getDoctorDetailsList(idList, doctorKbClient, recommendedDoctorArrayList);
try {
/**
* Description: 建立索引
*
*/
indexReady = true;
//创建IndexWriter
IndexWriter indexWriter = getIndexWriter();
assert doctorResponsesList != null;
for (DoctorResponse doctorResponse : doctorResponsesList) {
//通过IndexWriter添加文档到索引中
indexWriter.addDocument(getDocument(doctorResponse));
}
indexWriter.commit();
} catch (IOException e) {
log.warn("DefaultDoctorSearchEngines-IOException", e);
}
long endTime = System.currentTimeMillis();
log.info("Create DoctorSearchEngines Index Success Time :" + (endTime - startTime) + "ms");
}).start();
void addNewAnalyzer(String fieldName, Analyzer analyzer) {
PerFieldAnalyzerWrapper wrapper = getAnalyzerWrapper();
Map<String, Analyzer> map = new HashMap<>();
try {
Field field = wrapper.getClass().getDeclaredField("fieldAnalyzers");
field.setAccessible(true);
if (!field.get(wrapper).equals(new HashMap<>())) {
map = (Map<String, Analyzer>) field.get(wrapper);
}
map.put(fieldName, analyzer);
} catch (Exception e) {
log.warn("addNewAnalyzer", e);
}
analyzerWrapper = new PerFieldAnalyzerWrapper(new myzd.utils.PinyinAnalyzer(), map);
}
private Document getDocument(DoctorResponse doctorResponse) {
Document document = new Document();//创建Document对象
document.add(new NumericDocValuesField("orders_sort", doctorResponse.getOrders()));//加入排序
if (doctorResponse.getId() != null) {
document.add(new IntPoint("id", doctorResponse.getId()));
}
if (doctorResponse.getRecommended() != null && doctorResponse.getRecommended()) {
document.add(new IntPoint("recommended", 1));
} else {
document.add(new IntPoint("recommended", 0));
}
if (doctorResponse.getOrders() != null) {
document.add(new IntPoint("orders", doctorResponse.getOrders()));
}
try {
document.add(new StoredField("doctor", objectMapper.writeValueAsString(doctorResponse)));
} catch (JsonProcessingException e) {
log.warn("JsonProcessing", e);
}
return document;
}
解析部分：
StandardAnalyzer 英文的处理能力同于StopAnalyzer.支持中文采用的方法为单字切分。他会将词汇单元转换成小写形式，并去除停用词和标点符号。
文档Document和域Field的关系
文档Document相当于关系表中的每一条记录,域相当于表中的每一个字段,先创建文档,之后为文档添加域.
域存储选项和域索引选项,均需要在域添加的时候设置
存储域选项
Field.Store.YES表示把这个域中的内容完全存储到文件中,方便进行文本的还原
Field.Store.NO表示把这个域中的内容不存储到文件中,但是可以被索引,此时内容无法还原(即无法document.get());
索引域选项
Field.Index.ANALYZED：进行分词和索引,适用于标题和内容等
Field.Index.NOT_ANALYZED：进行索引,但是不进行分词,像身份证号,姓名,ID等,适用于精确索索
Field.Index.ANALYZED_NO_NORMS：进行分词但是不存储norms信息,这个norms中包括了创建索引的时间和权值等信息
Field.Index.NOT_ANALYZED_NO_NORMS：即不进行分词也不存储norms信息
Field.Index.NO：不进行索引
最佳实践
Field.Index.NOT_ANALYZED_NO_NORMS, Field.Store.YES标识符(主键,文件名),电话号码,身份证号,姓名,日期
Field.Index.ANALYZED, Field.Store.YES文档标题和摘要
Field.Index.ANALYZED, Field.Store.NO文档正文
Field.Index.NO,Field.Store.YES文档类型,数据库主键(不进行索引)
Field.Index.NOT_ANALYZED,Field.Store.NO 隐藏关键字
搜索操作的步骤:
1.创建Directory
2.创建IndexReader
3.根据IndexReader创建IndexSearcher
4.创建搜索的Query
5.根据Searcher搜索并且返回TopDocs
6.根据TopDocs获取ScoreDoc对象
7.根据Seacher和ScoreDoc对象获取具体的Document对象
8.根据Document对象获取需要的值
9.关闭IndexReader
下面我们加入一个具体搜索的列子：
private BooleanQuery.Builder createBooleanQueryBuilder(DoctorSearch doctorSearch) {
//得到所有医生INTEGER类型最小到最大的过滤
return new BooleanQuery.Builder() {{
add(IntPoint.newRangeQuery("id", Integer.MIN_VALUE, Integer.MAX_VALUE), BooleanClause.Occur.MUST);
}};
}
@Override
public ResultWrapper<PagedResult<DoctorResponse>> searchRecommendDoctor(DoctorSearch doctorSearch) {
List<DoctorResponse> doctorDetailsArrayList = new ArrayList<>();
Integer count;
if (indexReady) {
try {
DirectoryReader directoryReader = getDirectoryReader();
//2.创建IndexReader
IndexSearcher indexSearcher = new IndexSearcher(directoryReader);
//Lucene在6.0版本之后彻底废除了Filter的使用，采用BooleanQuery来实现Filter的功能
BooleanQuery.Builder booleanQuery = createBooleanQueryBuilder(doctorSearch);
if ((count = indexSearcher.count(booleanQuery.build())) > 0) {
int startIndex = (doctorSearch.getPage() - 1) * doctorSearch.getPageSize();
Sort sort = new Sort(new SortField("orders_sort", SortField.Type.INT, false));
//6.根据TBooleanQuery获取ScoreDoc对象
ScoreDoc[] hits = indexSearcher.search(booleanQuery.build(), count, sort).scoreDocs;
for (int i = startIndex; i < doctorSearch.getPageSize() + startIndex; i++) {
if (hits.length > i) {
//7.根据排序条件和ScoreDoc对象获取具体的Document对象
Document doc = indexSearcher.doc(hits[i].doc);
//8.根据Document对象获取需要的值
String result = doc.getField("doctor").stringValue();
//下面加入搜索结果
doctorDetailsArrayList.add(objectMapper.readValue(result, DoctorResponse.class));
} else {
break;
}
}
List<DoctorResponse> result = getOrderedResult(doctorDetailsArrayList);
return new ResultWrapper<>(new PagedResult<DoctorResponse>() {{
setList(result);
setSize(count);
setPage(doctorSearch.getPage());
setPageSize(doctorSearch.getPageSize());
}});
}
} catch (IOException e) {
log.warn("getAllDoctor-IOException", e);
}
}
return null;
}
第一次写博客，很多还要大牛指导。
本文很多理论知识还引用了http://www.cnblogs.com/dennisit/archive/2013/04/06/3002863.html
扫一扫
5064
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
