lucene类解析

1.lucene中主要的类

1.1.Document文档类

1.1.1.常用方法

1.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));

1.2.Field字段类

1.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的压缩功能将其值进行压缩。

1.2.2.Store类

1.2.3.Index类

1.2.4.示例

new Field("name", "word1 word2

word3",Field.Store.YES,Field.Index.TOKENIZED)

1.3.IndexWriter类

1.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。

1.3.

2.添加文档

public void addDocument(Document doc)

public void addDocument(Document doc,Analyzer analyzer)//使用一个开发者自定义的，而非事先在构建IndexWriter时声明的Analyzer来进行分析writer.addDocument(doc1);

1.3.3.性能参数

1)mergeFactor控制Lucene在把索引从内存写入磁盘上的文件系统时内存中最

大的Document数量，同时它还控制内存中最大的Segment数量。默认为10.

writer.setMergeFactor(10);

2)maxMergeDocs限制一个Segment中最大的文档数量。一个较大的

maxMergeDocs适用于对大批量的文档建立索引，增量式的索引则应使用较小的maxMergeDocs。

writer.setMaxMergeDocs(1000);

3)minMergeDocs用于控制内存中持有的文档数量的，它对磁盘上的Segment

大小没有任何影响。

1.3.4.限制Field的长度

maxFieldLength限制Field的长度，默认值为10000.最大值100000个。

public void setMaxFieldLength(int maxFieldLength)

writer.addDocument(doc1);

writer.setMaxFieldLength(100000);

writer.addDocument(doc2);

1.3.5.复合索引格式

setUseCompoundFile(Boolean) 默认true

writer.setUseCompoundFile(true);//复合索引

writer.setUseCompoundFile(false);

1.3.6.优化索引

writer.optimize();

将磁盘上的多个segment进行合并，组成一个全新的segment。这种方法并不会增加建索时的速度，反而会降低建索的速度。所以应该在建完索引后在调用这个函数

1.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);

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() + "个结果");

1.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);

1.5.IndexReader类

IndexReader类――索引的读取工具

1.5.1.删除文档

IndexReader reader=IndexReader.open(path);

reader.deleteDocument(0);//删除第一个

reader.close();

1.5.

2.反删除

reader.undeleteAll();

1.5.3.按字段删除

reader.deleteDocuments(new Term("name","word1"));

若要真正物理删除，则只需使用IndexWriter对索引optimize一次即可！

1.5.4.示例

IndexReader reader=IndexReader.open(path);

for(int i=0;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();

1.6.IndexModifier类

集成了IndexWriter的大部分功能和IndexReader中对索引删除的功能 ------ Lucene2.0的新类

1.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);

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();

}

1.7.IndexSearcher类

1.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) );

1.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)

1.7.3.Searcher的explain方法

public Explaination explain(Query query,int doc)throws IOException

for(int i=0;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()) ;

}

1.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

{

Document d=hits.doc(i);

System.out.println(d+" "+i+" "+hits.score(i)+"

"+d.get("contents"));

}

searcher.close();

1.8.Hits类

1.8.1.概述

Hits类――检索结果

1.8.

2.常用方法

1.8.3.示例

for(int i=0;i

{

Document d=hits.doc(i);

System.out.println(d+" "+" "+hits.score(i)+" "+d.get("contents"));

System.out.println("文档的内部ID号:" + hits.id(i));

}

1.9.QueryParser类

1.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

1.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());

1.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());

1.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());

1.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());

例如：要求用户选择某一方面的

1.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进行转换，再进行索引！

1.9.7.现在还不支持SpanQuery

1.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());

1.11.MultiSearcher类--多个索引搜索

IndexSearcher searcher1=new IndexSearcher(path1);

IndexSearcher searcher2=new IndexSearcher(path2);

IndexSeacher [] searchers={searcher1,seacher2};

MultiSearcher searcher=new MultiSearcher(searchers);

Hits hits=searcher.search(query);

for(int i=0;i

System.out.println(hits.doc(i));

}

1.1

2.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");

基于Lucene的语段模糊匹配中文检索系统设计与实现

