java集成lucene

本文是我们名为“ Apache Lucene基础知识 ”的学院课程的一部分。

在本课程中，您将了解Lucene。 您将了解为什么这样的库很重要，然后了解Lucene中搜索的工作方式。 此外，您将学习如何将Lucene Search集成到您自己的应用程序中，以提供强大的搜索功能。 在这里查看 ！

1.简介

Java Lucene提供了一种功能非常强大的查询语言，用于对大量数据执行搜索操作。

查询分为术语和运算符。 术语共有三种： 单项 ， 短语和子查询 。 单个术语是一个单词，例如“ test”或“ hello”。 词组是由双引号括起来的一组单词，例如“ hello dolly”。 子查询是用括号括起来的查询，例如“（hello dolly）”。

Lucene支持数据字段。 执行搜索时，您可以指定一个字段，也可以使用默认字段。 字段名称取决于索引数据，默认字段由当前设置定义。

2.解析查询字符串

查询解析器的工作是将用户提交的查询字符串转换为查询对象。

查询由解析其内容的查询解析器使用。 这是一个例子：

{"query_string" : {"default_field" : "content","query" : "this AND that OR thus"}
}

query_string顶级参数包括：

生成多词查询时，可以使用rewrite参数控制如何重写它。

QueryParser的规则

假设您正在Web上搜索同时包含单词java和net但不包含单词dot的页面。 如果搜索引擎让您为此简单查询输入类似以下内容，该怎么办？

BooleanQuery query = new BooleanQuery();
query.add(new TermQuery(new Term("contents","java")), true, false);
query.add(new TermQuery(new Term("contents", "net")), true, false);
query.add(new TermQuery(new Term("contents", "dot")), false, true);

那将是真正的阻力。 幸运的是，Google，Nutch和其他搜索引擎比这更友好，允许您输入更简洁的内容： java AND net NOT dot 。首先，我们将了解在应用程序中使用QueryParser涉及的内容。

使用QueryParser

使用QueryParser非常简单。 需要三件事：一个表达式，用于表达式中非限定字段的默认字段名称以及该表达式各部分的分析器。查询语法部分讨论了字段选择限定符。 “查询瘫痪”部分介绍了特定于查询解析的分析。 现在，让我们分析一个表达式：

String humanQuery = getHumanQuery();
Query query = QueryParser.parse(humanQuery, "contents", new StandardAnalyzer());

一旦获得Query对象，就可以像直接通过API创建查询一样进行搜索。 这是使用用户输入的查询字符串搜索现有索引并将结果显示到控制台的完整方法：

public static void search(File indexDir, String q) throws Exception{
Directory fsDir = FSDirectory.getDirectory(indexDir, false);IndexSearcher is = new IndexSearcher(fsDir);Query query = QueryParser.parse(q, "contents", new StandardAnalyzer());Hits hits = is.search(query);System.out.println("Found " + hits.length() +" document(s) that matched query '" + q + "':");for (int i = 0; i < hits.length(); i++) {Document doc = hits.doc(i);System.out.println(doc.get("filename"));}
}

根据简单的语法分析传递给QueryParser表达式。 遇到非法表达式时， QueryParser引发ParseException 。

QueryParser表达式语法

本节中的以下各项描述QueryParser支持创建各种查询类型的语法。

单项查询

仅一个单词的查询字符串将转换为基础TermQuery 。

词组查询

要在一个字段中一起搜索一组单词，请用双引号将单词引起来。 查询“ hello world”对应于精确的词组匹配，要求“ hello”和“ world”是匹配的连续项。 Lucene还支持草率的短语查询，其中引号之间的术语不必严格按照顺序排列。 斜率因子用于衡量将术语重新排列为准确顺序需要执行多少步。 如果移动次数小于指定的倾斜系数，则为匹配。 QueryParser将表达式“ hello world” PhraseQuery解析为PhraseQuery ，其PhraseQuery因子为2，允许对短语“ world hello”，“ hello world”，“ hello * world”和“ hello * * world”进行匹配，其中星号表示索引中不相关的单词。 请注意，“ world * hello”与坡度因子2不匹配。因为将其返回“ hello world”的步骤为3。将“ world”一词跳到星号位置是一个，到“你好”的位置是两个，第三跳完全匹配。

