关于SpanQuery(跨度搜索)，它是Query的子类，但是SpanQuery仍然是一个抽象类，它有6个直接子类实现类。继承关系如图所示：
其中SpanTermQuery是一个最基础的跨度搜索实现类，SpanTermQuery与SpanQuery的关系，就如同TermQuery与Query的关系：SpanTermQuery是为SpanQuery其它的具体实现子类服务的，其实TermQuery也是为Query的具体子类实现类服务的，例如构造一个BooleanQuery查询，可以向其中添加多个TermQuery查询子句。
SpanTermQuery跨度搜索
SpanTermQuery的应用与TermQuery的用法是一样的，获取到的检索结果集也是相同的。
这里，SpanTermQuery是SpanQuery的子实现类，所有从跨度搜索的角度来说，他的跨度值就是使用SpanTermQuery的唯一的一个构造方法所用的一个Term的跨度值。也就是说，它的起始位置和结束位置都是一个固定的值(其实就是一个固定跨度)。
SpanFirstQuery跨度搜索
SpanFirstQuery搜索是基于SpanTermQuery的，在实例化一个SpanFirstQuery的时候，是通过一个SpanTermQuery的实例作为参数来构造的。
该SpanFirstQuery只有唯一的一个构造方法：
public SpanFirstQuery(SpanQuery match, int end) {
this.match = match;
this.end = end;
}
上面的end指定了在查询时，从起始位置开始(起始位置为0，这点可以在后面的测试中得知。因为名称中First已经表达了这层含义)，在小于end的位置之前的文本中，与match进行匹配。
先使用ThesaurusAnalyzer分析器来实现分词，为指定的数据建立索引，如下所示：
package org.apache.lucene.shirdrn.main;
import java.io.IOException;
import net.teamhot.lucene.ThesaurusAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.LockObtainFailedException;
public class MySearchEngineUsingThesaurusAnalyzer {
public static void main(String[] args){
String indexPath = "E:\\Lucene\\index";
IndexWriter writer;
try {
writer = new IndexWriter(indexPath,new ThesaurusAnalyzer(),true);
Field fieldA = new Field("contents","今天是我们地球的生日，对于我们每个人，在我们的宇宙中，一场空前关于我们熟悉的宇宙论的辩论激烈地展开了。",Field.Store.YES,Field.Index.TOKENIZED);
Document docA = new Document();
docA.add(fieldA);
Field fieldB1 = new Field("contents","谁知道宇宙空间的奥秘，在我们这些人当中？",Field.Store.YES,Field.Index.TOKENIZED);
Field fieldB2 = new Field("contents","宇宙飞船。",Field.Store.YES,Field.Index.TOKENIZED);
Field fieldB3 = new Field("contents","我们的太空宇宙。",Field.Store.YES,Field.Index.TOKENIZED);
Document docB = new Document();
docB.add(fieldB1);
docB.add(fieldB2);
docB.add(fieldB3);
Field fieldC = new Field("contents","我们宇宙学家对地球的重要性。",Field.Store.YES,Field.Index.TOKENIZED);
Document docC = new Document();
docC.add(fieldC);
writer.addDocument(docA);
writer.addDocument(docB);
writer.addDocument(docC);
writer.close();
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (LockObtainFailedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
首先要把ThesaurusAnalyzer分析器的jar包加入到CLASSPATH中，然后运行上面的主函数，建立索引。
建立的索引文件在本地磁盘指定的索引目录E:\Lucene\index下生成，这时候可以测试SpanFirstQuery的使用了。
因为ThesaurusAnalyzer分析器自带了一个词库，该词库中有词条“我们”，我们就通过“我们”来构造SpanQuery，进行查询。
编写一个SpanFirstQuerySearcher测试类，带主函数，如下所示：
package org.apache.lucene.shirdrn.main;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.spans.SpanFirstQuery;
import org.apache.lucene.search.spans.SpanQuery;
import org.apache.lucene.search.spans.SpanTermQuery;
public class SpanFirstQuerySearcher {
public static void main(String[] args) {
String indexPath = "E:\\Lucene\\index";
try {
IndexSearcher searcher = new IndexSearcher(indexPath);
String keyword = "我们";
Term term = new Term("contents",keyword);
SpanTermQuery spanTermQuery = new SpanTermQuery(term);
int end = 1;
SpanQuery spanFirstQuery = new SpanFirstQuery(spanTermQuery,end);
System.out.println("####################################################################");
System.out.println("SpanFirstQuery中end指定值为 ： "+end);
System.out.println("####################################################################");
Date startTime = new Date();
Hits hits = searcher.search(spanFirstQuery);
for(int i=0;i<hits.length();i++){
TermDocs termDocs = searcher.getIndexReader().termDocs(term);
while(termDocs.next()){
if(termDocs.doc() == hits.id(i)){
System.out.println("Document的内部编号为 ： "+hits.id(i));
Document doc = hits.doc(i);
System.out.println("Document的得分为 ： "+hits.score(i));
List fieldList = doc.getFields();
System.out.println("Document(编号) "+hits.id(i)+" 的Field的信息： ");
for(int j=0;j<fieldList.size();j++){
Field field = (Field)fieldList.get(j);
System.out.println(" Field的name : "+field.name());
System.out.println(" Field的stringValue : "+field.stringValue());
System.out.println(" ------------------------------------");
}
System.out.println("搜索的该关键字【"+keyword+"】在Document(编号) "+hits.id(i)+" 中，出现过 "+termDocs.freq()+" 次");
}
}
}
System.out.println("********************************************************************");
Date finishTime = new Date();
long timeOfSearch = finishTime.getTime() - startTime.getTime();
System.out.println("本次搜索所用的时间为 "+timeOfSearch+" ms");
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
当end=1时，也就是从具有一个词条的跨度，运行结果如下所示：
####################################################################
SpanFirstQuery中end指定值为 ： 1
####################################################################
Document的内部编号为 ： 2
Document的得分为 ： 0.18888181
Document(编号) 2 的Field的信息：
Field的name : contents
Field的stringValue : 我们宇宙学家对地球的重要性。
------------------------------------
搜索的该关键字【我们】在Document(编号) 2 中，出现过 1 次
********************************************************************
本次搜索所用的时间为 78 ms
这里docB没有被检索出来。
当end=5时，增大了跨度，执行结果如下所示：
####################################################################
SpanFirstQuery中end指定值为 ： 5
####################################################################
Document的内部编号为 ： 2
Document的得分为 ： 0.18888181
Document(编号) 2 的Field的信息：
Field的name : contents
Field的stringValue : 我们宇宙学家对地球的重要性。
------------------------------------
搜索的该关键字【我们】在Document(编号) 2 中，出现过 1 次
Document的内部编号为 ： 0
Document的得分为 ： 0.09444091
Document(编号) 0 的Field的信息：
Field的name : contents
Field的stringValue : 今天是我们地球的生日，对于我们每个人，在我们的宇宙中，一场空前关于我们熟悉的宇宙论的辩论激烈地展开了。
------------------------------------
搜索的该关键字【我们】在Document(编号) 0 中，出现过 4 次
********************************************************************
本次搜索所用的时间为 62 ms
当end=10的时候，可以看到3个Document都被检索到，如下所示：
####################################################################
SpanFirstQuery中end指定值为 ： 10
####################################################################
Document的内部编号为 ： 2
Document的得分为 ： 0.18888181
Document(编号) 2 的Field的信息：
Field的name : contents
Field的stringValue : 我们宇宙学家对地球的重要性。
------------------------------------
搜索的该关键字【我们】在Document(编号) 2 中，出现过 1 次
Document的内部编号为 ： 0
Document的得分为 ： 0.13355961
Document(编号) 0 的Field的信息：
Field的name : contents
Field的stringValue : 今天是我们地球的生日，对于我们每个人，在我们的宇宙中，一场空前关于我们熟悉的宇宙论的辩论激烈地展开了。
------------------------------------
搜索的该关键字【我们】在Document(编号) 0 中，出现过 4 次
Document的内部编号为 ： 1
Document的得分为 ： 0.1259212
Document(编号) 1 的Field的信息：
Field的name : contents
Field的stringValue : 谁知道宇宙空间的奥秘，在我们这些人当中？
------------------------------------
Field的name : contents
Field的stringValue : 宇宙飞船。
------------------------------------
Field的name : contents
Field的stringValue : 我们的太空宇宙。
------------------------------------
搜索的该关键字【我们】在Document(编号) 1 中，出现过 2 次
********************************************************************
本次搜索所用的时间为 234 ms
SpanNearQuery跨度搜索
SpanNearQuery只有一个构造方法，可以从SpanNearQuery的构造方法来看：
public SpanNearQuery(SpanQuery[] clauses, int slop, boolean inOrder) {
this.clauses = new ArrayList(clauses.length);
for (int i = 0; i < clauses.length; i++) {
SpanQuery clause = clauses[i];
if (i == 0) {
field = clause.getField();
} else if (!clause.getField().equals(field)) {
throw new IllegalArgumentException("Clauses must have same field.");
}
this.clauses.add(clause);
}
this.slop = slop;
this.inOrder = inOrder;
}
从方法的声明来看，各个参数如下：
clauses是指：一个SpanQuery的子句的数组；
slop是指：对于每个SpanQuery都由一个Term构造而成，在一段文本中，可能在出现的这两个词条之间由若干个其它不相关的词条，slop指定了一个整数值，从而可以忽略这些不相关的词条(忽略的个数<=slop)，如果slop=0，则说明clauses中的SpanQuery查询的词条必须是相连着的；
inOrder是指：是否clauses子句们按照有序的方式实现搜索，当inOrder为true时，必须按照各个子句中检索的词条的前后顺序进行匹配，逆序的就被淘汰。
依然用上面建立的索引文件测试。
测试通过先构造一个SpanTermQuery(词条内容为“我们”)和一个SpanFirstQuery(词条内容为“宇宙”)，再构造一个SpanNearQuery，测试代码如下所示：
package org.apache.lucene.shirdrn.main;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.spans.SpanFirstQuery;
import org.apache.lucene.search.spans.SpanNearQuery;
import org.apache.lucene.search.spans.SpanQuery;
import org.apache.lucene.search.spans.SpanTermQuery;
public class SpanNearQuerySearcher {
public static void main(String[] args) {
String indexPath = "E:\\Lucene\\index";
try {
IndexSearcher searcher = new IndexSearcher(indexPath);
String keywordA = "我们";
Term termA = new Term("contents",keywordA);
SpanTermQuery spanTermQueryA = new SpanTermQuery(termA);
int end = 10;
System.out.println("####################################################################");
System.out.println("SpanFirstQuery中end指定值为 ： "+end);
System.out.println("####################################################################");
SpanQuery spanFirstQuery = new SpanFirstQuery(spanTermQueryA,end);
String keywordB = "宇宙";
Term termB = new Term("contents",keywordA);
SpanTermQuery spanTermQueryB = new SpanTermQuery(termB);
int slop = 2;
System.out.println("####################################################################");
System.out.println("SpanNearQuery中slop指定值为 ： "+slop);
System.out.println("####################################################################");
SpanNearQuery spanNearQuery = new SpanNearQuery(new SpanQuery[]{spanFirstQuery,spanTermQueryB},slop,true);
Date startTime = new Date();
Hits hits = searcher.search(spanNearQuery);
for(int i=0;i<hits.length();i++){
System.out.println("Document的内部编号为 ： "+hits.id(i));
Document doc = hits.doc(i);
System.out.println("Document的得分为 ： "+hits.score(i));
List fieldList = doc.getFields();
System.out.println("Document(编号) "+hits.id(i)+" 的Field的信息： ");
for(int j=0;j<fieldList.size();j++){
Field field = (Field)fieldList.get(j);
System.out.println(" Field的name : "+field.name());
System.out.println(" Field的stringValue : "+field.stringValue());
System.out.println(" ------------------------------------");
}
}
System.out.println("********************************************************************");
Date finishTime = new Date();
long timeOfSearch = finishTime.getTime() - startTime.getTime();
System.out.println("本次搜索所用的时间为 "+timeOfSearch+" ms");
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
这里，指定了slop=2，inOrder=true，即：“我们”和“宇宙”是按先后顺序在Document中进行匹配的。
运行测试程序，结果如下：
####################################################################
SpanFirstQuery中end指定值为 ： 10
####################################################################
####################################################################
SpanNearQuery中slop指定值为 ： 2
####################################################################
Document的内部编号为 ： 0
Document的得分为 ： 0.059729677
Document(编号) 0 的Field的信息：
Field的name : contents
Field的stringValue : 今天是我们地球的生日，对于我们每个人，在我们的宇宙中，一场空前关于我们熟悉的宇宙论的辩论激烈地展开了。
------------------------------------
********************************************************************
本次搜索所用的时间为 93 ms
其实，我们指定了SpanFirstQuery足够大的跨度，但是在SpanNearQuery中指定的slop的值很小，在进行匹配的时候，只是允许两个词条之间可以有2个无关的其它词条，再加上指定了inOrder为true，严格有序，所以只检索到了编号为0的Document。
现在，将slop改为10，因为slop比较关键，决定了两个检索词条之间的间隙大小，这时可以看到检索结果如下所示：
####################################################################
SpanFirstQuery中end指定值为 ： 10
####################################################################
####################################################################
SpanNearQuery中slop指定值为 ： 10
####################################################################
Document的内部编号为 ： 0
Document的得分为 ： 0.078204505
Document(编号) 0 的Field的信息：
Field的name : contents
Field的stringValue : 今天是我们地球的生日，对于我们每个人，在我们的宇宙中，一场空前关于我们熟悉的宇宙论的辩论激烈地展开了。
------------------------------------
Document的内部编号为 ： 1
Document的得分为 ： 0.06730772
Document(编号) 1 的Field的信息：
Field的name : contents
Field的stringValue : 谁知道宇宙空间的奥秘，在我们这些人当中？
------------------------------------
Field的name : contents
Field的stringValue : 宇宙飞船。
------------------------------------
Field的name : contents
Field的stringValue : 我们的太空宇宙。
------------------------------------
********************************************************************
本次搜索所用的时间为 125 ms
SpanNearQuery的构造方法给了一个SpanQuery[] clauses子句数组，可以使用任何继承了SpanQuery的具体实现类，当然也包括SpanNearQuery，将它们添加到子句的数组中，实现复杂的搜索。
SpanNotQuery跨度搜索
依然从构造方法看：
public SpanNotQuery(SpanQuery include, SpanQuery exclude) {
this.include = include;
this.exclude = exclude;
if (!include.getField().equals(exclude.getField()))
throw new IllegalArgumentException("Clauses must have same field.");
}
该SpanNotQuery指定了一个SpanQuery include，该include子句查询会得到一个结果的集合，设为集合A；SpanQuery exclude也可以得到一个结果的集合，设为集合B，则SpanNotQuery检索结果的集合表示为：
A-B
很好理解，就是集合的差运算。
SpanOrQuery跨度搜索
这个也很好理解，就是集合的并运算，它的构造方法如下所示：
public SpanOrQuery(SpanQuery[] clauses) {
this.clauses = new ArrayList(clauses.length);
for (int i = 0; i < clauses.length; i++) {
SpanQuery clause = clauses[i];
if (i == 0) {
field = clause.getField();
} else if (!clause.getField().equals(field)) {
throw new IllegalArgumentException("Clauses must have same field.");
}
this.clauses.add(clause);
}
}
只要把你想要检索的SpanQuery子句构造好以后，添加到SpanQuery[] clauses数组中，谈后执行SpanOrQuery跨度搜索的时候，会把每个子句得到的结果合并起来，得到一个很庞大的检索结果集。
SpanRegexQuery跨度搜索
构造该SpanQuery也很容易：
public SpanRegexQuery(Term term) {
this.term = term;
}
只需要一个Term作为参数即可。从该SpanRegexQuery的名称来看，就知道它和正则表达式有一定的联系。其实在构造好一个SpanRegexQuery以后，可以为其设置一个正则表达式，这要看你对正则表达式的运用的熟练程度如何了。
在SpanRegexQuery中定义了两个成员变量：
private RegexCapabilities regexImpl = new JavaUtilRegexCapabilities();
private Term term;
而且SpanRegexQuery实现了RegexQueryCapable接口：
public class SpanRegexQuery extends SpanQuery implements RegexQueryCapable
如果你想使用SpanRegexQuery实现跨度搜索，可以研究一下与SpanRegexQuery相关的JavaUtilRegexCapabilities类，在JavaUtilRegexCapabilities中涉及到了java.util.regex.Pattern，它可不是Lucene定义的，是第三方提供的。