(责任编辑:陈和榜) 浙江理工大学学报,第26卷,第1期,2009年1月 Journal of Zhejiang Sci 2Tech U niversity Vol.26,No.1,J an.2009 文章编号:167323851(2009)0120109205收稿日期:2008-05-29 作者简介:黄　珏(1982-　 ),女,浙江杭州人,助理研究员,主要从事搜索引擎,数字图书馆,软件工程方面的研究。基于Lucene 的语段模糊匹配中文检索系统设计与实现 黄　珏,黄志远 (浙江理工大学科技与艺术学院,杭州311121) 摘　要:为提高图书馆中文信息检索的精确度和有效性,设计了基于L ucene 的语段模糊匹配中文检索系统。其采用了自然语言处理中的词语切分技术,使输入条件可以直接通过自然语言的方式提交,同时针对语段匹配的实际问题情境,设计了一种新的结果有效性判别模型,提高了检索结果相似度的科学性和准确性。经过多次实验结果的统计,搜索结果有效性可提高12%。 关键词:L ucene ;语段;中文检索;有效性判别 中图分类号:TP393 文献标识码:A 0　引　言 信息检索技术在图书馆领域的应用是举足轻重的,然而,当前图书馆用户在检索资料的时候,常常会遇到这样的情况:记得一篇文章或一本书刊中的某段话,却记不清标题、作者、出版社之类的特征信息。凭着对这个语段的记忆,选取某些关键字/词进行查询,又无法快速准确的找到目标答案。个别数字资源自带的搜索引擎具有全文检索功能,允许用户输入一个语段来进行查询,但是查全率和查准率差强人意:要求输入条件与文档内容完全匹配,或者查询结果不能很好地对应用户感兴趣的内容。 首先,基于关键字/词和逻辑表达式的检索方式不能全面地反映用户的需求。由于用户输入的关键字/词之间,往往不存在任何联系,因此检索条件本身无法清晰表达用户的真正含义[1]。 其次,简单的关键字/词匹配,往往输出大量的文档,而真正相关的文本却很少,使得用户耗费很多的时间和精力处理一些不相关的结果。 因此建立一种基于语段模糊匹配的中文检索系统,为用户提供更为细致和有效的帮助是必要的。目前检索系统的开发平台并不多见,本文采用了一个较为实用的检索引擎架构———L ucene ,它结构精巧,功能强大,便于嵌入各种应用。在L ucene 良好的架构之上,本文结合最大正向匹配的中文分词算法,通过对L ucene 评分机制的改进,建立了一个新的文档有效性二次判别模型,设计了一个多维非线性计算函数得到搜索结果的相似度,并对搜索结果按照有效性来进行排序。与现有的图书馆中文检索系统相比,具有以下改进:输入全文中的某个语段(只需基本一致),即可搜索到与之相关的书籍/文章;检索的精度及结果集的有效性较一般检索系统有所提高。 1　基于Lucene 的语段模糊匹配中文检索系统设计 1.1　开放源码的搜索引擎(L ucene ) L ucene 是apache 软件基金会J akarta 项目组的子项目,是一个开放源代码的全文检索引擎工具包,它不是一个完整的全文检索引擎,而是一个全文检索引擎的架构[2],提供了完整的查询引擎和索引引擎,部分

一种基于Lucene的中文全文检索系统

—94— 一种基于Lucene 的中文全文检索系统 苏潭英1，郭宪勇2，金 鑫3 （1. 解放军信息工程大学电子技术学院，郑州 450004；2. 北京飞燕技术公司，北京 100072；3. 解放军通信指挥学院，武汉 430010）摘 要：在开源全文索引引擎Lucene 的基础上，设计了一个中文全文检索系统模型，该模型系统由7个模块组成，索引模块、检索模块是其中的核心部分。论述了模型的整体结构，分析设计了索引及检索模块，通过具体的索引技术和检索技术来提高整个系统的检索效率。该系统增加了加密模块，实现对建立的全文索引进行加密处理，增强了信息的安全性。 关键词：全文检索；Lucene ；倒排索引 Chinese Full-text Retrieval System Based on Lucene SU Tan-ying 1, GUO Xian-yong 2, JIN Xin 3 (1. Institute of Electronic Technology, PLA Information Engineering University, Zhengzhou 450004; 2. Technology Company of Beijing Feiyan, Beijing 100072; 3. Institute of PLA Communication Command, Wuhan 430010) 【Abstract 】This paper proposes a model of Chinese full-text retrieval system based on Lucene which is an open source full-text retrieval engine,and expatiates its frame. This model is composed of seven modules, among which the index module and the search module are the core parts. It designs them concretely, and improves the search efficiency of the full-text retrieval system with index technology and search technology. The system model concludes an encryption module to encrypt the index and increases the system security. 【Key words 】full-text retrieval; Lucene; inverse index 计 算 机 工 程Computer Engineering 第33卷 第23期 Vol.33 No.23 2007年12月 December 2007 ·软件技术与数据库· 文章编号：1000—3428(2007)23—0094—03 文献标识码：A 中图分类号：TP391 1 中文全文检索系统 全文检索技术是一个最普遍的信息查询应用，人们每天在网上使用Google 、百度等搜索引擎查找自己所需的信息，这些搜索引擎的核心技术之一就是全文检索。随着文档处理电子化、无纸化的发展，图书馆、新闻出版、企业甚至个人的电子数据激增，如何建立数据库、管理好自己的数据，是亟待解决的问题，而全文检索是其中一个非常实用的功能。全文检索产品实际上是一个内嵌该项技术的数据库产品[1]。 西文的全文检索已有许多成熟的理论与方法，其中，开放源代码的全文检索引擎Lucene 是Apache 软件基金会Jakarta 项目组的一个子项目，它的目的是为软件开发人员提供一个简单易用的工具包，方便在目标系统中实现全文检索的功能。很多项目使用了Lucene 作为其后台的全文索引引擎，比较著名的有： (1)Jive ：Web 论坛系统； (2)Cocoon ：基于XML 的Web 发布框架，全文检索部分使用了Lucene ； (3)Eclipse ：基于Java 的开放开发平台，帮助部分的全文索引使用了Lucene 。 Lucene 不支持中文，但可以通过扩充它的语言分析器实现对中文的检索。本文在深入学习研究Lucene 的前提下，设计了一个中文的全文检索系统，对其核心的索引模块和检索模块进行了阐释，并添加了加密模块对索引信息加密，增强了系统的安全性。 2 系统的总体结构 本模型总体上采用了Lucene 的架构。Lucene 的体系结构如表1所示，它的源代码程序由7个模块组成。 表1 Lucene 的组成结构 模块名 功能 org.apache.Lucene.search 搜索入口 org.apache.Lucene.index 索引入口 org.apache.Lucene.analysis 语言分析器 org.apache.Lucene.queryParser 查询分析器 org.apache.Lucene.document 存储结构 org.apache.Lucene.store 底层IO/存储结构 org.apache.Lucene.util 一些公用的数据结构 本文通过扩充Lucene 系统来完成中文的全文检索系统，Lucene 包含了大量的抽象类、接口、文档类型等，需要根据具体应用来定义实现，本文对其作了如下扩充修改： (1)按照中文的词法结构来构建相应的语言分析器。Lucene 的语言分析器提供了抽象的接口，因此，语言分析(analyser)是可以定制的。Lucene 缺省提供了2个比较通用的分析器SimpleAnalyser 和StandardAnalyser ，但这2个分析器缺省都不支持中文，因此，要加入对中文语言的切分规则，需要对其进行修改。 (2)按照被索引的文件的格式对不同类型的文档进行解析，进而建立全文索引。例如HTML 文件，通常需要把其中的内容分类加入索引，这就需要从org.apache.lucene.子document 中定义的类Document 继承，定义自己的HTMLDocument 类，然后将之交给org. apache.lucene.index 模块写入索引文件。Lucene 没有规定数据源的格式，只提供 作者简介：苏潭英(1981－)，女，硕士研究生，主研方向：数据库全文检索；郭宪勇，高级工程师；金 鑫，硕士研究生 收稿日期：2007-01-10 E-mail ：sutanyingwendy@https://www.doczj.com/doc/2f10731902.html,

