lucene

////根据文档设置权重 //Random rd = new Random(); //int i = rd.Next(10); //doc.SetBoost(i); ////根据字段设置权重数据 //Field d = new Field("sort", myred["sort"].ToString(), Field.Store.YES, Field.Index.TOKENIZED); //d.SetBoost(9F);//特注：参数float小数----------------------------------------------------------------------就是以上注释的啊，原来他们采用的随机权重，没有业务逻辑，你可以根据你的要求去添加权重，比如判断连接是否来自 新浪、搜狐、百度，这些适当权重设置高一些。 或者根据你数据库存储的url外链来控制一个url的权重，设置其内容的重要性（rank 值），这样可以保证一部分体验好的内容排在前面，更多的算法还要靠你自己去思考，你需要的是什么

JAVA 自带的IO包就能解决这个问题每一次 读一行一个一个CHAR 去比对，如果连续字符串 完全匹配则 把局部变量记录的行号写入全局带输出变量中，继续操作 知道读取全部文件

在test1应用的index.jsp中增加如下代码 test2 index.jsp 在test2应用的index.jsp中增加如下代码 (输出为NULL)

我用的是java的，你需要考虑是索引创建的优化手段，具体有：优化创建索引性能：这方面的优化途径比较有限，IndexWriter提供了一些接口可以控制建立索引的操作，另外我们可以先将索引写入RAMDirectory，再批量写入FSDirectory，不管怎样，目的都是尽量少的文件IO，因为创建索引的最大瓶颈在于磁盘IO。另外选择一个较好的分析器也能提高一些性能。1.1 通过设置IndexWriter的参数优化索引建立setMaxBufferedDocs(int maxBufferedDocs)控制写入一个新的segment前内存中保存的document的数目，设置较大的数目可以加快建索引速度，默认为10。setMaxMergeDocs(int maxMergeDocs)控制一个segment中可以保存的最大document数目，值较小有利于追加索引的速度，默认Integer.MAX_VALUE，无需修改。setMergeFactor(int mergeFactor)控制多个segment合并的频率，值较大时建立索引速度较快，默认是10，可以在建立索引时设置为100。1.2 通过RAMDirectory缓写提高性能我们可以先把索引写入RAMDirectory，达到一定数量时再批量写进FSDirectory，减少磁盘IO次数。FSDirectory fsDir = FSDirectory.getDirectory("/data/index", true);RAMDirectory ramDir = new RAMDirectory();IndexWriter fsWriter = new IndexWriter(fsDir, new StandardAnalyzer(), true);IndexWriter ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);while (there are documents to index){... create Document ...ramWriter.addDocument(doc);if (condition for flushing memory to disk has been met){fsWriter.addIndexes(new Directory[] { ramDir });ramWriter.close();ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);}}1.3 选择较好的分析器这个优化主要是对磁盘空间的优化，可以将索引文件减小将近一半，相同测试数据下由600M减少到380M。但是对时间并没有什么帮助，甚至会需要更长时间，因为较好的分析器需要匹配词库，会消耗更多cpu，测试数据用StandardAnalyzer耗时133分钟；用MMAnalyzer耗时150分钟。希望对你有帮助。