范围查询

文本或日期范围查询使用带括号的语法，在开始词和结束词之间使用TO。 方括号的类型确定范围是包含式（方括号）还是排他性（卷曲方括号）。

注意：非日期范围查询使用开始和结束词，因为用户输入时没有修改。 在{Aardvark TO Zebra}的情况下，这些术语不小写。 起始词和结束词不得包含空格，否则解析将失败； 只允许使用单个单词。 分析器未按开始和结束条件运行。

日期范围处理

当遇到范围查询（例如[1/1/03 TO 12/31/03]）时，解析器代码首先尝试将开始和结束条件转换为日期。 如果这些术语是有效日期，则根据DateFormat.SHORT和宽大的语法分析，日期将转换为其内部文本表示形式（但是，日期字段索引已超出本文的范围）。 如果这两个术语中的任何一个未能解析为有效日期，则它们都将原样用于文本范围。

通配符和前缀查询

如果一个术语包含星号或问号，则将其视为WildcardQuery ，除非该术语仅包含尾部星号并且QueryParser会将其优化为PrefixQuery 。 尽管WildcardQuery API本身支持前导通配符，但QueryParser不允许使用它。 通配符查询示例是w * ldc？rd ，而查询前缀*已优化为PrefixQuery 。

模糊查询

Lucene的FuzzyQuery匹配接近指定术语的术语。 Levenshtein距离算法确定索引中的词与指定目标词的接近程度。 “编辑距离”是“ Levenshtein距离”的另一个术语，是两个字符串之间相似度的量度，其中距离的测量是将一个字符串转换为另一个字符串所需的字符删除，插入或替换的数量。 例如，“三”和“树”之间的编辑距离是一，因为仅需要删除一个字符。 在阈值计算中使用移动数，该计算是距离与弦长的比率。 QueryParser支持在词条上使用尾随波浪号的模糊词条查询。 例如，搜索wuzza〜将找到包含“ fuzzy”和“ wuzzy”的文档。 编辑距离会影响评分，因此较低的编辑距离会获得较高的分数。

布尔查询

使用运算符AND，OR和NOT在文本上构造布尔查询。 列出的未指定运算符的术语使用隐式运算符，默认情况下为OR。 abc xyz的查询将解释为abc OR xyz。 在术语前加上NOT排除包含以下术语的文档。 否定项必须与至少一个非否定项组合才能返回文档。 下表中显示了每个大写单词运算符的快捷方式语法。

QueryParser是一种快速简便的方法，可以为用户提供强大的查询构造，但并不适合所有人。 QueryParser无法创建可以使用API​​构造的每种查询。 例如，不能构造PhrasePrefixQuery 。 您必须记住，将自由格式查询解析提供给最终用户时，所有可用的可能性。 某些查询可能会导致性能瓶颈。 内置QueryParser使用的语法可能不适合您的需求。 子类化QueryParser可以实现某些控制，尽管它仍然受到限制。

3.使用索引搜索器创建索引

通常，应用程序通常只需要调用继承的

Searcher.search(org.apache.lucene.search.Query,int)

要么

Searcher.search(org.apache.lucene.search.Query,org.apache.lucene.search.Filter,int)

方法。 为了提高性能，我们可以打开indexSearcher其用于所有其他搜索操作。 这是一个简单的示例，说明如何在lucene中创建索引并使用indexSearcher搜索该索引。