lucene 版本变动总结

3.1 1. 性能提升 2. ReusableAnalyzerBase使得跟容易让TokenStreams 可重用 3. 改进分析器的功能，包括对Unicode的支持(Unicode 4)、CharTermAttribute、对象重用等 4. ConstantScoreQuery允许直接封装Query 对象 5. 可通过IndexWriterConfig 对IndexWriter 进行配置 6. IndexWriter.getReader 被IndexReader.open(IndexWriter) 所替换. 7. 废弃了MultiSearcher；ParallelMultiSearcher被直接吸收到IndexReader 类中 8. 在64位的Windows 和Solaris JVMs, MMapDirectory 作为默认的FSDirectory.open 的实现 9. 新的TotalHitCountCollector用来获取索引的命中数 10. ReaderFinishedListener API 用来清除外部缓存 3.2 1、全新的分组模块，位于lucene/contrib/grouping 使得搜索结果可通过单值的索引域进行分组 2、新的IndexUpgrader 工具，用来转换老格式的索引到当前的版本 3、实现一个新的Directory ——NRTCachingDirectory ，用来在内存中缓存一些小的segments，以减少应用对IO的负载过高，更快速的NRT 再次打开的效率 4、新的Collector 实现——CachingCollector，用来收集搜索命中率（文档ID和分值） 5、可使用IndexWriter 新的addDocuments 和updateDocuments 来批量创建和更新文档的索引 6、新的默认索引合并策略——TieredMergePolicy，更高效的合并非连续的segments，详见https://www.doczj.com/doc/2f10731902.html,/merging 7、修复了NumericField 在加载已存储文档时没正确返回的问题 Deleted terms are now applied during flushing to the newly flushed segment, which is more efficient than having to later initialize a reader for that segment. 3.3 1、固定打开的文件句柄泄漏在很多地方代码。现在MockDirectoryWrapper（在测试框架）跟踪所有打开的文件、包括锁，并且如果测试失败，释放所有这些失败。 2、拼写检查suggest模块现在包括提示/自动完成功能、有三种实现：Jaspell，三元特里和有限状态https://www.doczj.com/doc/2f10731902.html,/question/554168_155187 3、改进MMapDirectory（现在也是默认的实现通过FSDirectory.open在64位Linux）返回 4、NRTManager简化处理近乎实时搜索与多个搜索线程，允许应用程序来控制索引变化必须是可见的哪个搜索请求。 5、TwoPhaseCommitTool便于执行多资源两阶段提交，其中包括的IndexWriter。 6、默认合并策略，TieredMergePolicy，在默认情况下有一个新方法（套/

