lucene入门整理

作者：梁章坪 1 / 21 4/16/2009 4:18:00 PM
1. 概述
Lucene 是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。Lucene 以其方便
使用、快速实施以及灵活性受到广泛的关注。它可以方便地嵌入到各种应用中实现针对应用
的全文索引、检索功能，本总结使用lucene--2.3.2。
2. lucene 的包结构
1、org.apache.lucene.analysis 对需要建立索引的文本进行分词、过滤等操作, 语言分析器，
主要用于的切词Analyzer 是一个抽象类，管理对文本内容的切分词规则。
2、org.apache.lucene.analysis.standard 是标准分析器
3、org.apache.lucene.document 提供对Document 和Field 的各种操作的支持。索引存储时的
文档结构管理，类似于关系型数据库的表结构。Document 相对于关系型数据库的记录对象，
Field 主要负责字段的管理。
4、org.apache.lucene.index 是最重要的包，用于向Lucene 提供建立索引时各种操作的支持。
索引管理，包括索引建立、删除等。索引包是整个系统核心，全文检索的根本就是为每个切
出来的词建索引，查询时就只需要遍历索引，而不需要去正文中遍历，从而极大的提高检索
效率。
5、org.apache.lucene.queryParser 提供检索时的分析支持。查询分析器，实现查询关键词间的
运算，如与、或、非等。
6、org.apache.lucene.search 负责检索。检索管理，根据查询条件，检索得到结果。
7、org.apache.lucene.store 提供对索引存储的支持。数据存储管理，主要包括一些底层的I/0
操作。
8、org.apache.lucene.util 提供一些常用工具类和常量类的支持
3. 索引文件格式
a) .fnm 格式 包含了Document 中所有field 名称
b) .fdt 与.fdx 格式 .fdt 文件用于存储具有Store.YES 属性的Field 的数据；.fdx 是一个索
引，用于存储Document 在.fdt 中的位置。
c) .tis 与.tii 格式 .tis 文件用于存储分词后的词条（Term），而.tii 就是它的索引文件，它
表明了每个.tis 文件中的词条的位置。
d) deletable 格式 文档被删除后，会首先在deletable 文件中留下一个记录，要真正删除时，
才将索引除去。
e) 复合索引格式 .cfs
使用IndexWriter 的useCompoundFile() 默认为True
作者：梁章坪 2 / 21 4/16/2009 4:18:00 PM
4. lucene 中主要的类
4.1. Document 文档类
4.1.1. 常用方法
方法 描述
void add(Field field) 往Document 对象中添加字段
void removeField(String name) 删除字段。若多个字段以同一个字段名存在，则删除首
先添加的字段；若不存在，则Document 保持不变
void removeFields(String name) 删除所有字段。若字段不存在，则Document 保持不变
Field getField（String name） 若多个字段以同一个字段名存在，则返回首先添加的字
段；若字段不存在，则Document 保持不变
Enumeration fields() 返回Document 对象的所有字段，以枚举类型返回
Field [] getFields(String name) 根据名称得到一个Field 的数组
String [] getValues(String name) 根据名称得到一个Field 的值的数组
4.1.2. 示例
Document doc1 = new Document();
doc1.add(new Field("name", "word1 word2 word3",
Field.Store.NO,Field.Index.TOKENIZED));
Document doc2 = new Document();
doc2.add(new Field("name", "word1 word2 word3",
Field.Store.NO,Field.Index.TOKENIZED));
4.2. Field 字段类
4.2.1. 构造方法
1) public Field(String name,String value,Store store,Index index);//直接的字符串方式
2) public Field(String name,String value,Store store,Index index,TermVector termVector);
3) public Field(String name,String value,Reader reader);//使用Reader 从外部传入
4) public Field(String name,String value,Reader reader,TermVector termVector);
5) public Field(String name,byte[] value,Store store)//使用直接的二进制byte 传入
当Field 值为二进制时，可以使用Lucene 的压缩功能将其值进行压缩。
作者：梁章坪 3 / 21 4/16/2009 4:18:00 PM
4.2.2. Store 类
静态属性 描述
Store.NO 表示该Field 不需要存储
Store.YES 表示该Field 需要存储
Store.COMPRESS 表示用压缩方式来保存这个Field 的值
4.2.3. Index 类
静态属性 描述
Index.NO 不需要索引
Index.TOKENIZED 先被分词再被索引
Index.UN_TOKENIZED 不对该Field 进行分词，但会对它进行索引
Index.NO_NORMS 对该Field 进行索引，但是不使用Analyzer，同时禁止
它参加评分，主要是为了减少内存的消耗。
4.2.4. 示例
new Field("name", "word1 word2 word3",Field.Store.YES,Field.Index.TOKENIZED)
4.3. IndexWriter 类
4.3.1. 构造方法
1) public IndexWriter(String path,Analyzer a,Boolean create)
2) public IndexWriter(File path,Analyzer a,Boolean create)
3) public IndexWriter(Directory d,Analyzer a,Boolean create)
第一个参数：索引存放在什么地方
第二个参数：分析器，继承自org.apache.lucene.analysis.Analyzer 类
第三个参数：为true 时，IndexWriter 不管目录内是否已经有索引了，一律清空，重新建立；
当为false 时，则IndexWriter 会在原有基础上增量添加索引。所以在更新的过程中，需要设
置该值为false。
4.3.2. 添加文档
public void addDocument(Document doc)
public void addDocument(Document doc,Analyzer analyzer)//使用一个开发者自定义的，而非事
先在构建IndexWriter 时声明的Analyzer 来进行分析
作者：梁章坪 4 / 21 4/16/2009 4:18:00 PM
writer.addDocument(doc1);
4.3.3. 性能参数
1) mergeFactor 控制Lucene 在把索引从内存写入磁盘上的文件系统时内存中最大的
Document 数量，同时它还控制内存中最大的Segment 数量。默认为10.
writer.setMergeFactor(10);
2) maxMergeDocs 限制一个Segment 中最大的文档数量。一个较大的maxMergeDocs 适用
于对大批量的文档建立索引，增量式的索引则应使用较小的maxMergeDocs。
writer.setMaxMergeDocs(1000);
3) minMergeDocs 用于控制内存中持有的文档数量的，它对磁盘上的Segment 大小没有任
何影响。
4.3.4. 限制Field 的长度
maxFieldLength 限制Field 的长度，默认值为10000.最大值100000 个。
public void setMaxFieldLength(int maxFieldLength)
writer.addDocument(doc1);
writer.setMaxFieldLength(100000);
writer.addDocument(doc2);
4.3.5. 复合索引格式
setUseCompoundFile(Boolean) 默认true
writer.setUseCompoundFile(true);//复合索引
writer.setUseCompoundFile(false);
4.3.6. 优化索引
writer.optimize();
将磁盘上的多个segment 进行合并，组成一个全新的segment。这种方法并不会增加建索时
的速度，反而会降低建索的速度。所以应该在建完索引后在调用这个函数
4.3.7. 示例
IndexWriter writer = new IndexWriter(path, new StandardAnalyzer(), true);
writer.addDocument(doc1);
writer.addDocument(doc2);
Sytem.out.println(writer.docCount());
writer.close();
IndexSearcher searcher = new IndexSearcher(path);
作者：梁章坪 5 / 21 4/16/2009 4:18:00 PM
Hits hits = null;
Query query = null;
QueryParser parser =new QueryParser("name", new StandardAnalyzer());
query =parser.parse("word1");
hits = searcher.search(query);
System.out.println("查找 word1 共" + hits.length() + "个结果");
4.4. Directory 类
Directory：用于索引的存放位置
a) FSDirectory.getDirectory(path, true)第二个参数表示删除掉目录内原有内容
IndexWriter writer = new IndexWriter(FSDirectory.getDirectory(path, true), new
StandardAnalyzer(), true);//删除原有索引
或
FSDirectory fsDir=FSDirectory.getDirectory(path,true);
IndexWriter writer = new IndexWriter(fsDir, new StandardAnalyzer(), true);
b) RAMDirectory 在内存中存放，读取速度快，但程序一运行结束，它的内容就不存在了
RAMDirectory ramDir=new RAMDirectory();
IndexWriter writer = new IndexWriter(ramDir, new StandardAnalyzer(), true);
或
IndexWriter writer = new IndexWriter(new RAMDirectory(), new StandardAnalyzer(), true);
4.5. IndexReader 类
IndexReader 类――索引的读取工具
4.5.1. 删除文档
IndexReader reader=IndexReader.open(path);
reader.deleteDocument(0);//删除第一个
reader.close();
4.5.2. 反删除
reader.undeleteAll();
4.5.3. 按字段删除
reader.deleteDocuments(new Term("name","word1"));
作者：梁章坪 6 / 21 4/16/2009 4:18:00 PM
若要真正物理删除，则只需使用IndexWriter 对索引optimize 一次即可！
4.5.4. 示例
IndexReader reader=IndexReader.open(path);
for(int i=0;i<reader.numDocs();i++){
System.out.println(reader.document(i));
}
System.out.println("版本："+reader.getVersion());
System.out.println("索引内的文档数量："+reader.numDocs());
//reader.deleteDocuments(new Term("name","word1"));
Term term1=new Term("name","word1");
TermDocs docs=reader.termDocs(term1);
while(docs.next())
{
System.out.println("含有所查找的"+term1+"的Document的编号
为"+docs.doc());
System.out.println("Term在文档中的出现次数"+docs.freq());
}
reader.close();
4.6. IndexModifier 类
集成了IndexWriter 的大部分功能和IndexReader 中对索引删除的功能 ------ Lucene2.0 的新
类
4.6.1. 示例
public static void main(String[] args) throws Exception {
IndexModifier modifier=new IndexModifier("C:\\Q1",new
StandardAnalyzer(),true);
Document doc1=new Document();
doc1.add(new Field("bookname","钢铁是怎样炼成的
",Field.Store.YES,Field.Index.TOKENIZED));
Document doc2=new Document();
doc2.add(new Field("bookname","山山水水
",Field.Store.YES,Field.Index.TOKENIZED));
modifier.addDocument(doc1);
modifier.addDocument(doc2);
作者：梁章坪 7 / 21 4/16/2009 4:18:00 PM
System.out.println(modifier.docCount());
modifier.setUseCompoundFile(false);
modifier.close();
IndexModifier mo=new IndexModifier("C:\\Q1",new
StandardAnalyzer(),false);
mo.deleteDocument(0);
System.out.println(mo.docCount());
mo.close();
}
4.7. IndexSearcher 类
4.7.1. 构造方法
IndexSearcher searcher = new IndexSearcher(String path);
IndexSearcher searcher = new IndexSearcher(Directory directory);
IndexSearcher searcher = new IndexSearcher(IndexReader r);
IndexSearcher searcher = new IndexSearcher(IndexReader r,Boolean closeReader);
IndexSearcher searcher = new IndexSearcher(path);
IndexSearcher searcher = new IndexSearcher(FSDirectory.getDirectory(path,false) );
4.7.2. search 方法
//返回Hits 对象
public Hits search(Query query)
public Hits search(Query query,Filter filter)
public Hits search(Query query,Sort sort)
public Hits search(Query query,Filter filter,Sort sort)
//检索只返回得分最高的Document
public TopDocs search(Query query,Filter filter,int n)
public TopDocs search(Weight weight,Filter filter,int n)
public TopFieldDocs search(Weight weight,Filter filter,int n,Sort sort)
public TopFieldDocs search(Query query,Filter filter,int n,Sort sort)
//传入HitCollector,将结果保存在HitCollector 中
public void search(Query query,HitCollector results)
public void search(Query query,Filter filter,HitCollector results)
public void search(Weight weight,Filter filter,HitCollector results)
作者：梁章坪 8 / 21 4/16/2009 4:18:00 PM
4.7.3. Searcher 的explain 方法
public Explaination explain(Query query,int doc)throws IOException
for(int i=0;i<hits.length()&&i<10;i++)
{
Document d=hits.doc(i);
System.out.println(i+" "+hits.score(i)+" "+d.get("contents"));
System.out.println(searcher.explain(query,hits.id(i)).toString())
;
}
4.7.4. 示例
IndexSearcher searcher = new IndexSearcher(path);
Hits hits = null;
Query query = null;
QueryParser parser =new QueryParser("contents", new StandardAnalyzer());
query =parser.parse("11");
hits = searcher.search(query);
System.out.println("查找 word1 共" + hits.length() + "个结果");
for(int i=0;i<hits.length()&&i<10;i++)
{
Document d=hits.doc(i);
System.out.println(d+" "+i+" "+hits.score(i)+"
"+d.get("contents"));
}
searcher.close();
4.8. Hits 类
4.8.1. 概述
Hits 类――检索结果
4.8.2. 常用方法
作者：梁章坪 9 / 21 4/16/2009 4:18:00 PM
方法名 描述
int length() 返回搜索到结果的总数量
Document doc(int i) 返回第i 个文档
int id(int i) 返回第i 个文档的内部ID 号
float score(int i) 返回第i 个文档的得分
Iterator iterator() 取得Hits 集合的遍历对象
4.8.3. 示例
for(int i=0;i<hits.length()&&i<10;i++)
{
Document d=hits.doc(i);
System.out.println(d+" "+" "+hits.score(i)+" "+d.get("contents"));
System.out.println("文档的内部ID号:" + hits.id(i));
}
4.9. QueryParser 类
4.9.1. 改变默认的布尔逻辑
Ø 默认为“或”关系
Query query = null;
QueryParser parser =new QueryParser("contents", new StandardAnalyzer());
query =parser.parse("hello world!");
System.out.println(query.toString());
Ø 改变默认布尔逻辑
Query query = null;
QueryParser parser =new QueryParser("contents", new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
query =parser.parse("hello world");//若world后加！会出错
System.out.println(query.toString());
Ø AND OR NOT – 关键字
也可以不用改变默认布尔逻辑，而直接让用户在输入关键字时指定不同词条间的布尔联系。
例如，用户输入 hello AND world 必须为大写
逻辑与：AND （大写）
逻辑或：OR （大写）
逻辑非：- 例如： hello - world
也可以是NOT 例如： hello NOT world
作者：梁章坪 10 / 21 4/16/2009 4:18:00 PM
4.9.2. 不需要分词
不进行分词，将其完整的作为一个词条进行处理，则需要在词组的外面加上引号
String queryStr="\"God helps those who help themselves\"";
QueryParser parser = new QueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
4.9.3. 设置坡度值,支持FuzzyQuery
String queryStr="\"God helps those who help themselves\"~1";//设置坡度
为1
QueryParser parser = new QueryParser("bookname",new StandardAnalyzer());
Query query=parser.parse(queryStr);
System.out.println(query.toString());
4.9.4. 设置通配符，支持WildcardQuery
String queryStr="wor?"
QueryParser parser = new QueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
4.9.5. 查找指定的Field
String queryStr="linux publishdate:2006-09-01";
QueryParser parser = new QueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
例如：要求用户选择某一方面的
作者：梁章坪 11 / 21 4/16/2009 4:18:00 PM
4.9.6. 范围的查找，支持RangeQuery
String queryStr="[1990-01-01 TO 1998-12-31]";
QueryParser parser=new QueryParser("publishdate",
new StandardAnalyzer());
Query query=parser.parse(queryStr);
System.out.println(query.toString());
输出结果为publishdate:[081xmghs0 TO 0boeetj3z]
因为建立索引时，如果按照日期表示的字符串来进行索引，实际上比较的是字符串的字典顺
序。而首先将日期转为以毫秒计算的时间后，则可以精确地比较两个日期的大小了。于是，
lucene 提供DateTools 工具，用来完成其内部对时间的转化和处理，将毫秒级的时间转化为
一个长字符串来进行表示，并进行索引。所以，遇到日期型数据时，最好用DateTools 进行
转换，再进行索引！
4.9.7. 现在还不支持SpanQuery
4.10. MultiFieldQueryParser 类--多域搜索
//在不同的Field 上进行不同的查找
public static Query parse(String []queries,String[] fields,Analyzer analyzer)throws ParseException
//在不同的Field 上进行同一个查找，指定它们之间的布尔关系
public static Query parse(String query,String[] fields,BooleanClause.Occur[] flags,Analyzer
analyzer) throws ParseException
//在不同的Field 上进行不同的查找，指定它们之间的布尔关系
public static Query parse(String []queries,String [] fields,BooleanClause.Occur[] flags,Analyzer
analyzer)throws ParseException
String [] queries={"钢", "[10 TO 20]"};
String[] fields={“bookname”,”price”};
BooleanClause.Occur[]
clauses={BooleanClause.Occur.MUST,BooleanClause.Occur.MUST};
Query query=MultiFieldQueryParser.parse(queries,fields,clauses,new
StandardAnalyzer());
System.out.println(query.toString());
4.11. MultiSearcher 类--多个索引搜索
IndexSearcher searcher1=new IndexSearcher(path1);
作者：梁章坪 12 / 21 4/16/2009 4:18:00 PM
IndexSearcher searcher2=new IndexSearcher(path2);
IndexSeacher [] searchers={searcher1,seacher2};
MultiSearcher searcher=new MultiSearcher(searchers);
Hits hits=searcher.search(query);
for(int i=0;i<hits.length();i++){
System.out.println(hits.doc(i));
}
4.12. ParalellMultiSearcher 类---多线程搜索
IndexSearcher searcher1=new IndexSearcher(path1);
IndexSearcher searcher2=new IndexSearcher(path2);
IndexSearcher [] searchers={searcher1,searcher2};
ParallelMultiSearcher searcher=new ParallelMultiSearcher(searchers);
long start=System.currentTimeMillis();
Hits hits=searcher.search(query);
long end=System.currentTimeMillis();
System.out.println((end-start)+"ms");
5. 排序
5.1. Sort 类
public Sort()
public Sort(String field)
public Sort(String field,Boolean reverse) //默认为false，降序排序
public Sort(String[] fields)
public Sort(SortField field)
public Sort(SortField[] fields)
Sort sort=new Sort(“bookname”);按照“bookname“这个Field值进行降序排序
Sort sort=new Sort(“bookname”,true) //升序排序
Sort sort=new Sort(new String[]{“bookNumber”,”bookname”,”publishdate”});
按照三个Field进行排序，但无法指定升序排序，所以用SortField
5.2. SortField 类
public SortField(String field)
public SortField(String field,Boolean reverse)
public SortField(String field,int type) //type表示当前Field值的类型
public SortField(String field,int type,boolean reverse) //默认为false，
升序
作者：梁章坪 13 / 21 4/16/2009 4:18:00 PM
Field值的类型：SortField.STRING、SortField.INT、SortField.FLOAT
SortField sf1=new SortField(“bookNumber”,SortField.INT,false);
SortField sf2=new SortField(“bookname”,SortField.STRING,false);
5.3. 指定排序的法则
5.3.1. 按照文档的得分降序排序
Hits hits=searcher.search(query,Sort.RELEVANCE);
5.3.2. 按文档的内部ID 升序排序
Hits hits=searcher.search(query, Sort.INDEXORDER);
5.3.3. 按照一个Field 来排序
Sort sort=new Sort();
SortField sf=new SortField(“bookNumber”,SortField.INT,false);
sort.setSort(sf);
Hits hits=searcher.search(query,sort);
5.3.4. 按照多个Field 来排序
Sort sort=new Sort();
SortField sf1=new SortField(“bookNumber”,SortField.INT,false);//升序
SortField sf2=new SortField(“publishdate”,SortField.STRING,true);//
降序
sort.setSort(new SortField[]{sf1,sf2});
Hits hits=searcher.search(query,sort);
5.3.5. 改变SortField 中的Locale 信息
String str1=”我”; String str2=”你”;
Collator co1=Collator.getInstance(Locale.CHINA);
Collator co2=Collator.getInstance(Locale.JAPAN);
System.out.println(Locale.CHINA+”:”+co1.compare(str1，str2));
System.out.println(Locale.JAPAN+”:”+co2.compare(str1,str2));
输出结果为：
zh_CN:1
ja_JP:-1
作者：梁章坪 14 / 21 4/16/2009 4:18:00 PM
所以
public SortField(String field,Locale locale)
public SortField(String field,Locale locale,boolean reverse)
6. 过滤器
使用public Hits search(Query query,Filter filter)
（1）简单过滤
Hits hits=searcher.search(query,new AdvancedSecurityFilter());//过滤掉
securitylevel为0的结果
（2）范围过滤—RangeFilter
只显示中间的
RangeFilter filter=new
RangeFilter(“publishdate”,”1970-01-01”,”1998-12-31”,true,true”);
Hits hits=searcher.search(query,filter);
无上边界
public static RangeFilter More(String fieldname,String lowerTerm)
无下边界
public static RangeFilter Less(String fieldname,String upperTerm)
(3)在结果中查询QueryFilter
RangeQuery q=new RangeQuery(new Term(“publicshdate”,”1970-01-01”),
new Term(“publishdate”,”1999-01-01”),true);
QueryFilter filter=new QueryFilter(q);
Hits hits=searcher.search(query,filter);
7. 分析器Analysis
7.1. 自带分析器和过滤器
Ø 标准过滤器：StandardAnalyzer
Ø 大小写转换器：LowerCaseFilter
Ø 忽略词过滤器：StopFilter
public StopFilter(TokenStream input,String [] stopWords)
public StopFilter(TokenStream in,String [] stopWords,boolean ignoreCase)
public StopFilter(TokenStream input,Set stopWords,boolean ignoreCase)
public StopFilter(TokenStream in, Set stopWords)
其中，参数TokenStream 代表当前正在进行处理的流；String 类型的数组代表一个用数组表
示的忽略词集合；Set 类型的参数与String 一样，是用来表示忽略词集合的；boolean 表示当
作者：梁章坪 15 / 21 4/16/2009 4:18:00 PM
与忽略词集合中的词进行匹配时，是否需要忽略大小写。
Ø 长度过滤器：LengthFilter
Ø PerFieldAnalyzerWrapper
Ø WhitespaceAnalyzer
String str="str1 str2 str3";
StringReader reader=new StringReader(str);
Analyzer anlyzer=new WhitespaceAnalyzer();
TokenStream ts=anlyzer.tokenStream("", reader);
Token t=null;
while( (t=ts.next())!=null ){
System.out.println(t.termText());
}
7.2. 第三方过分析器
Ø 单字分词
Ø 二分法：CJKAnalyzer、中科院ICTCLAS 分词、JE 分词
Ø 词典分词
7.2.1. JE 分词用法
7.2.1.1. 示例
import jeasy.analysis.MMAnalyzer;
IndexWriter writer = new IndexWriter(INDEX_STORE_PATH, new MMAnalyzer()
, true);
String str=" Lucene是一个全文检索引擎的架构，"+
"提供了完整的查询引擎和索引引擎。Lucene以其方便使用、快" +
"速实施以及灵活性受到广泛的关注。它可以方便地嵌入到各种应用" +
"中实现针对应用的全文索引、检索功能，本总结使用lucene--2.3.2。";
MMAnalyzer analyzer=new MMAnalyzer();
try{
System.out.println(analyzer.segment(str, "|"));
}
catch(Exception e)
{
e.printStackTrace();
}
输出结果：lucene|一个|全文|检索|引擎|架构|提供|完整|查询|。。。。
作者：梁章坪 16 / 21 4/16/2009 4:18:00 PM
7.2.1.2. 设定正向最大匹配的字数
MMAnalyzer analyzer=new MMAnalyzer(4);
7.2.1.3. 添加新词
MMAnalyzer.addWord(String word);
MMAnalyzer.addDictionary(Reader reader);
MMAnalyzer analyzer=new MMAnalyzer();
MMAnalyzer.addWord("迈克尔雷第");
8. 索引的合并
RAMDirectory RAMDir=new RAMDirectory();
IndexWriter writer = new IndexWriter(RAMDir, new StandardAnalyzer(),
true);//删除原有索引
IndexWriter writer2=new
IndexWriter(FSDirectory.getDirectory(path,true),
new StandardAnalyzer(), true);
writer.addDocument(doc1);
writer2.addDocument(doc2);
writer.close();
writer2.addIndexes(new Directory[]{RAMDir});
writer2.close();
注意：在合并前一定要先关闭要加的索引器。
9. 各种Query
9.1. 概述
query.toString()查看原子查询
9.2. 使用特定的分析器搜索
IndexSearcher searcher = new IndexSearcher(path );
Hits hits = null;
作者：梁章坪 17 / 21 4/16/2009 4:18:00 PM
Query query = null;
QueryParser parser =new QueryParser("contents", new StandardAnalyzer());
query =parser.parse("11 a and hello");
hits=searcher.search(query); //查找 name:11 name:hello 共1个结果
System.out.println("查找 "+query.toString()+" 共" + hits.length() + "个
结果");
9.3. 按词条搜索—TermQuery
Query query = null;
query=new TermQuery(new Term("name","word1 a and"));
hits=searcher.search(query);// 查找 name:word1 a and 共0个结果
System.out.println("查找 "+query.toString()+" 共" + hits.length() + "个
结果");
9.4. 按“与或”搜索—BooleanQuery
1.和： MUST 与MUST_NOT
2.或： SHOULD 与SHOULD
3.A 与B 的并集－B MUST 与MUST_NOT
Query query1=null;
Query query2=null;
BooleanQuery query=null;
query1=new TermQuery(new Term("name","word1"));
query2=new TermQuery(new Term("name","word2"));
query=new BooleanQuery();
query.add(query1,BooleanClause.Occur.MUST);
query.add(query2,BooleanClause.Occur.MUST_NOT);
9.5. 在某一范围内搜索—RangeQuery
Term beginTime=new Term("time","200001");
Term endTime=new Term("time","200005");
RangeQuery query=null;
query=new RangeQuery(beginTime,endTime,false);//不包含边界值
9.6. 使用前缀搜索—PrefixQuery
Term pre1=new Term("name","wor");
PrefixQuery query=null;
query = new PrefixQuery(pre1);
作者：梁章坪 18 / 21 4/16/2009 4:18:00 PM
9.7. 短语搜索—PhraseQuery
a)默认坡度为0
PhraseQuery query = new PhraseQuery();
query.add(new Term(“bookname”,”钢”));
query.add(new Term(“bookname”,”铁”));
Hits hits=searcher.search(query); //搜索“钢铁”短语，而非“钢”和“铁”
b)设置坡度，默认为0
PhraseQuery query = new PhraseQuery();
query.add(new Term(“bookname”,”钢”));
query.add(new Term(“bookname”,”铁”));
query.setSlop(1);
Hits hits=searcher.search(query);//搜索“钢铁”或“钢*铁”中含一字
9.8. 多短语搜索—MultiPhraseQuery
a)
MultiPhraseQuery query=new MultiPhraseQuery();
//首先向其中加入要查找的短语的前缀
query.add(new Term(“bookname”,”钢”));
//构建3个Term，作为短语的后缀
Term t1=new Term(“bookname”,”铁”);
Term t2=new Term(“bookname”,”和”);
Term t3=new Term(“bookname”,”要”);
//再向query中加入所有的后缀，与前缀一起，它们将组成3个短语
query.add(new Term[]{t1,t2,t3});
Hits hits=searcher.search(query);
for(int i=0;i<hits.length();i++)
System.out.println(hits.doc(i));
b)
MultiPhraseQuery query=new MultiPhraseQuery();
Term t1=new Term(“bookname”,”钢”);
Term t2 = new Term(“bookname”,”和”);
query.add(new Term[]{t1,t2});
query.add(new Term(“bookname”,”铁”));
c)
MultiPhraseQuery query=new MultiPhraseQuery();
Term t1=new Term(“bookname”,”钢”);
Term t2 = new Term(“bookname”,”和”);
query.add(new Term[]{t1,t2});
query.add(new Term(“bookname”,”铁”));
Term t3=new Term(“bookname”,”是”);
Term t4=new Term(“bookname”,”战”);
作者：梁章坪 19 / 21 4/16/2009 4:18:00 PM
query.add(new Term[]{t3,t4});
9.9. 模糊搜索—FuzzyQuery
使用的算法为levenshtein 算法，在比较两个字符串时，将动作分为3 种：
l 加一个字母
l 删一个字母
l 改变一个字母
FuzzyQuery query=new FuzzyQuery(new Term(“content”,”work”));
public FuzzyQuery(Term term)
public FuzzyQuery(Term term,float minimumSimilarity)throws
IllegalArgumentException
public FuzzyQuery(Term term,float minimumSimilarity,int
prefixLength)throws IllegalArgumentException
其中minimumSimilarity 为最小相似度，越小则文档的数量越多。默认为0.5.其值必须<1.0
FuzzyQuery query=new FuzzyQuery(new Term(“content”,”work”),0.1f);
其中prefixLength 表示要有多少个前缀字母必须完全匹配
FuzzyQuery query=new FuzzyQuery(new Term(“content”,”work”),0.1f,1);
9.10. 通配符搜索—WildcardQuery
* 表示0 到多个字符
? 表示一个单一的字符
WildcardQuery query=new WildcardQuery(new Term(“content”,”?qq*”));
9.11. 跨度搜索
9.11.1. SpanTermQuery
效果和TermQuery 相同
SpanTermQuery query=new SpanTermQuery(new Term(“content”,”abc”));
9.11.2. SpanFirstQuery
从Field 内容的起始位置开始，在一个固定的宽度内查找所指定的词条
SpanFirstQuery query=new SpanFirstQuery(new Term(“content”,”abc”),3);//
是第3个word，不是byte
作者：梁章坪 20 / 21 4/16/2009 4:18:00 PM
9.11.3. SpanNearQuery
SpanNearQuery 相当与PhaseQuery
SpanTermQuery people=new SpanTermQuery(new Term(“content”,”mary”));
SpanTermQuery how=new SpanTermQuery(new Term(“content”,”poor”));
SpanNearQuery query=new SpanNearQuery(new
SpanQuery[]{people,how},3,false);
9.11.4. SpanOrQuery
把所有SpanQuery 的结果合起来
SpanTermQuery s1=new SpanTermQuery(new Term(“content”,”aa”);
SpanTermQuery s2=new SpanTermQuery(new Term(“content”,”cc”);
SpanTermQuery s3=new SpanTermQuery(new Term(“content”,”gg”);
SpanTermQuery s4=new SpanTermQuery(new Term(“content”,”kk”);
SpanNearQuery query1=new SpanNearQuery(new
SpanQuery[]{s1,s2},1,false);
SpanNearQuery query2=new SpanNearQuery(new
SpanQuery[]{s3,s4},3,false);
SpanOrQuery query=new SpanOrQuery(new SpanQuery[]{query1,query2});
9.11.5. SpanNotQuery
从第1 个SpanQuery 的查询结果中，去掉第2 个SpanQuery 的查询结果
SpanTermQuery s1=new SpanTermQuery(new Term(“content”,”aa”);
SpanFirstQuery query1=new SpanFirstQuery(s1,3);
SpanTermQuery s3=new SpanTermQuery(new Term(“content”,”gg”);
SpanTermQuery s4=new SpanTermQuery(new Term(“content”,”kk”);
SpanNearQuery query2=new SpanNearQuery(new
SpanQuery[]{s3,s4},4,false);
SpanNotQuery query=new SpanNotQuery(query1,query2);
9.12. RegexQuery—正则表达式的查询
String regex="http://[a-z]{1,3}\\.abc\\.com/.*";
RegexQuery query=new RegexQuery(new Term("url",regex));
作者：梁章坪 21 / 21 4/16/2009 4:18:00 PM
10. 评分机制
10.1. 概述
通过searcher.explain(Query query, int doc)方法可以查看某个文档的得分的具体构成。
在Lucene 中score 简单说是由 tf * idf * boost * lengthNorm 计算得出的。
1) tf：Term Frequency.词条频率，是查询的词在文档中出现的次数的平方根
2) idf：表示反转文档频率，Math.log(numDocs/(double)(docFreq+1))+1.0 docDocs 表示当
前检索的词条的文档总数， numDocs 表示索引中总共的文档数量
3) boost：激励因子，可以通过setBoost 方法设置，需要说明的通过field 和doc 都可以设
置，所设置的值会同时起作用 。默认为1.boost 的值是在索引建立的时候已经写入了，
而不像其他计算得分的因子是在查询时实时得出的。因此，一旦boost 值被写入，就不
能修改它，除非重新建立文档索引。
4) lengthNorm：是由搜索的field 的长度决定了，越长文档的分值越低。
11. Lucene 的索引“锁”
1. write.lock
2. commit.lock