public void simpleLucene(){Analyzer analyzer = new StandardAnalyzer();// Store the index in memory:Directory directory = new RAMDirectory();// To store an index on disk, use this instead (note that the // parameter true will overwrite the index in that directory// if one exists):// Directory directory = FSDirectory.getDirectory("/tmp/myfiles", true);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.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();}

4.不同类型的查询

Lucene支持多种查询。 这里是其中的一些。

1. 术语查询
2. 布尔查询
3. 通配符查询
4. 词组查询
5. 前缀查询
6. 多词查询
7. 模糊查询
8. 正则表达式查询
9. TermRangeQuery
10. NumericRangeQuery
11. ConstantScoreQuery
12. DisjunctionMaxQuery
13. MatchAllDocsQuery

4.1术语查询

匹配具有包含术语（未分析）的字段的文档。 术语查询映射到Lucene TermQuery 。 以下匹配文档，其中用户字段包含术语kimchy ：

{"term" : { "user" : "kimchy" }
}

提升也可以与查询关联：

{"term" : { "user" : { "value" : "kimchy", "boost" : 2.0 } }
}

要么 ：

{"term" : { "user" : { "term" : "kimchy", "boost" : 2.0 } }
}

使用Lucene，可以搜索已使用TermQuery类建立索引的特定单词。 本教程将把TermQuery搜索与QueryParser搜索进行比较，并显示与术语查询有关的一些细微差别。

4.2布尔查询

我们可以使用BooleanQuery API或使用MultiFieldQueryParser在Lucene中运行多字段搜索来解析查询文本。 例如，如果一个索引有2个字段FirstName和LastName ，并且您需要在FirstName字段中搜索“ John”，在LastName字段中搜索“ Travis”，则可以使用BooleanQuery ：

BooleanQuery bq = new BooleanQuery();
Query qf = new TermQuery(new Lucene.Net.Index.Term("FirstName", "John"));
Query ql = new TermQuery(new Lucene.Net.Index.Term("LastName", "Travis"));
bq.Add(qf, BooleanClause.Occur.MUST);
bq.Add(ql, BooleanClause.Occur.MUST);
IndexSearcher srchr = new IndexSearcher(@"C:\\indexDir");
srchr.Search(bq);

4.3通配符查询

匹配具有匹配通配符表达式（未分析）的字段的文档。 支持的通配符是*，它匹配任何字符序列（包括空字符），以及？，它匹配任何单个字符。 请注意，此查询的速度可能很慢，因为它需要迭代许多项。 为了防止极慢的通配符查询，通配符术语不应以通配符*或？之一开头。 通配符查询映射到Lucene WildcardQuery。

{"wildcard" : { "user" : "ki*y" }
}

提升也可以与查询关联：

{"wildcard" : { "user" : { "value" : "ki*y", "boost" : 2.0 } }
}

要么 ：

{"wildcard" : { "user" : { "wildcard" : "ki*y", "boost" : 2.0 } }
}

此多项查询允许控制如何使用rewrite参数将其重写。

4.4短语查询

使用Lucene， PhaseQuery可以用于查询一系列术语，其中这些术语不一定必须彼此相邻或顺序相邻。 PhaseQuery对象的setSlop()方法可用于设置查询短语中各个单词之间可以包含多少个单词。

我们可以像这样使用PhraseQuery ，

Term term1 = new Term(FIELD_CONTENTS, string1);
Term term2 = new Term(FIELD_CONTENTS, string2);
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.add(term1);
phraseQuery.add(term2);
phraseQuery.setSlop(slop);

4.5前缀查询

匹配具有包含带有指定前缀（未分析）的术语的字段的文档。 前缀查询映射到Lucene PrefixQuery 。 以下匹配文档，其中用户字段包含以ki开头的术语：

{"prefix" : { "user" : "ki" }
}

提升也可以与查询关联：

{"prefix" : { "user" :  { "value" : "ki", "boost" : 2.0 } }
}

要么 ：

{"prefix" : { "user" :  { "prefix" : "ki", "boost" : 2.0 } }
}

此多项查询允许控制如何使用rewrite参数将其重写。

4.6 MultiPhraseQuery

内置的MultiPhraseQuery绝对是一种利基查询，但它可能很有用。 MultiPhraseQuery类似于PhraseQuery不同之处在于它允许每个职位使用多个术语。 您可以通过枚举所有可能的短语组合并使用BooleanQuery将它们“或”在一起来实现相同的逻辑效果，尽管以高性能为代价。

例如，假设我们要查找有关快速狐狸的所有文档，快速或快速后跟狐狸。 一种方法是执行“快速狐狸”或“快速狐狸”查询。 另一个选择是使用MultiPhraseQuery 。

4.7模糊查询

FuzzyQuery可以分为两种，一种。 像这样的查询模糊＆b。 像这样的字段查询模糊。 像这样的查询模糊–像这样的查询模糊，通过在一个或多个字段上运行来查找与提供的文本“相似”的文档。

{"fuzzy_like_this" : {"fields" : ["name.first", "name.last"],"like_text" : "text like this one","max_query_terms" : 12}
}

Fuzzy_like_this可以缩短为flt。
Fuzzy_like_this顶级参数包括：

• fields ->要对其运行类似查询的字段列表。 默认为_all字段。
• like_text >用于查找喜欢的文档的文本。
• ignore_tf >应该忽略词频。 默认为false。
• max_query_terms >任何生成的查询中将包含的最大查询词数。 默认为25。
• fuzziness ->术语变体的最小相似性。 默认值为0.5。 请参阅“模糊编辑”部分。
• prefix_length >变体术语上必需的公共前缀的长度。 预设为0。
• boost >设置查询的增强值。 默认为1.0。
• analyzer >将用于分析文本的分析器。 默认为与该字段关联的分析器。

模糊化所有以字符串形式提供的术语，然后选择最佳的n个差异术语。 实际上，这混合了FuzzyQuery和MoreLikeThis的行为，但要特别考虑模糊评分因素。 对于用户可能会在许多字段中提供详细信息并且不了解布尔查询语法的查询，并且还需要一定程度的模糊匹配和快速查询的查询，这通常会产生良好的查询结果。

对于每个源项，模糊变体都保存在没有BooleanQuery因子的BooleanQuery （因为我们不在任何文档中寻找多个变体的匹配项）。 此外，专门的TermQuery用于变体，并且不使用该变体词的IDF，因为这样会偏爱诸如拼写错误之类的罕见词。 取而代之的是，所有变体都使用相同的IDF排名（源查询项的排名），这是变体的提升因素。 如果索引中不存在源查询词，则使用变体的平均IDF。b。 像这样的字段查询模糊

Fuzzy_like_this_field查询与Fuzzy_like_this查询相同，只不过它针对单个字段运行。 它提供了比一般Fu​​zzy_like_this查询更好的查询DSL，并支持类型字段查询（使用类型过滤器自动包装类型字段以仅匹配特定类型）。

{"fuzzy_like_this_field" : {"name.first" : {"like_text" : "text like this one","max_query_terms" : 12}}
}

可以将Fuzzy_like_this_field缩短为flt_field。Fuzzy_like_this_field顶级参数包括：

• like_text->用于查找喜欢的文档的文本。
• ignore_tf->应该忽略词频。 默认为false。
• max_query_terms->任何生成的查询中将包含的最大查询词数。 默认为25。
• 模糊性->术语变体的模糊性。 默认值为0.5。 请参阅“模糊编辑”部分。
• prefix_length->变体术语上必需的公共前缀的长度。 预设为0。
• boost->设置查询的增强值。 默认为1.0。
• Analyzer->将用​​于分析文本的分析器。 默认为与该字段关联的分析器。

4.8 RegexpQuery

regexp查询允许您使用正则表达式术语查询。 有关受支持的正则表达式语言的详细信息，请参见正则表达式语法。

注意： regexp查询的性能在很大程度上取决于所选的正则表达式。 匹配。*之类的内容非常慢，而且无法使用环视正则表达式。 如果可能，应在正则表达式开始之前尝试使用长前缀。 诸如。*？+之类的通配符匹配器通常会降低性能。

{"regexp":{"name.first": "s.*y"}
}

还支持升压

{"regexp":{"name.first":{"value":"s.*y","boost":1.2}}
}

您还可以使用特殊标志

{"regexp":{"name.first": {"value": "s.*y","flags" : "INTERSECTION|COMPLEMENT|EMPTY"}}
}

可能的标志是ALL ， ANYSTRING ， AUTOMATON ， COMPLEMENT ， EMPTY ， INTERSECTION ， INTERVAL或NONE 。 正则表达式查询受regexp和query_string查询的支持。 Lucene正则表达式引擎不兼容Perl，但支持较小范围的运算符。

标准运营商

锚定大多数正则表达式引擎允许您匹配字符串的任何部分。 如果您想让正则表达式模式从字符串的开头开始或在字符串的末尾结束，则必须专门将其锚定，使用^表示开始或使用$表示结束.Lucene的模式始终被锚定。 提供的模式必须与整个字符串匹配。 对于字符串“ abcde” ：

ab.* # match

abcd # no match

允许的字符

模式中可以使用任何Unicode字符，但是某些字符是保留的，必须转义。 标准保留字符为：

。 ？ + * | {} []（）” \

如果启用了可选功能（请参见下文），那么这些字符也可能会被保留：

＃@＆<>〜

任何保留的字符都可以使用反斜杠“ \ *”进行转义，包括文字反斜杠字符：

“ \\”

此外，任何字符（双引号除外）在被双引号包围时都将按字面意义进行解释：

约翰” @ smith.com”

匹配任何字符

时期 ”。” 可以用来代表任何字符。 对于字符串“ abcde”：

ab... # match

a.c.e # match

一个或多个

加号“ +”可用于一次或多次重复前面的最短模式。 对于字符串“ aaabbb”：

a+b+ # match

aa+bb+ # match

a+.+ # match

aa+bbb+ # no match

零或更多

星号“ *”可用于匹配前面的最短模式零次或多次。 对于字符串“ aaabbb”：

a*b* # match

a*b*c* # match

.*bbb.* # match

aaa*bbb* # match

零或一

问号“？” 使前面的最短模式为可选。 它匹配零或一倍。 对于字符串“ aaabbb”：

aaa?bbb? # match

aaaa?bbbb? # match

.....?.? # match

aa?bb? # no match

最小到最大

可以使用花括号“ {}”指定前面的最短模式可以重复的最小次数和（可选）最大次数。 允许的形式为：

{5} # repeat exactly 5 times

{2,5} # repeat at least twice and at most 5 times

{2,} # repeat at least twice

对于字符串“ aaabbb”：

a{3}b{3} # match

a{2,4}b{2,4} # match

a{2,}b{2,} # match

.{3}.{3} # match

a{4}b{4} # no match

a{4,6}b{4,6} # no match

a{4,}b{4,} # no match

分组

括号“（）”可用于形成子模式。 上面列出的数量运算符以最短的先前模式进行操作，该模式可以是一组。 对于字符串“ ababab”：

(ab)+ # match

ab(ab)+ # match

(..)+ # match

(...)+ # no match

(ab)* # match

abab(ab)? # match

ab(ab)? # no match

(ab){3} # match

(ab){1,2} # no match

轮换

管道符号“ |” 充当OR运算符。 如果左侧或右侧的图案匹配，则匹配成功。 交替适用于最长的模式，而不是最短的模式。 对于字符串“ aabb”：

aabb|bbaa # match

aacc|bb # no match aa(cc|bb) # match

a+|b+ # no match

a+b+|b+a+ # match

a+(b|c)+ # match

角色类

潜在字符的范围可以通过将它们括在方括号“ []”中来表示为字符类。 前导^否定字符类。 允许的形式为：

[abc] # 'a' or 'b' or 'c'

[a-c] # 'a' or 'b' or 'c'

[-abc] # '-' or 'a' or 'b' or 'c'

[abc\\-] # '-' or 'a' or 'b' or 'c'

[^a-c] # any character except 'a' or 'b' or 'c'

[^a-c] # any character except 'a' or 'b' or 'c'

[-abc] # '-' or 'a' or 'b' or 'c'

[abc\\-] # '-' or 'a' or 'b' or 'c'

请注意，破折号“-”表示字符范围，除非它是第一个字符或用反斜杠转义。对于字符串“ abcd”：

ab[cd]+ # match

[a-d]+ # match

[^a-d]+ # no match

4.9 TermRangeQuery

一个Query ，该Query匹配一系列术语内的文档。 此查询寻找字词落入根据提供的范围中的文件相匹配String#compareTo(String) ，除非一个Collator被提供。 它不适用于数字范围。

这是一个如何在lucene中使用TermRangeQuery的示例，

private Query createQuery(String field, DateOperator dop) throws UnsupportedSearchException {
Date date = dop.getDate();
DateResolution res = dop.getDateResultion();
DateTools.Resolution dRes = toResolution(res);
String value = DateTools.dateToString(date, dRes);
switch(dop.getType()) {case ON:return new TermQuery(new Term(field ,value));case BEFORE: return new TermRangeQuery(field, DateTools.dateToString(MIN_DATE, dRes), value, true, false);case AFTER: return new TermRangeQuery(field, value, DateTools.dateToString(MAX_DATE, dRes), false, true);default:throw new UnsupportedSearchException();}
}

4.10 NumericRangeQuery

一个NumericRangeQuery ，它匹配指定范围内的数值。 要使用此功能，您必须先为数字索引。我们可以将NumericRangeQuery与TermQuery结合使用，

String termQueryString = "title:\\"hello world\\"";
Query termQuery = parser.parse(termQueryString);
Query pageQueryRange = NumericRangeQuery.newIntRange("page_count", 10, 20, true, true);
Query query = termQuery.combine(new Query[]{termQuery, pageQueryRange});

4.11 ConstantScoreQuery

包含另一个查询或过滤器的查询，对于与过滤器或查询匹配的每个文档，仅返回等于查询提升的常数分数。 因此，对于查询，它仅去除所有分数并返回常数。

{"constant_score" : {"filter" : {"term" : { "user" : "kimchy"}},"boost" : 1.2}
}

筛选器对象只能容纳筛选器元素，不能容纳查询。 过滤器比查询查询要快得多，因为它们不执行任何评分，尤其是在缓存时。查询还可以包装在constant_score查询中：

{"constant_score" : {"query" : {"term" : { "user" : "kimchy"}},"boost" : 1.2}
}

4.12 DisjunctionMaxQuery

一个查询，该查询生成由其子查询生成的文档并集，并使用任何子查询生成的该文档的最高分数对每个文档评分，并为任何其他匹配的子查询加上平局打破增量。

在具有不同提升因子的多个字段中搜索单词时，这很有用（这样就无法将这些字段等效地组合到单个搜索字段中）。 我们希望主要分数是与最高提升相关的分数，而不是字段分数的总和（如布尔查询所给出的那样）。 如果查询是“白化大象”，则这确保匹配一个字段的“白化”和匹配另一个字段的“大象”获得比匹配两个字段的“白化”更高的分数。 要获得此结果，请同时使用Boolean Query和DisjunctionMaxQuery ：对于每个术语，DisjunctionMaxQuery在每个字段中进行搜索，同时将这些DisjunctionMaxQuery的集合组合为BooleanQuery 。

打破平局功能使多个字段中包含相同术语的结果比仅在多个字段中最好的包含该术语的结果更好地进行判断，而不会与多个字段中两个不同术语的更好情况混淆。默认的tie_breaker是0.0。此查询映射到Lucene DisjunctionMaxQuery 。

{"dis_max" : {"tie_breaker" : 0.7,"boost" : 1.2,"queries" : [{"term" : { "age" : 34 }},{"term" : { "age" : 35 }}]}
}

4.13 MatchAllDocsQuery

与所有文档匹配的查询。 映射到Lucene MatchAllDocsQuery 。

{"match_all" : { }
}

哪些也可以与之关联：

{"match_all" : { "boost" : 1.2 }
}

翻译自: https://www.javacodegeeks.com/2015/09/integrating-lucene-search-into-an-application.html

java集成lucene