基于Lucene的网站全文搜索的设计与实现.

科技情报开发与经济 文章编号：１００５－６０３３（２００５）１５－０２４２－０３ ＳＣＩ／ＴＥＣＨＩＮＦＯＲＭＡＴＩＯＮＤＥＶＥＬＯＰＭＥＮＴ＆ＥＣＯＮＯＭＹ２００５年第１５卷第１５期 收稿日期：２００５－０６－０３ 基于Ｌｕｃｅｎｅ的网站全文搜索的设计与实现 陈庆伟１，刘 军２ （１．山西省网络管理中心，山西太原，０３０００１；２．山西省科技情报研究所，山西太原，０３０００１）摘要：Ｌｕｃｅｎｅ是一个基于Ｊａｖａ技术的开放源代码全文索引引擎工具包，它可以方便 地嵌入到各种应用中实现针对应用的全文索引／检索功能。利用Ｌｕｃｅｎｅ的ＡＰＩ可以比较方便地为一个网站提供全文搜索功能。探讨了如何使用Ｌｕｃｅｎｅ建造一个通用的Ｗｅｂ站点全文搜索工具，并对在构建系统中应注意的若干问题进行了探讨。关键词：全文搜索；Ｌｕｃｅｎｅ；Ｊａｖａ中图分类号：ＴＰ３９３．０７文献标识码：Ａ 在构建一个信息类Ｗｅｂ站点的时候，站点的全文搜索功能是必备的功能之一。一般站点的信息内容都存储在各种数据库系统中，并使用数据库提供的检索和查询功能构建网站的搜索功能。但随着信息的累‘％ｋｅｙｗｏｒｄ％’查询构成的数据检索性能将积，使用数据库中的类似ｌｉｋｅ急剧下降，因此，只使用数据库查询进行全文检索并不是一个好的解决它可以方便方案。Ｌｕｃｅｎｅ是一个基于Ｊａｖａ技术的全文索引引擎工具包，

地嵌入到各种应用中实现针对应用的全文索引／检索功能。例如Ｌｕｃｅｎｅ可以快速实现一个简单、功能强大的数据全文检索系统。 ＰＤＦＷｏｒｄ ＸＳＬＴ 格式化 各种输出 Ｔｅｘｔ ＸＭＬ输出 ＸＭＬ格式 ＸＭＬ中间格式 ＤＢＬｕｃｅｎｅＤＢ １设计目标 全文检索系统的主要功能就是为信息资料提供全文索引和查询。对 其他 专业格式 图１ 接口的实现示意图 于一个以提供信息资料为主要目的网站来说，网站的全文检索系统是必备功能之一。但对于小型的信息网站来说，购置全文检索系统的代价经‘ｋｅｙｗｏｒｄ’查询来代替全文检索常是昂贵的。如果只使用数据库的Ｌｉｋｅ

用lucene实现在一个(或者多个)字段中查找多个关键字

用lucene实现在一个(或者多个)字段中查找多个关键字 最近跟着师兄们做个项目，我的任务就是负责做个“全文检索”的小模块。用到了Lucene 的索引，下面的是其中的用Lucene实现在索引的一个字段(比如文章内容字段)进行查找多个关键字的实例代码。 1.Lucene说明 Lucene是非常优秀的成熟的开源的免费的纯java语言的全文索引检索工具包。 Lucene的的强项在“建立索引”和”搜索“，而不是实现具体的”分词“。Lucene支持对生成索引的进行”增，删，改，查“操作，这比自己建立的索引有了很大的进步。 可以使用专门的分词程序进行分词，在分词的结果上用Lucene建立索引。 2.用Lucene实现在一个或者多个字段中的检索 主要是函数：MultiFieldQueryParser.parse(String[] query,String[] field,Occur[] occ,Analyzer analyzer); 1)query：要查找的字符串数组 2)field：要查找的字符串数组对应的字段（当然有可以相同的） 3)occ：表示对应字段的限制。有三种：Occur.MUST(必须有)，Occur.MUST_NOT(必须没有)，Occur.SHOULD(应该) 4)analyzer：对查询数据的分析器，最好与建立索引时用的分析器一致 3.代码示例 下面这个程序可以实现在一个字段“contents”中查找多个关键字。稍加修改也可以在多个字段查找多个关键字。 import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.queryParser.MultiFieldQueryParser; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query;

lucene基础学习