Create a PriorityQueue from a word->tf map. * * @param words a map of words keyed on the word(String) with Int objects as the values. */ private PriorityQueue<ScoreTerm> createQueue(Map<String, Int> words) throws IOException { // have collected all words in doc and their freqs int numDocs = ir.numDocs(); final int limit = Math.min(maxQueryTerms, words.size()); FreqQ queue = new FreqQ(limit); // will order words by score for (String word : words.keySet()) { // for every word int tf = words.get(word).x; // term freq in the source doc if (minTermFreq > 0 && tf < minTermFreq) { continue; // filter out words that don"t occur enough times in the source } // go through all the fields and find the largest document frequency String topField = fieldNames[0]; int docFreq = 0; for (String fieldName : fieldNames) {

没代码不是太好判断，不过有可能是你做索引的时候是不分词的，比如说，你的title是“我爱中国”，不分词就是索引库中把“我爱中国作为一个term，而你搜索的时候是采用标准分词，”我爱中国“就被分为”我“”爱“”中“”国“4个term，每个term到索引库中搜索都是没有的，因为索引中只有”我爱中国“一个term。要能搜索到只能用精确搜索，及：Query query=new TermQuery("title","我爱中国");这样就能搜到了。

1.手动的把数据从doc粘贴到txt2.读doc然后写txt-----百度poi（一款开源包）3.不想学怎么用poi就直接百度 有现成的示例的恩 就是这样 希望采纳哈~话说从数据库里直接读就是爽那。。。

呵呵，兄弟你在做搜索引擎的东西？这个IK分词器测试分词效果的代码需要稍作处理才能回避着个问题

针对你问的这些，您可以这样做：如果是linux服务器的话，可以考虑用mount方式把ftp挂载到本地路径上。具体java操作文件的API保存不变。希望我的回答能够帮助的到您

你好,我也想找搞一个基于lucene+mysql的站内搜索,请问你是怎么配置环境的

好像没有直接的方法，不过可以通过try catch的方法来判断，如：Boolean flag=false;try{ String contents=searcher.doc(docNum).get("content"); flag=true;}catch(Exception e){ flag=false;}如果flag=ture说明content这个字段是存在的，否则说明这个字段不存在。

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Runtime.InteropServices; using Lucene.Net.Analysis; namespace Lucene.Net.Analysis.DChinese { [StructLayout(LayoutKind.Explicit)] public struct result_t { [FieldOffset(0)] public int start; [FieldOffset(4)] public int length; [FieldOffset(8)] public int sPos1; [FieldOffset(12)] public int sPos2; [FieldOffset(16)] public int sPos3; [FieldOffset(20)] public int sPos4; [FieldOffset(24)] public int sPos5; [FieldOffset(28)] public int sPos

这个问题我也不是很清楚，其他的组合查询或者是重新查询试一下吧

查一下你的代码 是否每次执行查询之后 有写索引的过程。可以执行一次把索引的全部数量打印出来看一下 同时打印出来 query.

官方的答案：Release 4.8.0 [2014-04-28]System Requirements (1)LUCENE-4747, LUCENE-5514: Move to Java 7 as minimum Java version. (Robert Muir, Uwe Schindler)

src是指源文件,tgz格式是linux文件格式

可以啊，searcher不加query就是全部。

solr+hadoop（elasticsearch和solr类似，有hadoop模块，你也可以试试）在不能满足需求的时候可以改底层的lucene

把创建索引时，把new Field("content", new FileReader(file))改成new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"))

加入中文分词器

是用prefixQuery完全匹配的，但是被匹配的那一列，你在索引的时候不能分词存储，例如field=new Field("path",path,Field.Store.YES,Field.Index.NOT_ANALYZED);之后匹配的时候用个term就行了。例如：Term term1 = new Term("path",queryString); PrefixQuery query = new PrefixQuery(term1);不知道是否对你有帮助。

你用Lucene建立索引的时候IndexWriter writer = new IndexWriter(indexdir,new StandardAnalyzer(), true);第三个参数当为TRUE时是会删除同一个目录下的索引的，这是在初次创建索引时使用以后每次增量索引直接设置为FALSE即可，这样直接将后面新建立的索引添加到索引文件中，不会覆盖原来建立的索引。当删除索引时我们可以找到对应的索引ID，然后删除索引，将删除掉索引文件中的该条记录，同时在同目录下生成一个删除索引的记录问价，为-DEL文件，便于后面恢复删除的索引。以上解答希望你能理解，建个简单的索引试试就可以知道的

可以的，模糊查询和分词没有直接关系的。如果不分词，那么一句话就是一个域，可以使用FuzzyQuery或QueryParser查询。在使用QueryParser的时候，如果第一个字符就想使用通配符，那么需要使用setAllowLeadingWildcard(true)来开启。最后，模糊查询效率较低，结合自己的需求使用吧。

luncene？给你个测试结果，自己考虑测试一：250万记录，300M左右文本，生成索引380M左右，800线程下平均处理时间300ms。测试二：37000记录，索引数据库中的两个varchar字段，索引文件2.6M，800线程下平均处理时间1.5ms。

因为一元分词不适合进行中文检索。一元分词是按字拆分的，比如一句话“梦想很丰满”，使用一元分词拆分的结果是：“梦”，“想”，“很”，“丰”，“满”。如果查找“梦想”这个词，是找不到查询结果的。这并不符合我们的检索习惯，所以极少使用。

好像没有直接的方法，不过可以通过try catch的方法来判断，如： Boolean flag=false; try{ String contents=searcher.doc(docNum).get("content"); flag=true; } catch(Exception e){ flag=false; } 如果flag=ture说明content这个字段是存在的

首先，应该知道lucene检索的是索引文件，而索引文件则是依据于数据库创建而成的。那么问题来了，你想怎么去创建索引呢？一般来说，这个得看需求了，最主要是考虑对数据的实时性要求高不高、数据量大不大？额，就假设数据量比较大吧，毕竟数据量太小也没必要使用lucene。1、数据实时性要求不高。可定时增量更新索引，以天或几个小时为单位。2.数据实时性要求较高。可在数据入库时，立即进行索引更新操作。那么问题又来了数据量比较大的时候，更新一次索引是比较慢的。所以，还得继续考虑缓存策略问题，将新增数据保存在缓存中，选择合适的时间进行提交。

IndexReader indexReader=IndexReader.open(FSDirectory.open(file))

Lucene一个常见的用例是在一个或者多个数据库表进行全文检索。 虽然MySql有全文检索的功能，但是如果字段和数据量增加，MySql的性能会减低很快。映射数据到Lucene用伪代码表示：String sql = “select id, firstname, lastname, phone, email fro...

本文及后面关于Lucene的文章所采用的lucene 版本为8.1.0. doc 文件主要用于保存term的倒排表信息，包括docId倒排链及term在docId的term freq信息等。倒排链是Lucene 进行全文检索的核心数据结构，请特别关注这个数据结构 请参考 Lucene tim文件格式详解 第三部分 文件头部分主要内容为标识此文件类型为 Lucene50PostingsWriterDoc , 源码部分在 Lucene50PostingsWriter 的123行，主要内容如下 开始本部分阅读时，请注意一个在第3部分得到的结果及含义, 现在开始分析该部分内容 下面为term的doc信息。 主要逻辑是: 对于term的doc freq = 1的term来说，doc文件不保存这个term的doc信息，而是在 tim 文件中保存，doc 文件只保存doc freq > 1的term。在范例中，只有nice的doc freq > 1, 故只保存nice的doc倒排链 关于其它term(term freq = 1)的编码方式，请参考 tim 文件相应的格式内容 footer区主要有以下内容

反正我项目是保存在本地，好像也可以保存在内存的

虽然这个问题过去很久了，但是给后来的人解释下----第三个 用表达式("content:Y*")来搜索是不是应该搜索出"Yello你好"而不是"hello你好"----那是因为 你给content设置了两个值啊，一个field1一个field2，分词名称都是content

Lucene是可以的，它常见的用例就是在一个或者多个数据库表进行全文检索。虽然MySql有全文检索的功能，但是如果字段和数据量增加，MySql的性能会减低很快。

Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。 下面研究几种设置/改变检索结果排序的方法。 1、改变Document的boost(激励因子) 改变boost的大小，会导致Document的得分的改变，从而按照Lucene默认的对检索结果集的排序方式，改变检索结果中Document的排序的提前或者靠后。在计算得分的时候，使用到了boost的值，默认boost的值为1.0，也就说默认情况下Document的得分与boost的无关的。一旦改变了默认的boost的值，也就从Document的得分与boost无关，变为相关了：boost值越大，Document的得分越高。 2、改变Field的boost(激励因子) 改变Field的boost值，和改变Document的boost值是一样的。因为Document的boost是通过添加到Docuemnt中Field体现的，所以改变Field的boost值，可以改变Document的boost值。 3、使用Sort排序工具实现排序 Lucene在查询的时候，可以通过以一个Sort作为参数构造一个检索器IndexSearcher，在构造Sort的时候，指定排序规则。 调用sort进行排序的方法是IndexSearcher.search，例如： IndexSearcher.search(query,sort); 关于Sort类，在其内部定义了6种构造方法： public Sort() // public Sort(SortField field) //通过构造某个域（field）的SortField对象根据一个域进行排序 public Sort(SortField[] fields) //通过构造一组域（field）的SortField对象组实现根据多个域排序 public Sort(String field) //根据某个域（field）的名称构造Sort进行排序 public Sort(String field, boolean reverse) //根据某个域（field）的名称构造SortField进行排序，reverse为true为升序 public Sort(String[] fields) //根据一组域（field）的名称构造一组Sort进行排序 4、直接使用SortField实现排序 关于SortField类，在其内部定义了7种构造方法： public SortField (String field, boolean reverse)//根据某个域（field）的名称构造SortField, reverse为false为升序 public SortField (String field, int type) public SortField (String field, int type, boolean reverse) public SortField (String field, Locale locale) public SortField (String field, Locale locale, boolean reverse) public SortField (String field, SortComparatorSource comparator) public SortField (String field, SortComparatorSource comparator, boolean reverse) type对应的值分别为： SortField. SCORE 按积分排序 SortField. DOC 按文档排序 SortField. AUTO 域的值为int、long、float都有效 SortField.STRING 域按STRING排序 SortField..FLOAT SortField.LONG SortField.DOUBLE SortField.SHORT SortField.CUSTOM 通过比较器排序 SortField.BYTE 5、自定义排序 Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在了解具体实现方法之前先来看看这两个接口的定义吧

这个要看你的搜索关键词是什么，采用的分词器是什么，比如你搜索的关键词是“搜索引擎”，如果采用的分词器的分词结果就包含“搜索引擎‘这个词，那么采用TermQuery就可以了；如果采用的分词器的分词结果不是“搜索引擎‘这个词，而是”搜索“和”引擎“这两个词，那么要采用PhraseQuery，setSlop(0)，这样就可以搜索出同时包含”搜索“和”引擎“这两个词并且这两个词紧挨着的所有文章了。

Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。下面研究几种设置/改变检索结果排序的方法。1、改变Document的boost(激励因子)改变boost的大小，会导致Document的得分的改变，从而按照Lucene默认的对检索结果集的排序方式，改变检索结果中Document的排序的提前或者靠后。在计算得分的时候，使用到了boost的值，默认boost的值为1.0，也就说默认情况下Document的得分与boost的无关的。一旦改变了默认的boost的值，也就从Document的得分与boost无关，变为相关了：boost值越大，Document的得分越高。2、改变Field的boost(激励因子)改变Field的boost值，和改变Document的boost值是一样的。因为Document的boost是通过添加到Docuemnt中Field体现的，所以改变Field的boost值，可以改变Document的boost值。3、使用Sort排序工具实现排序Lucene在查询的时候，可以通过以一个Sort作为参数构造一个检索器IndexSearcher，在构造Sort的时候，指定排序规则。调用sort进行排序的方法是IndexSearcher.search，例如：IndexSearcher.search(query,sort);关于Sort类，在其内部定义了6种构造方法：publicSort()//publicSort(SortFieldfield)//通过构造某个域（field）的SortField对象根据一个域进行排序publicSort(SortField[]fields)//通过构造一组域（field）的SortField对象组实现根据多个域排序publicSort(Stringfield)//根据某个域（field）的名称构造Sort进行排序publicSort(Stringfield,booleanreverse)//根据某个域（field）的名称构造SortField进行排序，reverse为true为升序publicSort(String[]fields)//根据一组域（field）的名称构造一组Sort进行排序4、直接使用SortField实现排序关于SortField类，在其内部定义了7种构造方法：publicSortField(Stringfield,booleanreverse)//根据某个域（field）的名称构造SortField,reverse为false为升序publicSortField(Stringfield,inttype)publicSortField(Stringfield,inttype,booleanreverse)publicSortField(Stringfield,Localelocale)publicSortField(Stringfield,Localelocale,booleanreverse)publicSortField(Stringfield,SortComparatorSourcecomparator)publicSortField(Stringfield,SortComparatorSourcecomparator,booleanreverse)type对应的值分别为：SortField.SCORE按积分排序SortField.DOC按文档排序SortField.AUTO域的值为int、long、float都有效SortField.STRING域按STRING排序SortField..FLOATSortField.LONGSortField.DOUBLESortField.SHORTSortField.CUSTOM通过比较器排序SortField.BYTE5、自定义排序Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口.在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在了解具体实现方法之前先来看看这两个接口的定义吧

lu Sen

用solr或者es吧 升级版

就报错来看，还没有用到Lucene就出错了，意思是只到第一行就虚拟机内存溢出了，可以考虑把源文件进行切割，如把10M的文本切成5个1M的，建议你试一下给一个可以切分文件的程序，可把它作为预处理的一部分public static void splitToSmallFiles(File file, String outputpath) throws IOException {int filePointer = 0;int MAX_SIZE = 10240000;BufferedWriter writer = null;BufferedReader reader = new BufferedReader(new FileReader(file));StringBuffer buffer = new StringBuffer();String line = reader.readLine();while (line != null) {buffer.append(line).append("\r");if (buffer.toString().getBytes().length >= MAX_SIZE){writer = new BufferedWriter(new FileWriter(outputpath + "output" + filePointer + ".txt"));writer.write(buffer.toString());writer.close();filePointer++;buffer = new StringBuffer();}line = reader.readLine();}writer = new BufferedWriter(new FileWriter(outputpath + "output" + filePointer + ".txt"));writer.write(buffer.toString());writer.close();}

你如果用的是不可索引的Field，那么肯定查不出来，如果用StringField，你需要分词查，那也查不出来（StringField("a", "中华人民共和国", Field.Store.YES)你查询共和国是查不出来的）org.apache.lucene.document.StringField这个是可索引的，不分词的org.apache.lucene.document.TextField这个是可索引的，分词的

我感觉应该是fileReader这个函数出错了，如果fileDir目录下有子目录，或者这个目录下有比较大的文件，获取内容就会失败，这样就不会执行ndexWriter.close();这句。程序中应该加一些异常判断和保护就可以了。

这个要看你的搜索关键词是什么，采用的分词器是什么，比如你搜索的关键词是“搜索引擎”，如果采用的分词器的分词结果就包含“搜索引擎‘这个词，那么采用TermQuery就可以了；如果采用的分词器的分词结果不是“搜索引擎‘这个词，而是”搜索“和”引擎“这两个词，那么要采用PhraseQuery，setSlop(0)，这样就可以搜索出同时包含”搜索“和”引擎“这两个词并且这两个词紧挨着的所有文章了。

IndexReader提供了两种方法：reader.DeleteDocument(int docNum)reader.DeleteDocuments(Term term)前者是根据文档的编号来删除该文档，docNum是该文档进入索引时Lucene的编号，是按照顺序编的；后者是删除满足某一个条件的多个文档。在执行了DeleteDocument或者DeleteDocuments方法后，系统会生成一个*.del的文件，该文件中记录了删除的文档，但并未从物理上删除这些文档。此时，这些文档是受保护的，当使用Document doc = reader.Document(i)来访问这些受保护的文档时，Lucene会报“Attempt to access a deleted document”异常。如果一次需要删除多个文档时，可以用两种方法来解决：1. 删除一个文档后，用IndexWriter的Optimize方法来优化索引，这样我们就可以继续删除另一个文档。2. 先扫描整个索引文件，记录下需要删除的文档在索引中的编号。

您去看看lucene的实现原理吧 没有分词无法建立索引库 自然搜不到

你用Lucene建立索引的时候IndexWriter writer = new IndexWriter(indexdir,new StandardAnalyzer(), true);第三个参数当为TRUE时是会删除同一个目录下的索引的，这是在初次创建索引时使用以后每次增量索引直接设置为FALSE即可，这样直接将后面新建立的索引添加到索引文件中，不会覆盖原来建立的索引。当删除索引时我们可以找到对应的索引ID，然后删除索引，将删除掉索引文件中的该条记录，同时在同目录下生成一个删除索引的记录问价，为-DEL文件，便于后面恢复删除的索引。以上解答希望你能理解，建个简单的索引试试就可以知道的

1、您的document里面有该字段；2、您在addField内容这个字段的时候，需要把设置Field.Store.YES。

SpanQuery是按照词在文章中的距离或者查询几个相邻词的查询。打个比方：如“中华人民共和国” 用“中国“做为关键字， 跨度为某个值，如5。跨度代表 中 和国之间的长度。。lucene的：SpanQuery包括以下几种： SpanTermQuery：词距查询的基础，结果和TermQuery相似，只不过是增加了查询结果中单词的距离信息。 SpanFirstQuery：在指定距离可以找到第一个单词的查询。 SpanNearQuery：查询的几个语句之间保持者一定的距离。 SpanOrQuery：同时查询几个词句查询。 SpanNotQuery：从一个词距查询结果中，去除一个词距查询。所以这种Query不能进行模糊搜索，要进行模糊查询，可以选择FuzzyQuery或者WildcardQuery。

个人认为，第一种方法相对靠谱一点。毕竟你的目的是可以检索到附件。优化建议：提取摘要。索引全部附件不太可取，这对硬件的压力也很大。可以选择新增一个域，用来保存附件的摘要。从那行代码来看，附件应该都是文档类吧。lucene的Highlighter貌似有这个功能，也可以考虑用其它方式实现。摘要+附件名，附件检索的目的完全可以达到了。增加相关域，根据对附件的检索需求，可以使用tika读取更多的相关信息，比如：附件名、附件大小、作者、时间、附件摘要，等相关信息。加上这些内容，一般的需求都能满足了。

建索引代码： private Document[] fileContentConvertDoc() { File f = new File(fileLuceneConfig.getDocFilePath()); List<File> allowFiles = new LinkedList<File>(); allowFiles = getAllowFiles(f, allowFiles); Document[] documents = new Document[allowFiles.size()]; int i = 0; for (File tmp : allowFiles) { this.baseExtractor = AbstractExtractorFactory.getBaseExtractor(tmp .getName()); documents[i] = new Document(); // 文件名，不分词的索引，但存储 documents[i].add(new Field("fileName", tmp.getName(), Field.Store.YES, Field.Index.NOT_ANALYZED)); // 文件绝对路径，不索引，但存储 documents[i].add(new Field("filePath", tmp.getAbsolutePath(), Field.Store.YES, Field.Index.NO)); // 文件内容，分词索引，但不存储，根据路径来加载 try { documents[i].add(new Field("fileContent", baseExtractor .getContent(new FileInputStream(tmp)), Field.Store.NO, Field.Index.ANALYZED)); } catch (FileNotFoundException e) { log.debug(new StringBuffer("文件名为：").append(tmp.getName()).append("的文件没有找到，无法对该文件内容建立索引！")); } i++; } return documents; } public void indexDocs() { FSDirectory fsDirectory = null; try { fsDirectory = FSDirectory.open(new File(luceneConfig.getIndexDirPath())); RAMDirectory ramDirectory = new RAMDirectory(); IndexWriter fsWriter = new IndexWriter(fsDirectory, AnalyzerFactory.getAnalyzer(luceneConfig), true, MaxFieldLength.UNLIMITED); IndexWriter ramWriter = new IndexWriter(ramDirectory, AnalyzerFactory.getAnalyzer(luceneConfig), true, MaxFieldLength.UNLIMITED); Document[] documents = this.luceneConfig.getAbstractDocument().getDocuments();这里实际就是调用上面那个方法将每个目标目录下每个文件构建成单独的Document int i = 0; for (Document d : documents) { ramWriter.addDocument(d); if (i % 10 == 0) { fsWriter.addIndexesNoOptimize(new Directory[]{ramDirectory}); ramWriter.close(); ramWriter = new IndexWriter(ramDirectory, AnalyzerFactory.getAnalyzer(luceneConfig), MaxFieldLength.UNLIMITED); } fsWriter.optimize(); fsWriter.commit(); } fsWriter.close(); ramWriter.close(); } catch (IOException e) { e.printStackTrace(); } 搜索代码：通过fileContent内容找出对应的filePath public String[] searchDoc(SearchModel searchModel, String returnField) { try { Analyzer analyzer = AnalyzerFactory.getAnalyzer(luceneConfig); QueryParser parser = new QueryParser(Version.LUCENE_30,searchModel.getSearchField(),analyzer); Query query = parser.parse(searchModel.getSearchContent()); IndexSearcher seacrcher = new IndexSearcher(FSDirectory.open(new File(luceneConfig.getIndexDirPath())),true); TopDocs ts = seacrcher.search(query,null,100); int totalHits = ts.totalHits; ScoreDoc[] scoreDocs = ts.scoreDocs; String[] values = new String[scoreDocs.length]; for (int i = 0; i < scoreDocs.length; i++) { //根据命中的文档的内部编号获取该文档 Document hitDoc = seacrcher.doc(scoreDocs[i].doc); //获取该文档指定域的值 values[i] = hitDoc.getField(returnField).stringValue(); System.out.println(values[i]); } return values; }catch (FileNotFoundException e) { if (-1 < e.getMessage().indexOf("no segments* file found")) { log.error(new StringBuffer(luceneConfig.getIndexDirPath()).append("目录没有索引文件！")); } } catch (ParseException e) { e.printStackTrace(); } catch (CorruptIndexException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return null; } public static void main(String[] args) { FileLuceneConfig fileLuceneConfig = new FileLuceneConfig("E:\Lucene\test\target"); fileLuceneConfig.setIndexDirPath("E:\Lucene\test\index\file");//这是索引存放目录 fileLuceneConfig.setAnalyzerType("SC"); SearchModel searchModel = new SearchModel("人民","fileContent"); LuceneSearcher luceneSearcher = new LuceneSearcher(fileLuceneConfig); luceneSearcher.searchDoc(searchModel,"filePath"); } 查询结果，有重复记录： E:Lucene est argetc.txt E:Lucene est arget.txt E:Lucene est arget.txt 这里，我们先不管分词器如何分词，我希望出来的结果应该是： E:Lucene est argetc.txt E:Lucene est arget.txt 不会出现两条E:Lucene est arget.txt记录，请高手指定，为什么这里会有重复，如何做才能得到不重复的记录呢？

3.4 修改了Tokenizer 的接口，见incrementToken() 方法，原来是没有的。不兼容之前的，所以需要修改一下。

应该可以帮到你：Document doc = new Document(); Field FieldPath = new Field("path",file.getCanonicalPath(), Field.Store.YES, Field.Index.NO);Field FieldBody = new Field("contents", txtReader, Field.Store.YES, Field.Index.ANALYZED,Field.TermVector.WITH_POSITIONS_OFFSETS); doc.add(FieldPath); doc.add(FieldBody); writer.addDocument(doc);注：IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_DIR),analyzer, true, IndexWriter.MaxFieldLength.LIMITED);

获取Lucene中的主要的索引文件关键字方法：1．索引块文件这个文件包含了索引中的索引块信息，这个文件包含了每个索引块的名字以及大小等信息。2．域信息文件我们知道，索引中的文档由一个或者多个域组成，这个文件包含了每个索引块中的域的信息。3．索引项信息文件这是索引文件里面最核心的一个文件，它存储了所有的索引项的值以及相关信息，并且以索引项来排序。4．频率文件5．位置文件这个文件包含了索引项在每个文档中出现的位置信息，可以利用这些信息来参与对索引结果的排序。

看来楼主是刚接触lucene。lucene在磁盘上建立的索引，就是数据内容的本身，索引一旦建立，就和数据库没有任何关系了。按楼主的说法就是：已经包含了全部的内容。lucene的数据是不是缓存到本地，这个问题要看自己的设置。在建立索引的时候，有两种方式，一个是在内存中建立索引，一个是在本地磁盘建立索引。第一种方式，当电脑重启之后就会消失。第二种方式是在本地磁盘建立了文件，可以被长期保留。

String queryString = "site:1 AND channel:1 AND title:*lucene*";QueryParsernew parser = new QueryParser(参数自己写，默认字段传null);parser.setAllowleading...(true);具体怎么写自己查API吧Query query = parser(参数自己写).parse(queryString);searcher.search(query,100);根据自己的印象写的，手头没有api，剩下的你自己写吧。

报什么异常,能贴出来么？

这个要看你的搜索关键词是什么，采用的分词器是什么，比如你搜索的关键词是“搜索引擎”，如果采用的分词器的分词结果就包含“搜索引擎‘这个词，那么采用TermQuery就可以了；如果采用的分词器的分词结果不是“搜索引擎‘这个词，而是”搜索“和”引擎“这两个词，那么要采用PhraseQuery，setSlop(0)，这样就可以搜索出同时包含”搜索“和”引擎“这两个词并且这两个词紧挨着的所有文章了。

Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。 下面研究几种设置/改变检索结果排序的方法。 1、改变Document的boost(激励因子) 改变boost的大小，会导致Document的得分的改变，从而按照Lucene默认的对检索结果集的排序方式，改变检索结果中Document的排序的提前或者靠后。在计算得分的时候，使用到了boost的值，默认boost的值为1.0，也就说默认情况下Document的得分与boost的无关的。一旦改变了默认的boost的值，也就从Document的得分与boost无关，变为相关了：boost值越大，Document的得分越高。 2、改变Field的boost(激励因子) 改变Field的boost值，和改变Document的boost值是一样的。因为Document的boost是通过添加到Docuemnt中Field体现的，所以改变Field的boost值，可以改变Document的boost值。 3、使用Sort排序工具实现排序 Lucene在查询的时候，可以通过以一个Sort作为参数构造一个检索器IndexSearcher，在构造Sort的时候，指定排序规则。 调用sort进行排序的方法是IndexSearcher.search，例如： IndexSearcher.search(query,sort); 关于Sort类，在其内部定义了6种构造方法： public Sort() // public Sort(SortField field) //通过构造某个域（field）的SortField对象根据一个域进行排序 public Sort(SortField[] fields) //通过构造一组域（field）的SortField对象组实现根据多个域排序 public Sort(String field) //根据某个域（field）的名称构造Sort进行排序 public Sort(String field, boolean reverse) //根据某个域（field）的名称构造SortField进行排序，reverse为true为升序 public Sort(String[] fields) //根据一组域（field）的名称构造一组Sort进行排序 4、直接使用SortField实现排序 关于SortField类，在其内部定义了7种构造方法： public SortField (String field, boolean reverse)//根据某个域（field）的名称构造SortField, reverse为false为升序 public SortField (String field, int type) public SortField (String field, int type, boolean reverse) public SortField (String field, Locale locale) public SortField (String field, Locale locale, boolean reverse) public SortField (String field, SortComparatorSource comparator) public SortField (String field, SortComparatorSource comparator, boolean reverse) type对应的值分别为： SortField. SCORE 按积分排序 SortField. DOC 按文档排序 SortField. AUTO 域的值为int、long、float都有效 SortField.STRING 域按STRING排序 SortField..FLOAT SortField.LONG SortField.DOUBLE SortField.SHORT SortField.CUSTOM 通过比较器排序 SortField.BYTE 5、自定义排序 Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在了解具体实现方法之前先来看看这两个接口的定义吧

没必要。如果数据在千万级以下，完全可以通过索引、建分区表等方式提升性能。使用lucene对性能提升不大，反而会使系统更加臃肿。当然，如果这个小型系统存储的全是文本文档，那就另当别论了。

cene的搜索结果默认按相关度排序，这个相关度排序是基于内部的Score和DocID，Score又基于关键词的内部评分和做索引时的boost。默认Score高的排前面，如果Score一样，再按索引顺序，先索引的排前面。那么有人问了，如果我要先索引的排后面怎么办呢？隐士研究了源码后发现这是相当简单的事情。以下代码基于Lucene 2.0。看Sort的默认构造函数，相关度就是SortField.FIELD_SCORE和SortField.FIELD_DOC的组合。java 代码/**

lucene是一个公用的全文索引组件，它的目标是把各种各样格式的数据转化成lucene特有的索引文件格式，这样才能通过lucene的高速检索机制进行全文检索。你的数据来源可以是关系数据库，可以是word、execl、txt文档，可以是html网页，对于这些数据源，你必须将它们内部的数据读取出来，并封装成lucene的document实例，之后让lucene帮你构建索引。举个例子：你的有一个用户数据库，里面存储了几十万的用户信息，你现在要对这个数据库进行全文索引，那么你要做的事情是：1.写一段传统的JDBC程序，讲每条的用户信息从数据库读取出来2.针对每条用户记录，建立一个lucene documentDocument doc = new Document();并根据你的需要，将用户信息的各个字段对应luncene document中的field 进行添加，如：doc.add(new Field("NAME","USERNAME", Field.Store.YES,Field.Index.UN_TOKENIZED));然后将该条doc加入到索引中， 如： luceneWriter.addDocument(doc);这样就建立了lucene的索引库3.编写对索引库的搜索程序（看lucene文档），通过对lucene的索引库的查找，你可以快速找到对应记录的ID4.通过ID到数据库中查找相关记录上面阐述了lucene的大体用法，不知道是不是说的很清楚。

ucene中分词和索引的区别如下：1、分词器，对文本资源进行切分，将字符文本串按照一定的规则切分为一个个可以进行索引的最小单位（关键词），以便检索时使用。2、索引文件结构索引库是一组索引文件的集合。索引文件的检索：索引表规模相对较小，文档集合规模较大。进行检索时，先从检索索引表开始，然后找到相对应的文档。如果查询中仅包含一个关键词，则在索引表中找到该关键词，并取出它所对应的文档就可以了。如果查询中包含多个关键词，则需要将各个关键字检索出的文档记录进行合并。索引文件的维护：维护索引常使用三个操作：插入、删除和更新文档。但是更新操作需要较高的代价，因为文档修改后（即使是很小的修改），也可以造成文档中的很多的关键词的位置发生了变化，这时需要频繁的读取和修改记录，这种代价是相当高的。因此，一般不进行更新操作，而是使用“先删除，后创建”的方式代替更新操作。代码如下：

Lucene搜索时都是搜索的索引库，并不搜索原文档。在索引时，Lucene首先将文档内容进行分词，然后做成倒排索引，搜索是搜索该倒排索引。建立索引时，可以针对每个字段(域)进行不同的索引设置，可设置是否分词?是否存储?以及使用到的分词器。此处设置的是否存储是指该字段(域)是否作为一个整体保留(不分词)。例如:文档一:”巴西世界杯很好看!“在索引时，如果是分词索引，则:巴西/世界杯/很/好看如果搜索世界杯，则文档一就会被搜索出来，在索引中保存的是巴西/世界杯/很/好看这样的分词。如果索引时除了分词之外还存储该字段(域)，则:巴西/世界杯/很/好看/巴西世界杯很好看可以看出，索引中将文档一的所有内容作为一个分词，搜索时必须输入整个字段内容才会搜索到就想到这么多了，希望你能明白。

很多人会抱怨 Lucene 在数据量增加到一定规模的时候，性能会出现明显下降，对于并发用户访问的支持能力也比较弱。其实在工程师所遇到的绝大多数环境下 Lucene 的性能问题，往往是因为系统没有经过良好的调优。而非简单的 Lucene 设计缺陷所造成。 当前使用 Lucene 的知名网站包括，Stack Exchange，旗下全球最大的事实性问答网站 StackOverFlow.com . 基于Lucene 文档 “How to make indexing faster”，我们可以看到如下经验可能可以应用于 Lucene 优化。 确定的确需要进行索引性能调优很多场景之下，性能问题其实表现为整体数据架构设计的问题，而不仅仅是通过索引所可以解决的。在决定进行索引性能调优之前，可能需要首先判断，是否数据架构上出现了情况。 确定在使用最新版本的LuceneLucene也是在不断发展之中。新版本的Lucene通常性能都会有些改善。 使用更快的硬件，例如，改善IO系统性能通常硬件性能的改善对于系统整体性能提升是立竿见影的。例如，通过SSD硬盘（Solid-State Disk，固态硬盘）取代通常的 SATA 或者 SAS 硬盘，将可以获得明显的系统性能提升。 在建立索引过程中，使用单例的 Writer基于内存执行 Flush 而不是基于 document count在Lucene 2.3 及其以上系统中，IndexWriter可以基于内存执行Flush操作。调用 writer.setRAMBufferSizeMB() 可以设置Buffer大小。 尽量多使用内存内存越多，Lucene应对海量数据的时候性能明显加强。 关闭复合文件格式（Compound file format）调用setUseCompoundFile(false)，可以关闭。建立复合文件，将可能使得索引建立时间被拉长，有可能达到7%-33%。而关闭复合文件格式，将可能大大增加文件数量，而由于减少了文件合并操作，索引性能被明显增强。 重用文档与字段实例这是在 Lucene 2.3 之后才有的一个新技术。在之前如果要修改某个记录，需要删除掉索引中的文档，然后重新添加。而新的方法通过 setValue 实现。这将有助于更有效的减少GC开销而改善性能。 在存储字段数据以及执行 term vectors 的时候，使用同样的字段顺序添加文档这样将有助于保证合并操作的性能。 在打开 IndexWriter 的时候，设置 autoCommit = false同传统的数据库操作一样，批量提交事务性能总是比每个操作一个事务的性能能好很多。 同样，对于实时性要求不是很强的系统。通过标记，并定时进行索引和优化，也将比随时进行索引操作性能能改善很多。 不要使用太多的小字段，如果字段过多，尝试将字段合并到一个更大的字段中，以便于查询和索引适当增加 mergeFactor，但是不要增加的太多。关闭所有不需要的特性使用更快的 Analyzer特别是对于中文分词而言，分词器对于性能的影响更加明显。 加快文档的构造速度通常，从数据库，文件系统，或者网络爬行过程中，都可能因为上游程序处理的性能而影响 Lucene 文档建立的速度。 除非真的需要改善索引性能，通常不要特别进行优化对于一个实例的 IndexWriter 可以使用多线程或者并发技术使用Java Profiler分析 Lucene 和调用程序的性能，并由此改善性能Index into separate indices then merge.If you have a very large amount of content to index then you can break your content into N "silos", index each silo on a separate machine, then use the writer.addIndexesNoOptimize to merge them all into one final index.

　　在lucene使用过程中 如果要对同一IndexWriter中不同Document 不同Field中使用不同的 *** yzer 我们该如何实现呢？ 　　通过对《lucene in action》的阅读 发现是可以解决这一问题的 lucene可以正对整个IndexWriter对象或者每一个document对象或者特定Field使用不同的分析器 　　Analyzer *** yzer = new StandardAnalyzer(); 　　IndexWriter writer = new IndexWriter(direcotry *** yzer true); // 　　Document doc = new Document(); 　　doc add(new Field( title this is title Field Store PRESS Field Index TOKENIZED Field TermVector WITH_POSITIONS_OFFSETS)); 　　doc add(new Field( content this is content Field Store PRESS Field Index TOKENIZED Field TermVector WITH_POSITIONS_OFFSETS)); 　　writer addDocument(doc); //这是大部分情况下使用的一个方法 　　其实还有另外一个方法 原型如下 　　lucene自带文档写道 　　addDocument(Document doc Analyzer *** yzer) Adds a document to this index using the provided *** yzer instead of the value of getAnalyzer() 　　所以我们还可以写成这样 　　writer addDocument(doc *** yzer); // 这里的 *** yzer是指另外一个你指定的 *** yzer 不同于上面的StandardAnalyzer 　　那么如何针对特定Field使用不同分析器呢 lucene包里面有个PerFieldAnalyzerWrapper类 解决了这一问题 这是lucene的文档里面的一段话 　　lucene自带文档写道 　　Example usage: 　　PerFieldAnalyzerWrapper aWrapper = new PerFieldAnalyzerWrapper(new StandardAnalyzer()); 　　aWrapper addAnalyzer( firstname new KeywordAnalyzer()); aWrapper addAnalyzer( lastname new KeywordAnalyzer()); 　　In this example StandardAnalyzer will be used for all fields except firstname and lastname for which KeywordAnalyzer will be used 　　A PerFieldAnalyzerWrapper can be used like any other *** yzer for both indexing and query parsing PreFieldAnalyzerWrapper类的构造函数中需要一个默认的分析器作为参数 为了给不同的Field指定不同的 *** yzer 就需要调用该类的addAnalyzer()方法 上面的E文相信大家都能看懂的 就不需要我来翻译了 我的英语很差 着急啊 呵呵 　　也就是说大家以前初始化分析器的时候用这一句: 　　Analyzer *** yzer = new StandardAnalyzer(); 　　现在可以改用 　　PerFieldAnalyzerWrapper *** yzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer()); 　　然后如果需要特定域的分析器就调用addAnalyzer方法 　　 *** yzer addAnalyzer( fieldname new KeywordAnalyzer()); lishixinzhi/Article/program/Java/hx/201311/25894

java的开源的免费全文检索工具Lucene Lucene不是一个完整的全文索引应用，而是是一个用Java写的全文索引引擎工具包，它可以方便的嵌入到各种应用中实现针对应用的全文索引/检索功能。 Lucene的作者：Lucene的贡献者Doug Cutting是一位资深全文索...

Lucene是一个开放源代码的全文检索引擎工具包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎.Solr是一个高性能，采用Java5开发，基于Lucene的全文搜索服务器。同时对其进行了扩展，提供了比Lucene更为丰富的查询语言，同时实现了可配置、可扩展并对查询性能进行了优化，并且提供了一个完善的功能管理界面，是一款非常优秀的全文搜索引擎。它对外提供类似于Web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过Http Solr Get操作提出查找请求，并得到XML格式的返回结果；Solr和Lucene的本质区别有以下三点：搜索服务器，企业级和管理。Lucene本质上是搜索库，不是独立的应用程序，而Solr是。Lucene专注于搜索底层的建设，而Solr专注于企业应用。Lucene不负责支撑搜索服务所必须的管理，而Solr负责。所以说，一句话概括Solr: Solr是Lucene面向企业搜索应用的扩展

你的问题跟我要问的一字不差啊!

Lucene： java写的单机搜索引擎Solr和Elasticsearch都是流行的搜索引擎，都是基于Java，但它们有一些区别。Solr是基于Lucene的搜索服务器，而Elasticsearch是一个分布式搜索和分析引擎。Solr更适合传统的企业搜索场景，而Elasticsearch更适合实时搜索和分析场景。Elasticsearch还具有更好的可扩展性和更好的文档处理能力。还有新的搜索引擎，基于c++开发的小唐代码搜索引擎，基于rust开发的github代码搜索引擎。

1、什么是lucene Lucene是一个全文搜索框架，而不是应用产品。因此它并不像http://www.baidu.com/ 或者google Desktop那么拿来就能用，它只是提供了一种工具让你能实现这些产品。 2、lucene能做什么 要回答这个问题，先要了解lucene的本质。实际上lucene的功能很单一，说到底，就是你给它若干个字符串，然后它为你提供一个全文搜索服务，告诉你你要搜索的关键词出现在哪里。知道了这个本质，你就可以发挥想象做任何符合这个条件的事情了。你可以把站内新闻都索引了，做个资料库；你可以把一个数据库表的若干个字段索引起来，那就不用再担心因为“%like%”而锁表了；你也可以写个自己的搜索引擎……

lucene的检索算法属于索引检索，即用空间来换取时间，对需要检索的文件、字符流进行全文索引，在检索的时候对索引进行快速的检索，得到检索位置，这个位置记录检索词出现的文件路径或者某个关键词。 lucene 在存储它的全文索引结构时，是有层次结构的，这涉及到5个层次：索引(Index)；段(Segment)；文档(Document)；域(Field)；词(Term)，他们的关系如下图所示：（lucene 索引存储结构概念图） 下图是Lucene生成的索引的一个实例，右边是对这5个层次的描述： Lucene的索引结构是有层次结构的，主要分以下几个层次： Lucene的索引结构中，即保存了正向信息，也保存了反向信息。 所谓正向信息： 所谓反向信息： 段(Segment) 的控制策略 在建立索引的时候对性能影响最大的地方就是在将索引写入文件的时候, 所以在具体应用的时候就需要对此加以控制: Lucene默认情况是每加入10份文档(Document)就从内存往index文件写入并生成一个段(Segment) ,然后每10个段(Segment)就合并成一个段(Segment). 这些控制的变量如下： MaxMergeDocs用于控制一个segment文件中最多包含的Document数.比如限制为100的话,即使当前有10个segment也不会合并,因为合并后的segment将包含1000个文档,超过了限制。 MinMergeDocs用于确定一个当内存中文档达到多少的时候才写入文件,该项对segment的数量和大小不会有什么影响,它仅仅影响内存的使用,进一步影响写索引的效率。

卢僧

Lucene的下载lucene在jakarta项目中的发布主页：::URL::http://jakarta.apache.org/lucene/docs/index.html。以下主要针对windows用户，其它用户请在上面的地址中查找相关下载。lucene的.jar包的下载（包括.jar和一个范例demo）：::URL::http://apache.oregonstate.edu/jakarta/lucene/binaries/lucene-1.4-final.ziplucene的源代码下载：::URL::http://www.signal42.com/mirrors/apache/jakarta/lucene/source/lucene-1.4-final-src.ziplucene的api地址：::URL::http://jakarta.apache.org/lucene/docs/api/index.html

些刚接触Lucene说使用关键:ApacheLucene由java编写高性能全位单词搜索引擎库批评前我必须承认Lucene高性能划词搜索引擎几Lucene已经看作用java编写嵌入式搜索引擎等公民声誉每剧增并且仍源java搜索引擎佳每都说:DougCutting做项伟工作近几月内发进程变缓慢我认Lucene满足现代文档处理需求要东西搞糟:我搜索引擎发者我发者使用搜索引擎提供合适信息检索科技贴讨论未发者言Lucene选择至少我言并且情况并没改变我列Lucene局限性:Lingway公司基于语意复杂查询例查找关于东区冲突文章许需要找关于伊拉克战争文章面用例战争伊拉克别冲突东扩展我使用种技术能析查询产相应合适扩展查询相关结些够:通Lucene实现类似Google等级或经变化积并能满足语意级别积例包含东短语超单词隔种情况并我想要查找更重要相规单词我应该给扩展更低数比我应该给东区冲突短语更高数伊拉克战争Lingway公司我认种文章相关性技术种未搜索引擎Google文章搜索做色我想要却相关文章部代搜索引擎都没复杂查询做相关设计…Lucenewikipedia使用注意查询查单词数查询结并由关联…演示需求Lingway公司即线KM3.7产品界面截图我用语写查询用查找些同主题用英语写文章注意仅仅简简单单翻译我称语言交叉模式:注意些绿色匹配:chanteur变singer,我发现singing匹配同情况流行乐蓝调扩展6理由选用Lucene6.没集群内置支持创建集群写自Directory实现或使用Solr或者使用Nutch+HadoopSolrNutch都支持Lucene直接替代Lucene嵌入必须支持SolrNutch..我认HadoopLucene团队产并惊讶:Lucene并通用内性决定数场合说非快速型文档集合,排除Lucene内核级别并没实现集群必须Lucene转换别搜索引擎做并直接转换Solr或者Nutch问题让遇许必要麻烦:Nutch集crawlingSolr检索服务5.跨度查询太慢Lingway公司说能特殊问题我跨度查询强要求,Lucene检索结构已经始添加细节初没想基础实现导致复杂算并且运行缓慢尤其某些短语份文档重复许现我倾向说Lucene高性能划词检索引擎仅仅使用基本布尔查询4.积能插件化Lucene自积算实现,条件增加使用Similarity类快显示局限性想要表示复杂积,例基于实际匹配元数据查询做继承Lucene查询类Lucene使用类似tf/idf积算我遇场合语意积Lucene积机制并合适我迫重写每Lucene查询类使支持我自定义积问题3.Lucene并非良设计作系统架构师我倾向认(1)Lucene非糟糕OO设计虽包类设计几乎没任何设计模式让我想起由C(++)发者行并且坏习惯带java造需要自定义Lucene满足需求(必定遇需求)必须面问题例:几乎没使用接口查询类(例BooleanQuery,SpanQuery,TermQuery…)都抽象类类要添加其细节首先想写接口描述扩展契约抽象Query类并没实现接口必须经变化自查询象Query并本Lucene调用堆例(HitCollecor,…)使用AOP自代理说问题.别扭迭代实现.没hasNext(),next()返布尔类型并刷新象内容.想要保持迭代元素跟踪说非痛苦.我假定故意用节省内存导致算杂乱复杂.2.关闭API使继承Lucene痛苦Lucene世界,称特性某些用户需要某些细节针放类导致数类都包保护级别意味着能够继承(除非创建类似同包做污染客户代码)或者复制重写代码更重要同面点提严重缺乏OO设计结构些类应该设内部类却没匿名类用作复杂计算需要重写行关闭API理由让代码发布前变整洁并且稳定虽想光荣再让痛苦些代码Lucene主要思路并吻合经归Lucene改进自版本直补丁接受发者始越越限制API更改补丁少机接受些类加final修饰符让遇问题我认Spring框架限制觉流行起1.Lucene搜索算适合网格计算Lucene写候硬件没内存处理器存索引结构设计使用线性内存销式我花间重写跨度查询算并使用线程内容(使用双核处理器)基于迭代器目录读取算几乎能实现些罕见场合能做些优化并能迭代索引通并行式数场合能我遇情况我复杂超50+内嵌跨度查询CPU空闲I/O却直忙碌甚至使用RAMDirectory.没替代品我认观点充满疑问:Lucene达极限现硬件基础条件检索型数据集合我寻找替代Lucene现阅读博客目录Wikia讨论我发现并没替代品我推荐希望案:MG4J良面向象设计性能良检索(索引比Lucene慢)内存销达10倍于Lucene速度跨度查询我跨度查询基准并且原支持集群同内置负载平衡Lucene近才加入项功能并且实验性质MG4J仍缺少些特性例简单索引指数文档移除更简单使用索引处理让我高兴我自定义Lucene功能MG4J需花几Lucene却需要数我认源搜索引擎说仍发展空间通单台电脑用限内存索引批量文档通透明布式索引提供型数据集合检索更快捷答案必利用应用获集群特性Lucene第类搜索引擎实现单我认并符合我需求:合理间内找佳答案基于tf/idf搜索算google等级并未搜索引擎趋势实现原数据语义复杂查询并找相关信息Lingway公司(通Lucene其搜索引擎技术)所作要求更支持新硬件新技术使用Lucene理由论我何指责Lucene,仍java源解决案佳实现

4.1　网络蜘蛛原理4.1.1　体系结构设计4.1.2　访问策略与算法4.1.3　效率优化与更新4.1.4　蜘蛛访问规范4.1.5　开源蜘蛛简介4.2　Nutch网络蜘蛛4.2.1　Nutch网络蜘蛛概述4.2.2　Nutch抓取模式分类4.2.3　抓取测试站点建立4.3　Nutch局域网抓取4.3.1　本地下载准备4.3.2　启动下载过程4.3.3　下载过程解析4.3.4　下载多个网站4.4　Nutch互联网抓取4.4.1　下载列表获取4.4.2　下载大量网站4.5　Nutch抓取比较4.6　Nutch结果检测4.6.1　网页内容检索4.6.2　使用Readdb获取摘要4.6.3　使用SegRead读取分段4.6.4　Luke工具使用4.7　Nutch配置文件解析4.8　Heritrix网络蜘蛛4.8.1　Heritrix概述4.8.2　Heritrix体系结构4.8.3　Heritrix安装与使用4.9　小结 5.1　文档索引原理5.1.1　索引概述5.1.2　索引基本结构5.1.3　倒排索引原理5.1.4　索引分类5.1.5　高性能索引5.2　Lucene索引器5.2.1　Lucene索引介绍5.2.2　Lucene索引结构5.2.3　多文件索引结构5.2.4　复合索引结构5.3　Lucene索引实例5.3.1　索引创建代码解析5.3.2　索引创建器（IndexWriter）5.3.3　索引管理器（IndexReader）5.3.4　索引修改器（IndexModifier）5.3.5　索引分析器（Analyzer）5.4　Lucene索引操作5.4.1　添加文本文件索引5.4.2　创建Lucene增量索引5.4.3　使用索引项删除文档5.4.4　使用编号删除文档5.4.5　压缩文档编号5.4.6　索引文档更新5.5　Lucene索引高级特性5.5.1　选择索引域类型5.5.2　索引参数优化5.5.3　使用磁盘索引5.5.4　使用内存索引5.5.5　同步与锁机制5.6　Lucene高级应用实例5.6.1　创建本地搜索的索引5.6.2　索引数据库记录5.6.3　索引优化与合并5.7　Nutch中的Lucene索引5.8　小结 6.1　信息查询原理6.1.1　信息查询概述6.1.2　查询基本流程6.1.3　查询结果显示6.1.4　高性能查询6.2　Lucene查询概述6.2.1　Lucene查询操作基础6.2.2　Lucene查询实例入门6.2.3　查询工具IndexSearcher类6.2.4　查询封装Query类6.2.5　查询分析器QueryParser类6.2.6　查询结果集Hits类6.3　Lucene基本查询6.3.1　Lucene查询Query对象6.3.2　最小项查询TermQuery6.3.3　区间范围搜索RangeQuery6.3.4　逻1/4组合搜索BooleanQuery6.3.5　字串前缀搜索PrefixQuery6.3.6　短语搜索PhraseQuery6.3.7　模糊搜索FuzzyQuery6.3.8　通配符搜索WildcardQuery6.3.9　位置跨度搜索SpanQuery6.4　Lucene高级查询6.4.1　索引内存检索6.4.2　多关键字跨域检索6.4.3　多检索器跨索引检索6.5　Nutch中的Lucene查询6.6　小结 7.1　搜索引擎文档排序原理7.1.1　传统检索排序技术7.1.2　向量模型排序局限7.1.3　搜索引擎相关性排序7.1.4　链接分析PageRank原理7.1.5　搜索引擎排序流程7.2　Lucene检索排序7.2.1　Lucene相关性因素7.2.2　Lucene相关排序流程7.2.3　Lucene排序计算体系7.2.4　Lucene排序控制方法7.3　文档Boost加权排序7.3.1　Lucene中Boost介绍7.3.2　Boost值全文档排序7.3.3　Boost值文档域排序7.3.4　BoostingTermQuery排序7.4　Sort对象检索排序7.4.1　Sort对象概述7.4.2　Sort对象相关性排序7.4.3　Sort对象文档编号排序7.4.4　Sort对象独立域排序7.4.5　Sort对象联合域排序7.4.6　Sort对象逆向排序7.5　Lucene相关性公式7.5.1　Lucene评分结果分析7.5.2　Lucene排序公式7.5.3　其他动态排序因子7.6　Lucene自定义排序7.6.1　自定义排序比较接口7.6.2　自定义排序接口类实例7.6.3　自定义排序结果测试实例7.6.4　自定义排序测试结果7.7　Nutch中的结果排序7.7.1　Nutch排序因素7.7.2　Nutch链接分析7.7.3　Nutch相关度计算7.8　小结 8.1　文档分析与中文分词原理8.1.1　文档分析预处理概述8.1.2　文档分析基本流程8.1.3　中文分析处理中的分词8.2　Lucene分析器内核原理8.2.1　Lucene分析器原理8.2.2　Analysis包简介8.2.3　Analyzer类的组合结构8.2.4　JavaCC构造分析器8.2.5　StopAnalyzer内核代码分析8.2.6　StandardAnalyzer内核代码分析8.3　Lucene分析器应用模式8.3.1　使用默认分析器建立索引8.3.2　使用多种分析器建立索引8.3.3　使用分析器检索查询8.4　Lucene主要分析器应用实例8.4.1　停用词分析器StopAnalyzer8.4.2　标准分析器StandardAnalyzer8.4.3　简单分析器SimpleAnalyzer8.4.4　空格分析器WhitespaceAnalyzer8.4.5　关键字分析器KeywordAnalyzer8.5　TokenStream分词器内核分析8.5.1　Tokenizer分词器8.5.2　标准分词器StandardTokenizer8.5.3　字符分词器CharTokenizer8.5.4　空格分词器WhiteSpaceTokenizer8.5.5　字母分词器LetterTokenizer8.5.6　小写分词器LowerCaseTokenizer8.6　TokenStream过滤器内核分析8.6.1　TokenFilter过滤器8.6.2　标准过滤器StandardFilter8.6.3　停用词过滤器StopFilter8.6.4　小写过滤器LowerCaseFilter8.6.5　长度过滤器LengthFilter8.6.6　词干过滤器PorterStemFilter8.7　Lucene中文分词8.7.1　中文分词基本原理方法8.7.2　StandardAnalyzer分析器中文处理8.7.3　CJKAnalyzer中文分析器8.7.4　ChineseAnalyzer中文分析器8.7.5　IK_CAnalyzer中文分析器8.7.6　中科院ICTCLAS中文分词8.7.7　JE中文分词8.7.8　中文分词问题8.8　Nutch分词和预处理8.8.1　Nutch分析器8.8.2　Nutch中文分词8.9　小结 9.1　非结构化文本简介9.1.1　非结构化文本概述9.1.2　非结构化文本检索9.2　HTML文档分析9.2.1　主流HTML文档分析器9.2.2　HTMLParser安装配置9.2.3　HTMLParser的框架结构9.3　HTMLParser应用实例9.3.1　HTMLParser功能模式9.3.2　HTMLParser内容解析方式9.3.3　Visitor模式正文解析9.3.4　Filter模式简单链接提取9.3.5　Filter模式搜索链接提取9.3.6　Lexer模式遍历文档9.4　PDF文档分析9.4.1　常用的PDF处理包9.4.2　PDFBox安装配置9.5　PDFBox应用实例9.5.1　PDFBox提取文档内容9.5.2　PDFBox文档内容索引9.6　Office文档分析9.6.1　常用Office文档处理包9.6.2　使用POI安装与配置9.6.3　POI原理与接口介绍9.7　POI分析Office文档实例9.7.1　POI处理Excel文档9.7.2　POI处理Word文档9.8　XML文档分析9.8.1　主流XML文档分析器9.8.2　JDOM分析器安装配置9.8.3　xerces分析器安装配置9.9　XML解析应用实例9.9.1　使用JDOM分析XML 文档9.9.2　使用xerces分析XML 文档9.10　Nutch文档处理9.11　小结 10.1　分布式检索与缓存10.1.1　分布式搜索引擎现状10.1.2　分布式搜索引擎原理10.1.3　搜索引擎缓存现状10.1.4　搜索引擎缓存原理10.2　Nutch与分布式检索10.2.1　Google分布式文件系统10.2.2　MapReduce系统介绍10.2.3　Hadoop分布式文件系统10.2.4　Nutch分布式文件系统10.2.5　Nutch分布式检索概述10.2.6　Nutch分布式检索器10.3　Lucene分布式检索10.3.1　Socket通信基础10.3.2　Lucene索引服务器10.4　Nutch与搜索缓存10.5　开源系统缓存系统10.6　小结

Lucene其实是一个提供全文文本搜索的函数库，它不是一个应用软件。它提供很多API函数让你可以运用到各种实际应用程序中。现在，它已经成为Apache的一个项目并被广泛应用着。Nutch是一个建立在Lucene核心之上的Web搜索的实现，它是一个真正的应用程序。也就是说，你可以直接下载下来拿过来用。它在Lucene的基础上加了网络爬虫和一些和Web相关的东东。其目的就是想从一个简单的站内索引和搜索推广到全球网络的搜索上，就像Google和Yahoo一样。当然，和那些巨人竞争，你得动一些脑筋，想一些办法。我们已经测试过100M的网页，并且它的设计用在超过1B的网页上应该没有问题。当然，让它运行在一台机器上，搜索一些服务器，也运行的很好。 总的来说，我认为LUCENE会应用在本地服务器的网站内部搜索，而Nutch则扩展到整个网络、Internet的检索。当然LUCENE加上爬虫程序等就会成为Nutch，这样理解应该没错吧。

创建索引的过程如下： 索引结构如下： IndexWriter结构： IndexWriter通过指定存放的目录（Directory）以及文档分析器（Analyzer）来构建，direcotry代表索引存储在哪里；analyzer表示如何来分析文档的内容；similarity用来规格化文档，给文档算分；IndexWriter类里还有一些SegmentInfos对象用于存储索引片段信息，以及发生故障回滚等。 添加文档使用addDocument()方法，删除文档使用deleteDocuments(Term)或者deleteDocuments(Query)方法，而且一篇文档可以使用updateDocument()方法来更新（仅仅是先执行delete在执行add操作而已）。当完成了添加、删除、更新文档，应该需要调用close方法。 这些修改会缓存在内存中（buffered in memory），并且定期地（periodically）刷新到（flush）Directory中（在上述方法的调用期间）。一次flush操作会在如下时候触发（triggered）：当从上一次flush操作后有足够多缓存的delete操作（参见setMaxBufferedDeleteTerms(int)），或者足够多已添加的文档（参见setMaxBufferedDocs(int)），无论哪个更快些（whichever is sooner）。对被添加的文档来说，一次flush会在如下任何一种情况下触发，文档的RAM缓存使用率（setRAMBufferSizeMB）或者已添加的文档数目，缺省的RAM最高使用率是16M，为得到索引的最高效率，你需要使用更大的RAM缓存大小。需要注意的是，flush处理仅仅是将IndexWriter中内部缓存的状态（internal buffered state）移动进索引里去，但是这些改变不会让IndexReader见到，直到commit()和close()中的任何一个方法被调用时。一次flush可能触发一个或更多的片断合并（segmentmerges），这时会启动一个后台的线程来处理，所以不会中断addDocument的调用，请参考MergeScheduler。 一个IndexReader或者IndexSearcher只会看到索引在它打开的当时的状态。任何在索引被打开之后提交到索引中的commit信息，在它被重新打开之前都不会见到。 DocumentsWriter结构： DocumentsWriter 是由IndexWriter 调用来负责处理多个文档的类，它通过与Directory 类及Analyzer 类、Scorer 类等将文档内容提取出来，并分解成一组term列表再生成一个单一的segment 所需要的数据文件，如term频率、term 位置、term 向量等索引文件，以便SegmentMerger 将它合并到统一的segment 中去。 该类可接收多个添加的文档，并且直接写成一个单独的segment 文件。这比为每一个文档创建一个segment（使用DocumentWriter）以及对那些segments 执行合作处理更有效率。 每一个添加的文档都被传递给DocConsumer类，它处理该文档并且与索引链表中（indexing chain）其它的consumers相互发生作用（interacts with）。确定的consumers，就像StoredFieldWriter和TermVectorsTermsWriter，提取一个文档的摘要（digest），并且马上把字节写入“文档存储”文件（比如它们不为每一个文档消耗（consume）内存RAM，除了当它们正在处理文档的时候）。 其它的consumers，比如FreqProxTermsWriter和NormsWriter，会缓存字节在内存中，只有当一个新的segment制造出的时候才会flush到磁盘中。 一旦使用完我们分配的RAM缓存，或者已添加的文档数目足够多的时候（这时候是根据添加的文档数目而不是RAM的使用率来确定是否flush），我们将创建一个真实的segment，并将它写入Directory中去。 索引创建的调用过程： 一个Directory对象是一系列统一的文件列表（a flat list of files）。文件可以在它们被创建的时候一次写入，一旦文件被创建，它再次打开后只能用于读取（read）或者删除（delete）操作。并且同时在读取和写入的时候允许随机访问。 FSDirectory类直接实现Directory抽象类为一个包含文件的目录。目录锁的实现使用缺省的SimpleFSLockFactory，但是可以通过两种方式修改，即给getLockFactory()传入一个LockFactory实例，或者通过调用setLockFactory()方法明确制定LockFactory类。 目录将被缓存（cache）起来，对一个指定的符合规定的路径（canonical path）来说，同样的FSDirectory实例通常通过getDirectory()方法返回。这使得同步机制（synchronization）能对目录起作用。 RAMDirectory类是一个驻留内存的（memory-resident）Directory抽象类的实现。目录锁的实现使用缺省的SingleInstanceLockFactory，但是可以通过setLockFactory()方法修改。 IndexInput类是一个为了从一个目录（Directory）中读取文件的抽象基类，是一个随机访问（random-access）的输入流（input stream），用于所有Lucene读取Index的操作。BufferedIndexInput是一个实现了带缓冲的IndexInput的基础实现。 IndexOutput类是一个为了写入文件到一个目录（Directory）中的抽象基类，是一个随机访问（random-access）的输出流（output stream），用于所有Lucene写入Index的操作。BufferedIndexOutput是一个实现了带缓冲的IndexOutput的基础实现。RAMOuputStream是一个内存驻留（memory-resident）的IndexOutput的实现类。 域索引选项通过倒排索引来控制文本是否可被搜索。 当lucene建立起倒排索引后，默认情况下它会保存所有必要的信息以实施Vector Space Model。该Model需要计算文档中出现的Term数，以及它们出现的文职（这是必要的，比如通过词组搜索时用到）。但有时候这些域只是在布尔搜索时用到，他们并不为相关评分做贡献，一个常见的例子是，域只是被用作过滤，如权限过滤和日期过滤。在这种情况下，可以通过调用Field.setOmitTermFreqAndPositions(true)方法让lucene跳过对改选项的出现频率和出现位置的索引。该方法可以节省一些索引在磁盘上的储存空间，还可以加速搜索和过滤过程，但会悄悄阻止需要位置信息的搜索，如阻止PhraseQuery和SpanQuery类的运行。 域存储选项是用来确定是否需要存储域的真实值，以便后续搜索时能回复这个值。 lucene支持想一个域中写入多个不同的值。 这种处理方式是完全可以接受并鼓励使用的，因为这是逻辑上具有多个域值的域的自然表示方式。在lucene内部，只要文档中出现同名的多域值，倒排索引和项向量都会在逻辑上将这些语汇单元附加进去，具体顺序由添加该域的顺序决定。 文档和域的加权操作可以在索引期间完成。而搜索期间的加权操作会更加动态化，因为每次搜索都可以根据不同的加权因子独立选择加权或不加权，但这个策略也可能多消耗一些CPU效率。搜索期间的动态加权可以更灵活控制。 默认情况下，所有文档的加权因子都是1.0，通过改变文档的加权因子，就可以影响文档在索引中的重要程度。调整加权操作的API为：setBoost(float)； 同文档加权一样，可以对进行加权操作。文档加权时，lucene内部会采用同一加权因子来对该文档中的域进行加权。域加权API：Field.setBoost(fliat)。 Analyzer类构建用于分析文本的TokenStream对象，因此（thus）它表示（represent）用于从文本中分解（extract）出组成索引的terms的一个规则器（policy）。典型的（typical）实现首先创建一个Tokenizer，它将那些从Reader对象中读取字符流（stream of characters）打碎为（break into）原始的Tokens（raw Tokens）。然后一个或更多的TokenFilters可以应用在这个Tokenizer的输出上。警告：你必须在你的子类（subclass）中覆写（override）定义在这个类中的其中一个方法，否则的话Analyzer将会进入一个无限循环（infinite loop）中。 StandardAnalyzer： StandardAnalyzer类是使用一个English的stop words列表来进行tokenize分解出文本中word，使用StandardTokenizer类分解词，再加上StandardFilter以及LowerCaseFilter以及StopFilter这些过滤器进行处理的这样一个Analyzer类的实现。

您去下载3.0或者3.5 官方就自带的高亮

目　录第1部分　Lucene核心第1章　初识Lucene 31.1　应对信息爆炸 41.2　Lucene是什么 51.2.1　Lucene能做些什么 61.2.2　Lucene的历史 71.3　Lucene和搜索程序组件 91.3.1　索引组件 101.3.2　搜索组件 131.3.3　搜索程序的其他模块 161.3.4　Lucene与应用程序的整合点 181.4　Lucene实战：程序示例 181.4.1　建立索引 191.4.2　搜索索引 221.5　理解索引过程的核心类 251.5.1　IndexWriter 251.5.2　Directory 251.5.3　Analyzer 261.5.4　Document 261.5.5　Field 271.6　理解搜索过程的核心类 271.6.1　IndexSearcher 271.6.2　Term 281.6.3　Query 281.6.4　TermQuery 281.6.5　TopDocs 291.7　小结 29第2章　构建索引　302.1　Lucene如何对搜索内容进行建模 312.1.1　文档和域 312.1.2　灵活的架构 322.1.3　反向规格化(Denormalization) 322.2　理解索引过程 332.2.1　提取文本和创建文档 332.2.2　分析文档 342.2.3　向索引添加文档 342.3　基本索引操作 352.3.1　向索引添加文档 352.3.2　删除索引中的文档 382.3.3　更新索引中的文档 392.4　域选项 412.4.1　域索引选项 412.4.2　域存储选项 422.4.3　域的项向量选项 422.4.4　Reader、TokenStream和byte[ ]域值 422.4.5　域选项组合 432.4.6　域排序选项 442.4.7　多值域 442.5　对文档和域进行加权操作 452.5.1　文档加权操作 452.5.2　域加权操作 462.5.3　加权基准(Norms) 472.6　索引数字、日期和时间 482.6.1　索引数字 482.6.2　索引日期和时间 492.7　域截取(Field truncation) 502.8　近实时搜索(Near-real-time search) 512.9　优化索引 512.10　其他Directory子类 522.11　并发、线程安全及锁机制 552.11.1　线程安全和多虚拟机安全 552.11.2　通过远程文件系统访问索引 562.11.3　索引锁机制 572.12　调试索引 592.13　高级索引概念 602.13.1　用IndexReader删除文档 612.13.2　回收被删除文档所使用过的磁盘空间 622.13.3　缓冲和刷新 622.13.4　索引提交 632.13.5　ACID事务和索引连续性 652.13.6　合并段 662.14　小结 68第3章　为应用程序添加搜索功能　703.1　实现简单的搜索功能 713.1.1　对特定项的搜索 723.1.2　解析用户输入的查询表达式：QueryParser 733.2　使用IndexSearcher类 763.2.1　创建IndexSearcher类 763.2.2　实现搜索功能 783.2.3　使用TopDocs类 783.2.4　搜索结果分页 793.2.5　近实时搜索 793.3　理解Lucene的评分机制 813.3.1　Lucene如何评分 813.3.2　使用explain()理解搜索结果评分 833.4　Lucene的多样化查询 843.4.1　通过项进行搜索：TermQuery类 853.4.2　在指定的项范围内搜索：TermRangeQuery类 863.4.3　在指定的数字范围内搜索：NumericRangeQuery类 873.4.4　通过字符串搜索：PrefixQuery类 883.4.5　组合查询：BooleanQuery类 883.4.6　通过短语搜索：PhraseQuery类 913.4.7　通配符查询：WildcardQuery类 933.4.8　搜索类似项：FuzzyQuery类 943.4.9　匹配所有文档：MatchAllDocsQuery类 953.5　解析查询表达式：QueryParser 963.5.1　Query.toString方法 973.5.2　TermQuery 973.5.3　项范围查询 983.5.4　数值范围搜索和日期范围搜索 993.5.5　前缀查询和通配符查询 993.5.6　布尔操作符 1003.5.7　短语查询 1003.5.8　模糊查询 1013.5.9　MatchAllDocsQuery 1023.5.10　分组查询 1023.5.11　域选择 1033.5.12　为子查询设置加权 1033.5.13　是否一定要使用QueryParse 1033.6　小结 104第4章　Lucene的分析过程 1054.1　使用分析器 1064.1.1　索引过程中的分析 1074.1.2　QueryParser分析 1094.1.3　解析vs分析：分析器何时不再适用 1094.2　剖析分析器 1104.2.1　语汇单元的组成 1114.2.2　语汇单元流揭秘 1124.2.3　观察分析器 1154.2.4　语汇单元过滤器：过滤顺序的重要性 1194.3　使用内置分析器 1214.3.1　StopAnalyzer 1224.3.2　StandardAnalyzer 1224.3.3　应当采用哪种核心分析器 1234.4　近音词查询 1234.5　同义词、别名和其他表示相同意义的词 1264.5.1　创建SynonymAnalyzer 1274.5.2　显示语汇单元的位置 1314.6　词干分析 1324.6.1　StopFilter保留空位 1334.6.2　合并词干操作和停用词移除操作 1344.7　域分析 1344.7.1　多值域分析 1354.7.2　特定域分析 1354.7.3　搜索未被分析的域 1364.8　语言分析 1394.8.1　Unicode与字符编码 1394.8.2　非英语语种分析 1404.8.3　字符规范化处理 1404.8.4　亚洲语种分析 1414.8.5　有关非英语语种分析的其他问题 1434.9　Nutch分析 1444.10　小结 146第5章　高级搜索技术　1475.1　Lucene域缓存 1485.1.1　为所有文档加载域值 1495.1.2　段对应的reader 1495.2　对搜索结果进行排序 1505.2.1　根据域值进行排序 1505.2.2　按照相关性进行排序 1535.2.3　按照索引顺序进行排序 1545.2.4　通过域进行排序 1545.2.5　倒排序 1555.2.6　通过多个域进行排序 1565.2.7　为排序域选择类型 1575.2.8　使用非默认的locale方式进行排序 1575.3　使用MultiPhraseQuery 1585.4　针对多个域的一次性查询 1605.5　跨度查询 1625.5.1　跨度查询的构建模块：SpanTermQuery 1655.5.2　在域的起点查找跨度 1665.5.3　彼此相邻的跨度 1675.5.4　在匹配结果中排除重叠的跨度 1695.5.5　SpanOrQuery类 1705.5.6　SpanQuery类和QueryParser类 1715.6　搜索过滤 1725.6.1　TermRangeFilter 1735.6.2　NumericRangeFilter 1745.6.3　FieldCacheRangeFilter 1745.6.4　特定项过滤 1745.6.5　使用QueryWrapperFilter类 1755.6.6　使用SpanQueryFilter类 1755.6.7　安全过滤器 1765.6.8　使用BooleanQuery类进行过滤 1775.6.9　PrefixFilter 1785.6.10　缓存过滤结果 1785.6.11　将filter封装成query 1795.6.12　对过滤器进行过滤 1795.6.13　非Lucene内置的过滤器 1805.7　使用功能查询实现自定义评分 1805.7.1　功能查询的相关类 1805.7.2　使用功能查询对最近修改过的文档进行加权 1825.8　针对多索引的搜索 1845.8.1　使用MultiSearch类 1845.8.2　使用ParallelMultiSearcher进行多线程搜索 1865.9　使用项向量 1865.9.1　查找相似书籍 1875.9.2　它属于哪个类别 1905.9.3　TermVectorMapper类 1935.10　使用FieldSelector加载域 1945.11　停止较慢的搜索 1955.12　小结 196第6章　扩展搜索　1986.1　使用自定义排序方法 1996.1.1　针对地理位置排序方式进行文档索引 1996.1.2　实现自定义的地理位置排序方式 2006.1.3　访问自定义排序中的值 2036.2　开发自定义的Collector 2046.2.1　Collector基类 2056.2.2　自定义Collector：BookLinkCollector 2066.2.3　AllDocCollector类 2076.3　扩展QueryParser类 2086.3.1　自定义QueryParser的行为 2086.3.2　禁用模糊查询和通配符查询 2096.3.3　处理数值域的范围查询 2106.3.4　处理日期范围 2116.3.5　对已排序短语进行查询 2136.4　自定义过滤器 2156.4.1　实现自定义过滤器 2156.4.2　搜索期间使用自定义过滤器 2166.4.3　另一种选择：FilterQuery类 2176.5　有效载荷(Payloads) 2186.5.1　分析期间生成有效载荷 2196.5.2　搜索期间使用有效载荷 2206.5.3　有效载荷和跨度查询 2236.5.4　通过TermPositions来检索有效载荷 2236.6　小结 223第2部分　Lucene应用第7章　使用Tika提取文本　2277.1　Tika是什么 2287.2　Tika的逻辑设计和API 2307.3　安装Tika 2317.4　Tika的内置文本提取工具 2327.5　编程实现文本提取 2347.5.1　索引Lucene文档 2347.5.2　Tika工具类 2377.5.3　选择自定义分析器 2387.6　Tika的局限 2387.7　索引自定义的XML文件 2397.7.1　使用SAX进行解析 2397.7.2　使用Apache Commons Digester进行解析和索引 2427.8　其他选择 2447.9　小结 245第8章　Lucene基本扩展　2468.1　Luke：Lucene的索引工具箱 2478.1.1　Overview标签页：索引的全局视图 2488.1.2　浏览文档 2498.1.3　使用QueryParser进行搜索 2518.1.4　Files and Plugins标签页 2528.2　分析器、语汇单元器和语汇单元过滤器 2538.2.1　SnowballAnalyzer 2558.2.2　Ngram过滤器 2568.2.3　Shingle过滤器 2588.2.4　获取捐赠分析器 2588.3　高亮显示查询项 2598.3.1　高亮显示模块 2598.3.2　独立的高亮显示示例 2628.3.3　使用CSS进行高亮显示处理 2638.3.4　高亮显示搜索结果 2648.4　FastVector Highlighter类 2668.5　拼写检查 2698.5.1　生成提示列表 2698.5.2　选择最佳提示 2718.5.3　向用户展示搜索结果 2728.5.4　一些加强拼写检查的考虑 2738.6　引人注目的查询扩展功能 2748.6.1　MoreLikeThis 2748.6.2　FuzzyLikeThisQuery 2758.6.3　BoostingQuery 2758.6.4　TermsFilter 2768.6.5　DuplicateFilter 2768.6.6　RegexQuery 2768.7　构建软件捐赠模块(contrib module) 2778.7.1　源代码获取方式 2778.7.2　contrib目录的Ant插件 2778.8　小结 278第9章　Lucene高级扩展　2799.1　链式过滤器 2809.2　使用Berkeley DB存储索引 2829.3　WordNet同义词 2849.3.1　建立同义词索引 2859.3.2　将WordNet同义词链接到分析器中 2879.4　基于内存的快速索引 2899.5　XML QueryParser：超出“one box”的搜索接口 2899.5.1　使用XmlQueryParser 2919.5.2　扩展XML查询语法 2959.6　外围查询语言 2969.7　Spatial Lucene 2989.7.1　索引空间数据 2999.7.2　搜索空间数据 3029.7.3　Spatial Lucene的性能特点 3049.8　远程进行多索引搜索 3069.9　灵活的QueryParser 3099.10　其他内容 3129.11　小结 313第10章　其他编程语言使用Lucene　31410.1　移植入门 31510.1.1　移植取舍 31610.1.2　选择合适的移植版本 31710.2　CLucene(C++) 31710.2.1　移植目的 31810.2.2　API和索引兼容 31910.2.3　支持的平台 32110.2.4　当前情况以及未来展望 32110.3　Lucene-Net(C#和其他.NET编程语言) 32110.3.1　API兼容 32310.3.2　索引兼容 32410.4　KinoSearch和Lucy(Perl) 32410.4.1　KinoSearch 32510.4.2　Lucy 32710.4.3　其他Perl选项 32710.5　Ferret(Ruby) 32810.6　PHP 32910.6.1　Zend Framework 32910.6.2　PHP Bridge 33010.7　PyLucene(Python) 33010.7.1　API兼容 33210.7.2　其他Python选项 33210.8　Solr(包含多种编程语言) 33210.9　小结 334第11章　Lucene管理和性能调优　33511.1　性能调优 33611.1.1　简单的性能调优步骤 33711.1.2　测试方法 33811.1.3　索引-搜索时延调优 33911.1.4　索引操作吞吐量调优 34011.1.5　搜索时延和搜索吞吐量调优 34411.2　多线程和并行处理 34611.2.1　使用多线程进行索引操作 34711.2.2　使用多线程进行搜索操作 35111.3　资源消耗管理 35411.3.1　磁盘空间管理 35411.3.2　文件描述符管理 35711.3.3　内存管理 36111.4　热备份索引 36411.4.1　创建索引备份 36511.4.2　恢复索引 36611.5　常见错误 36711.5.1　索引损坏 36711.5.2　修复索引 36911.6　小结 369第3部分　案例分析第12章　案例分析1：Krugle　37312.1　Krugle介绍 37412.2　应用架构 37512.3　搜索性能 37612.4　源代码解析 37712.5　子串搜索 37812.6　查询VS搜索 38112.7　改进空间 38212.7.1　FieldCache内存使用 38212.7.2　合并索引 38212.8　小结 383第13章　案例分析2：SIREn　38413.1　SIREn介绍 38513.2　SIREn优势 38513.2.1　通过所有域进行搜索 38713.2.2　一种高效词典 38813.2.3　可变域 38813.2.4　对多值域的高效处理 38813.3　使用SIREn索引实体 38813.3.1　数据模型 38913.3.2　实现问题 38913.3.3　索引概要 39013.3.4　索引前的数据准备 39013.4　使用SIREn搜索实体 39213.4.1　搜索内容 39213.4.2　根据单元限制搜索范围 39313.4.3　将单元合并成元组 39313.4.4　针对实体描述进行查询 39413.5　在Solr中集成SIREn 39413.6　Benchmark 39513.7　小结 397第14章　案例分析3：LinkedIn　39814.1　使用Bobo Browse进行分组搜索 39814.1.1　Bobo Browse的设计 40014.1.2　深层次分组搜索 40314.2　使用Zoie进行实时搜索 40514.2.1　Zoie架构 40614.2.2　实时VS近实时 40914.2.3　文档与索引请求 41114.2.4　自定义IndexReaders 41114.2.5　与Lucene的近实时搜索进行比较 41214.2.6　分布式搜索 41314.3　小结 415附录A　安装Lucene　416A.1　二进制文件安装 416A.2　运行命令行演示程序 417A.3　运行Web应用演示程序 418A.4　编译源代码 419A.5　排错 420附录B　Lucene索引格式　421B.1　逻辑索引视图 421B.2　关于索引结构 422B.2.1　理解多文件索引结构 422B.2.2　理解复合索引结构 425B.2.3　转换索引结构 426B.3　倒排索引 427B.4　小结 430附录C　Lucene/contrib benchmark　431C.1　运行测试脚本 432C.2　测试脚本的组成部分 435C.2.1　内容源和文档生成器 438C.2.2　查询生成器 439C.3　控制结构 439C.4　内置任务 441C.4.1　建立和使用行文件 445C.4.2　内置报表任务 446C.5　评估搜索质量 446C.6　出错处理 449C.7　小结 449附录D　资源　450D.1　Lucene知识库 450D.2　国际化 450D.3　语言探测 451D.4　项向量 451D.5　Lucene移植版本 451D.6　案例分析 452D.7　其他 452D.8　信息检索软件 452D.9　Doug Cutting的著作 453D.9.1　会议论文 453D.9.2　美国专利 454

你具体代码？ 我的加了个红色标签 怎么可以？public String setHighlighter(String keyWord, String content) throws Exception { // 截取前一百个字 content=cutContent(content); TermQuery query = new TermQuery(new Term("field", keyWord)); Scorer scorer = new QueryScorer(query); // 创建高亮显示模板 SimpleHTMLFormatter formatter = new SimpleHTMLFormatter( "<font color="red" style="font-weight: bold">", "</font>"); // 构造高亮对象 Highlighter hig = new Highlighter(formatter, scorer); TokenStream tokens = PaodingFactory.getInstance().tokenStream("field", new StringReader(content)); // 高亮后的结果 String result = hig.getBestFragment(tokens, content); // 如果没有检索到高亮的词 if (result == null) { result = content; } return result; }

为什么不去看直接给的example呢，官方源码里自带的test写得很全，这边给你贴一个吧package org.apache.lucene;/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */import java.io.IOException;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.MockAnalyzer;import org.apache.lucene.document.Document;import org.apache.lucene.document.Field;import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.RandomIndexWriter;import org.apache.lucene.queryParser.ParseException;import org.apache.lucene.queryParser.QueryParser;import org.apache.lucene.search.TopDocs;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.store.Directory;import org.apache.lucene.util.LuceneTestCase;/** * A very simple demo used in the API documentation (src/java/overview.html). * * Please try to keep src/java/overview.html up-to-date when making changes * to this class. */public class TestDemo extends LuceneTestCase { public void testDemo() throws IOException, ParseException { Analyzer analyzer = new MockAnalyzer(random); // Store the index in memory: Directory directory = newDirectory(); // To store an index on disk, use this instead: //Directory directory = FSDirectory.open("/tmp/testindex"); RandomIndexWriter iwriter = new RandomIndexWriter(random, directory, analyzer); iwriter.w.setInfoStream(VERBOSE ? System.out : null); Document doc = new Document(); String text = "This is the text to be indexed."; doc.add(newField("fieldname", text, Field.Store.YES, Field.Index.ANALYZED)); iwriter.addDocument(doc); iwriter.close(); // Now search the index: IndexReader ireader = IndexReader.open(directory); // read-only=true IndexSearcher isearcher = new IndexSearcher(ireader); // Parse a simple query that searches for "text": QueryParser parser = new QueryParser(TEST_VERSION_CURRENT, "fieldname", analyzer); Query query = parser.parse("text"); TopDocs hits = isearcher.search(query, null, 1); assertEquals(1, hits.totalHits); // Iterate through the results: for (int i = 0; i < hits.scoreDocs.length; i++) { Document hitDoc = isearcher.doc(hits.scoreDocs[i].doc); assertEquals("This is the text to be indexed.", hitDoc.get("fieldname")); } // Test simple phrase query query = parser.parse(""to be""); assertEquals(1, isearcher.search(query, null, 1).totalHits); isearcher.close(); ireader.close(); directory.close(); }}