搜索引擎Lucene 第一章Lucene简介 Lucene是apache软件基金会jakarta项目组的一个子项目，是一个开放源代码[的全文检索引擎工具包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。 第二章lucene索引的建立 的五个基础类 索引的建立，Lucene 提供了五个基础类，分别是Document, Field, IndexWriter, Analyzer, Directory。以下是他们的用途： Document Document的含义为文档，在Lucene中，它代表一种逻辑文件。Lucene本身无法对物理文件建立索引，而只能识别并处理Document的类型文件。Lucene从Document取出相关的数据源并根据属性配置进行相应的处理。 Field 对象是用来描述一个文档的某个属性的 lucene中的field也具有一些特定的类型如

在中，Field内部包含两个静态的内部类分别是Store和Index详细的描述了Field的属性，它们分别表示Field的储存方式和索引方式。 Store类有3个公有的静态属性： :表示该Field不需要储存。 :表示该Field需要储存。 :表示使用压缩方式来保存这个Field的值。 Index有4个公有的静态属性： :表示该Field不需要索引，也就是用户不需要去查找该Field的值。 :表示该Field先被分词再被索引。 TOKENIZED:表示不对该Field进行分词，但是要对他进行索引，也就是该Field会被用户查找。 :表示对该Field进行索引，但是不使用Analyzer，同时禁止它参加评分，主要是为了减少内存的消耗。 Analyzer

Lucene初级教程

Lucene初级教程 2007-12-26 15:24 点击次数：0 次 1 lucene简介 1.1 什么是lucene Lucene是一个全文搜索框架，而不是应用产品。因此它并不像https://www.doczj.com/doc/2f10731902.html,或者google Desktop 那么拿来就能用，它只是提供了一种工具让你能实现这些产品。 2 lucene的工作方式 lucene提供的服务实际包含两部分：一入一出。所谓入是写入，即将你提供的源（本质是字符串）写入索引或者将其从索引中删除；所谓出是读出，即向用户提供全文搜索服务，让用户可以通过关键词定位源。 2.1写入流程 源字符串首先经过analyzer处理，包括：分词，分成一个个单词；去除stopword（可选）。 将源中需要的信息加入Document的各个Field中，并把需要索引的Field索引起来，把需要存储的Field 存储起来。 将索引写入存储器，存储器可以是内存或磁盘。 2.2读出流程 用户提供搜索关键词，经过analyzer处理。 对处理后的关键词搜索索引找出对应的Document。 用户根据需要从找到的Document中提取需要的Field。 3 一些需要知道的概念 3.1 analyzer Analyzer是分析器，它的作用是把一个字符串按某种规则划分成一个个词语，并去除其中的无效词语，这里说的无效词语是指英文中的“of”、“the”，中文中的“的”、“地”等词语，这些词语在文章中大量出现，但是本身不包含什么关键信息，去掉有利于缩小索引文件、提高效率、提高命中率。 分词的规则千变万化，但目的只有一个：按语义划分。这点在英文中比较容易实现，因为英文本身就是以单词为单位的，已经用空格分开；而中文则必须以某种方法将连成一片的句子划分成一个个词语。具体划分方法下面再详细介绍，这里只需了解分析器的概念即可。 3.2 document 用户提供的源是一条条记录，它们可以是文本文件、字符串或者数据库表的一条记录等等。一条记录经过索引之后，就是以一个Document的形式存储在索引文件中的。用户进行搜索，也是以Document列表的形式返回。 3.3 field 一个Document可以包含多个信息域，例如一篇文章可以包含“标题”、“正文”、“最后修改时间”等信息域，这些信息域就是通过Field在Document中存储的。 Field有两个属性可选：存储和索引。通过存储属性你可以控制是否对这个Field进行存储；通过索引属性你可以控制是否对该Field进行索引。这看起来似乎有些废话，事实上对这两个属性的正确组合很重要，下面举例说明：还是以刚才的文章为例子，我们需要对标题和正文进行全文搜索，所以我们要把索引属性设置为真，同时我们希望能直接从搜索结果中提取文章标题，所以我们把标题域的存储属性设置为真，但是由于正文域太大了，我们为了缩小索引文件大小，将正文域的存储属性设置为假，当需要时再直接读取文件；我们只是希望能从搜索解果中提取最后修改时间，不需要对它进行搜索，所以我们把最后修改时间域的存储属性设置为真，索引属性设置为假。上面的三个域涵盖了两个属性的三种组合，还有一种全为假的没有用到，事实上Field不允许你那么设置，因为既不存储又不索引的域是没有意义的。

lucene索引优化

这篇文章主要介绍了如何提高Lucene的索引速度。介绍的大部分思路都是很容易尝试的，当然另外一部分可能会加大你程序的复杂度。所以请确认索引速度确实很慢，而且很慢的原因确实是因为Lucene自身而造成的。推荐姐妹篇：如何提高和优化Lucene搜索速度 ? 确认你在使用最新的Lucene版本。 ? 尽量使用本地文件系统 远程文件系统一般来说都会降低索引速度。如果索引必须分布在远程服务器，请尝试先在本地生成索引，然后分发到远程服务器上。 ? 使用更快的硬件设备，特别是更快的IO设备 ? 在索引期间复用单一的IndexWriter实例 ? 使用按照内存消耗Flush代替根据文档数量Flush 在Lucene 2.2之前的版本，可以在每次添加文档后调用ramSizeInBytes方法，当索引消耗过多的内存时，然后在调用flush()方法。这样做在索引大量小文档或者文档大小不定的情况下尤为有效。你必须先把maxBufferedDocs参数设置足够大，以防止writer基于文档数量flush。但是注意，别把这个值设置的太大，否则你将遭遇Lucene-845号BUG。不过这个BUG已经在2.3版本中得到解决。 在Lucene2.3之后的版本。IndexWriter可以自动的根据内存消耗调用flush()。你可以通过writer.setRAMBufferSizeMB()来设置缓存大小。当你打算按照内存大小flush后，确保没有在别的地方设置MaxBufferedDocs值。否则flush条件将变的不确定（谁先符合条件就按照谁）。 ? 在你能承受的范围内使用更多的内存 在flush前使用更多的内存意味着Lucene将在索引时生成更大的segment，也意味着合并次数也随之减少。在Lucene-843中测试，大概48MB内存可能是一个比较合适的值。但是，你的程序可能会是另外一个值。这跟不同的机器也有一定的关系，请自己多加测试，选择一个权衡值。 ? 关闭复合文件格式 调用setUseCompoundFile(false)可以关闭复合文件选项。生成复合文件将消耗更多的时间（经过Lucene-888测试，大概会增加7%-33%的时间）。但是请注意，这样做将大大的增加搜索和索引使用的文件句柄的数量。如果合并因子也很大的话，你可能会出现用光文件句柄的情况。 ? 重用Document和Field实例

Lucene、Solr开发经验

Lucene/Solr开发经验 1、开篇语 2、概述 3、渊源 4、初识Solr 5、Solr的安装 6、Solr分词顺序 7、Solr中文应用的一个实例 8、Solr的检索运算符 [开篇语]按照惯例应该写一篇技术文章了，这次结合Lucene/Solr来分享一下开发经验。 Lucene是一个使用Java语言写的全文检索开发包（API），利用它可以实现强大的检索功能，它的详细介绍大家可以去Google上搜索一下，本文重点放在Solr相关的讨论上。 [概述]目前国内研究Solr的人不多，而且大多是因为项目开发需要。Solr师承Lucene，为Apache基金会下的一个项目，具体的说它还是Lucene下的一个子项目。Solr出身豪门，而且具有自己的技术特点，填补了以往Lucene仅仅作为开发工具包的遗憾，它是一个完完整整地应用。换句话说，它是一个全文检索服务器，它开箱即用，让我们能立马体会到Lucene 的强大功能，为Lucene产品化走出了一大步。

Solr分词原理演示界面 [渊源]最初，CNET Networks使用Lucene API来开发了一些应用，并在这个基础上产生了Solr的雏形，后来Apache Software Foundation在Lucene顶级项目的支持下得到了Solr，这已经是2006年1月份的事了。2006年1月17日，Solr正是加入Apache基金会的孵化项目，在整个项目孵化期间，Solr 稳步地积累各种特性并吸引了一个稳定的user群体、developer 群体和Committer群体，并于1年之后的17日正式酝酿成熟，在这之前已经成功发布了1.1.0版。目前的稳定版本是1.2，Solr在9月份的2007Apache年会上大放异彩，在今年11月底将来到香港参加2007亚洲开源软件峰会，遗憾的是为什么不来北京:-( [初识Solr]Solr服务器不同于普通的关系型数据库，不仅仅在于它核心本质的不同（面向结构化和非结构化数据的不同），很大的不同还在于它的体系架构上。Solr服务器一般情况下需要部署于应用服务器/Java容器上（如果是本机通信不涉及RPC可以不使用Java容器，如采用嵌入方式使用Solr），无法独立工作于JVM上。 Solr架构图

Lucene3.0之搜索

Lucene3.0之查询处理（1）：原理 1、查询的三种方式 ①顺序查询：简单，但查询效率低 ②索引查询：快速，需要基础索引结构支撑 2、理论模型 ①布尔模型：基于集合论和布尔代数的一种简单检索模型 ②向量模型：查询串和文档之间分配不同的权值，权值大小放映了文档库中的文档 与用户查询串的相关度。查询得到的结果文档按照权值计算相关度有关排序，所以向量模型得到的匹配文档可以是全部精确匹配，也可以是部分匹配查询串。 3、查询流程 用户查询请求输入->查询词频->查询词频出现->查询词格式化->文本库索引匹配->相似度和排序计算->结果排重与生成。 4、Lucence3.0查询概述 1、主要利用查询工具IndexSearcher类 这是检索的主要控制和工具，也是所有搜索操作的入口。其构造方法主要有： IndexSearcher(Directory path) IndexSearcher(Directory path, boolean readOnly) IndexSearcher(IndexReader r) IndexSearcher(IndexReader reader, IndexReader[] subReaders, int[] docStarts) 这里推荐主要使用第1个和第2个构造方法。 2、其它相关的类 ①Query：抽象类，必须通过一系列子类来表述检索的具体需求。 ②QueryParser：查询分析器。处理用户输入的查询条件。把用户输入的非格式化检 索词转化成后台检索可以理解的Query对象 查询最基本的结果返回方式是通过Hits对象来提供。Hits提供了检索查询结果的缓冲，为结果的展示和返回提供支持。Hits中的结果集已经按照相关性进行了排序，前面的文档结果表明与查询词更为相似。 Lucene3.0之查询（2）：查询类型 1、查询Query对象 Lucnce查询主要有两种方式。一是通过Query子类构造函数方法生成子类。这种方法最大的好处是非常直观，可以根据自己的功能目标挑选合适的子类来够着具体的Query对象。 另一种查询方式是通过QueryParse动态构造查询对象。这种方法使用了parse方法，具体构造的对象类型需要根据查询词的内容来确定。除了少数特殊查询，几乎所有的查询检索都可以通过QueryParser来代替特定子类的构造函数来查询对象生成功能。 2、最小项查询TermQuery 适合关键字查询文档，大小写敏感。 ①Term term = new Term(“content”, “星期一”);

Lucene：基于Java的全文检索引擎简介

Lucene：基于Java的全文检索引擎简介 Lucene是一个基于Java的全文索引工具包。 对于中文用户来说，最关心的问题是其是否支持中文的全文检索。但通过后面对于Lucene 的结构的介绍，你会了解到由于Lucene良好架构设计，对中文的支持只需对其语言词法分析接口进行扩展就能实现对中文检索的支持。

全文检索≠ like "%keyword%" 通常比较厚的书籍后面常常附关键词索引表（比如：北京：12, 34页，上海：3,77页……），它能够帮助读者比较快地找到相关内容的页码。而数据库索引能够大大提高查询的速度原理也是一样，想像一下通过书后面的索引查找的速度要比一页一页地翻内容高多少倍……而索引之所以效率高，另外一个原因是它是排好序的。对于检索系统来说核心是一个排序问题。 由于数据库索引不是为全文索引设计的，因此，使用like "%keyword%"时，数据库索引是不起作用的，在使用like查询时，搜索过程又变成类似于一页页翻书的遍历过程了，所以对于含有模糊查询的数据库服务来说，LIKE对性能的危害是极大的。如果是需要对多个关键词进行模糊匹配：like"%keyword1%" and like "%keyword2%" ...其效率也就可想而知了。 所以建立一个高效检索系统的关键是建立一个类似于科技索引一样的反向索引机制，将数据源（比如多篇文章）排序顺序存储的同时，有另外一个排好序的关键词列表，用于存储关键词==>文章映射关系，利用这样的映射关系索引：[关键词==>出现关键词的文章编号，出现次数（甚至包括位置：起始偏移量，结束偏移量），出现频率]，检索过程就是把模糊查询变成多个可以利用索引的精确查询的逻辑组合的过程。从而大大提高了多关键词查询的效率，所以，全文检索问题归结到最后是一个排序问题。

Lucene3.0之结果排序

Lucene3.0之结果排序（1）：原理 传统上，人们将信息检索系统返回结果的排序称为“相关排序” （relevance ranking），隐含其中各条目的顺序反映结果和查询的相关程度。 1、基本排序原理 ①向量空间模型 Gerald Salton等在30多年前提出的“向量空间模型” （Vector Space Model，VSM）[Salton and Lesk,1968, Salton,1971]。该模型的基础是如下假设：文档d和查询q的相关性可以由它们包含的共有词汇情况来刻画。 经典的TF*IDF词项权重的计算公式： 给定某种权重的定量设计，求文档和查询的相关性就变成了求d和q向量的 某种距离，最常用的是余弦（cos）距离 ②链接分析PageRank原理 链接分析技术主要基于两个假设：1）一个网页被多次引用，则它可能是很重要的，如果被重要的网页引用，说明自身也是重要的，网页的重要性在网页之间可以传递。 2）随机冲浪模型：认为假定用户一开始随机地访问网页集合中的一个网页，然和跟随网页的链接向前浏览网页，不会退浏览，那么浏览下一个网页的概率是被浏览网页的量化的重要程度值。 按照以上的用户行为模型，每个网页可能被访问到的次数越多就越重要，这样的“可能被访问的次数”也就定义为网页的权值，PageRank值。如何计算这个权值呢？PageRank采用以下公式进行计算： 其中wj代表第j个网页的权值；lij只取0、1值，代表从网页i到网页j是否存在链接；ni代表网页i有多少个连向其它网页的链接；d代表“随机冲浪”中沿着链接访问网页的平均次数。选择合适的初始数值，递归的使用上述公式，即可得到理想的网页权值。 2、Lucene排序计算公式 Lucene的排序公式如下： 1)，协调因子，表示文档（d）中Term(t)出现的百分比，也就是计算查询条 件（q）中不同Term(t)，以及在文档中出现的数量之和，两者的数量之比。通常在文档中出现查询Term种类越多，分值越高。

一步一步学lucene——(第四步：搜索篇)

下面说的主要是lucene如何进行搜索，相比于建索引，搜索可能更能提起大家的兴趣。lucene的主要搜索的API 下面通过表格来看一下lucene用到的主要的搜索API 类目的 IndexSeacher搜索操作的入口，所有搜索操作都是通过IndexSeacher实例使用一个重载的search方法来实现 Query(及其子类)具体的Query子类为每一种特定类型的查询进行逻辑上的封装。Query实例被传递到IndexSearcher的search方法中 QueryParser将用户输入的（并且可读的）查询表达式处理为一个具体的Query对象 TopDocs保持由IndexSearcher.search()方法返回的具有较高评分的顶部文档 ScoreDoc提供对TopDocs中每条搜索结果的访问接口 对特定项进行搜索 其中IndexSearcher是对索引中文档进行搜索的核心类，我们下面的例子中就会对subject域进行索引，使用的是Query的子类TermQuery。 测试程序如下： 1p u b l i c v o i d t e s t T e r m()t h r o w s E x c e p t i o n{ 2D i r e c t o r y d i r=T e s t U t i l.g e t B o o k I n d e x D i r e c t o r y();//A 3I n d e x S e a r c h e r s e a r c h e r=n e w I n d e x S e a r c h e r(d i r);//B 4 5T e r m t=n e w T e r m("s u b j e c t","a n t"); 6Q u e r y q u e r y=n e w T e r m Q u e r y(t); 7T o p D o c s d o c s=s e a r c h e r.s e a r c h(q u e r y,10); 8a s s e r t E q u a l s("A n t i n A c t i o n",//C 91,d o c s.t o t a l H i t s);//C 10 11t=n e w T e r m("s u b j e c t","j u n i t"); 12d o c s=s e a r c h e r.s e a r c h(n e w T e r m Q u e r y(t),10); 13a s s e r t E q u a l s("A n t i n A c t i o n,"+//D 14"J U n i t i n A c t i o n,S e c o n d E d i t i o n",//D 152,d o c s.t o t a l H i t s);//D 16 17s e a r c h e r.c l o s e(); 18d i r.c l o s e(); 19} 当然在不同的情况下你可以改变其中的代码来搜索你想要的东西。

lucene实例

package https://www.doczj.com/doc/2f10731902.html,.learn.lucene.myLucene; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.util.Date; import org.apache.lucene.analysis.Analyzer; import https://www.doczj.com/doc/2f10731902.html,.smart.SmartChineseAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.LongField; import org.apache.lucene.document.StringField; import org.apache.lucene.document.TextField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.index.IndexWriterConfig.OpenMode; import org.apache.lucene.index.Term; import org.apache.lucene.queryparser.classic.ParseException; import org.apache.lucene.queryparser.classic.QueryParser; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.Sort; import org.apache.lucene.search.SortField; import org.apache.lucene.search.TopDocs; import org.apache.lucene.search.highlight.Formatter; import org.apache.lucene.search.highlight.Fragmenter; import org.apache.lucene.search.highlight.Highlighter; import org.apache.lucene.search.highlight.InvalidTokenOffsetsException; import org.apache.lucene.search.highlight.QueryScorer; import org.apache.lucene.search.highlight.Scorer; import org.apache.lucene.search.highlight.SimpleFragmenter; import org.apache.lucene.search.highlight.SimpleHTMLFormatter; import org.apache.lucene.store.Directory; import org.apache.lucene.store.FSDirectory; import org.apache.lucene.util.Version;

全文检索例子

本文由美白面膜排行榜https://www.doczj.com/doc/2f10731902.html,整理 全文检索例子 lucene3搜索引擎,索引建立搜索排序分页高亮显示, IKAnalyzer分词public class LuceneService { private final Log logger = LogFactory.getLog(LuceneService.class); private final String dirPath = "d:/temp/user"; Analyzer analyzer = new IKAnalyzer(); Directory directory = null; IndexWriter writer = null; IndexSearcher indexSearcher = null; private void confirmDirs() { File indexFile = new File(dirPath); if (!indexFile.exists()) { indexFile.mkdirs(); } if (!indexFile.exists() || !indexFile.canWrite()) { if (logger.isDebugEnabled()) logger.error("索引文件目录创建失败或不可写入！"); } } public void init() {

confirmDirs(); try { File f = new File(dirPath); directory = FSDirectory.open(f); } catch (Exception e) { if (logger.isDebugEnabled()) { logger.error("解除索引文件锁定失败！" + e.getCause()); } } } public void createIndex(List<User> userList) { init(); try { // 第一个参数是存放索引目录有FSDirectory（存储到磁盘上）和RAMDirectory（存储到内存中）， // 第二个参数是使用的分词器，第三个：true，建立全新的索引，false,建立增量索引，第四个是建立的索引的最大长度 writer = new IndexWriter(directory, analyzer, true,IndexWriter.MaxFieldLength.LIMITED); writer.setMergeFactor(500); writer.setMaxBufferedDocs(155);