当前位置：文档之家 › Lucene初级教程

Lucene初级教程

  • 格式：doc
  • 大小：294.50 KB
  • 文档页数：33

Lucene初级教程2007-12-26 15:24 点击次数：0 次1 lucene简介1.1 什么是luceneLucene是一个全文搜索框架，而不是应用产品。

因此它并不像 或者google Desktop那么拿来就能用，它只是提供了一种工具让你能实现这些产品。

2 lucene的工作方式lucene提供的服务实际包含两部分：一入一出。

所谓入是写入，即将你提供的源（本质是字符串）写入索引或者将其从索引中删除；所谓出是读出，即向用户提供全文搜索服务，让用户可以通过关键词定位源。

2.1写入流程源字符串首先经过analyzer处理，包括：分词，分成一个个单词；去除stopword（可选）。

将源中需要的信息加入Document的各个Field中，并把需要索引的Field索引起来，把需要存储的Field存储起来。

将索引写入存储器，存储器可以是内存或磁盘。

2.2读出流程用户提供搜索关键词，经过analyzer处理。

对处理后的关键词搜索索引找出对应的Document。

用户根据需要从找到的Document中提取需要的Field。

3 一些需要知道的概念3.1 analyzerAnalyzer是分析器，它的作用是把一个字符串按某种规则划分成一个个词语，并去除其中的无效词语，这里说的无效词语是指英文中的“of”、“the”，中文中的“的”、“地”等词语，这些词语在文章中大量出现，但是本身不包含什么关键信息，去掉有利于缩小索引文件、提高效率、提高命中率。

分词的规则千变万化，但目的只有一个：按语义划分。

这点在英文中比较容易实现，因为英文本身就是以单词为单位的，已经用空格分开；而中文则必须以某种方法将连成一片的句子划分成一个个词语。

具体划分方法下面再详细介绍，这里只需了解分析器的概念即可。

3.2 document用户提供的源是一条条记录，它们可以是文本文件、字符串或者数据库表的一条记录等等。

一条记录经过索引之后，就是以一个Document的形式存储在索引文件中的。

用户进行搜索，也是以Document列表的形式返回。

3.3 field一个Document可以包含多个信息域，例如一篇文章可以包含“标题”、“正文”、“最后修改时间”等信息域，这些信息域就是通过Field在Document中存储的。

Field有两个属性可选：存储和索引。

通过存储属性你可以控制是否对这个Field进行存储；通过索引属性你可以控制是否对该Field进行索引。

这看起来似乎有些废话，事实上对这两个属性的正确组合很重要，下面举例说明：还是以刚才的文章为例子，我们需要对标题和正文进行全文搜索，所以我们要把索引属性设置为真，同时我们希望能直接从搜索结果中提取文章标题，所以我们把标题域的存储属性设置为真，但是由于正文域太大了，我们为了缩小索引文件大小，将正文域的存储属性设置为假，当需要时再直接读取文件；我们只是希望能从搜索解果中提取最后修改时间，不需要对它进行搜索，所以我们把最后修改时间域的存储属性设置为真，索引属性设置为假。

上面的三个域涵盖了两个属性的三种组合，还有一种全为假的没有用到，事实上Field不允许你那么设置，因为既不存储又不索引的域是没有意义的。

3.4 termterm是搜索的最小单位，它表示文档的一个词语，term由两部分组成：它表示的词语和这个词语所出现的field。

3.5 tockentocken是term的一次出现，它包含trem文本和相应的起止偏移，以及一个类型字符串。

一句话中可以出现多次相同的词语，它们都用同一个term表示，但是用不同的toc ken，每个tocken标记该词语出现的地方。

3.6 segment添加索引时并不是每个document都马上添加到同一个索引文件，它们首先被写入到不同的小文件，然后再合并成一个大索引文件，这里每个小文件都是一个segment。

4 如何建索引4.1 最简单的能完成索引的代码片断IndexWriter writer = new IndexWriter(“/data/index/”, new StandardAnalyzer(), true); Document doc = new Document();doc.add(new Field("title", "lucene introduction", Field.Store.YES, Field.Index.TOKENIZ ED));doc.add(new Field("content", "lucene works well", Field.Store.YES, Field.Index.TOKENI ZED));writer.addDocument(doc);writer.optimize();writer.close();下面我们分析一下这段代码。

首先我们创建了一个writer，并指定存放索引的目录为“/data/index”，使用的分析器为S tandardAnalyzer，第三个参数说明如果已经有索引文件在索引目录下，我们将覆盖它们。

然后我们新建一个document。

我们向document添加一个field，名字是“title”，内容是“lucene introduction”，对它进行存储并索引。

再添加一个名字是“content”的field，内容是“lucene works well”，也是存储并索引。

然后我们将这个文档添加到索引中，如果有多个文档，可以重复上面的操作，创建doc ument并添加。

添加完所有document，我们对索引进行优化，优化主要是将多个segment合并到一个，有利于提高索引速度。

随后将writer关闭，这点很重要。

对，创建索引就这么简单！当然你可能修改上面的代码获得更具个性化的服务。

4.2 索引文本文件如果你想把纯文本文件索引起来，而不想自己将它们读入字符串创建field，你可以用下面的代码创建field：Field field = new Field("content", new FileReader(file));这里的file就是该文本文件。

该构造函数实际上是读去文件内容，并对其进行索引，但不存储。

Lucene 2 教程Lucene是apache组织的一个用java实现全文搜索引擎的开源项目。

其功能非常的强大，api也很简单。

总得来说用Lucene来进行建立和搜索和操作数据库是差不多的(有点像)，Document可以看作是数据库的一行记录，Field可以看作是数据库的字段。

用lucene 实现搜索引擎就像用JDBC实现连接数据库一样简单。

Lucene2.0，它与以前广泛应用和介绍的Lucene 1.4.3并不兼容。

Lucene2.0的下载地址是/lucene/java/例子一：1、在windows系统下的的C盘，建一个名叫s的文件夹,在该文件夹里面随便建三个txt文件，随便起名啦，就叫"1.txt","2.txt"和"3.txt"啦其中1.txt的内容如下：中华人民共和国全国人民2006年而"2.txt"和"3.txt"的内容也可以随便写几写，这里懒写，就复制一个和1.txt文件的内容一样吧2、下载lucene包，放在classpath路径中建立索引:package ;import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;import java.util.Date;import org.apache.lucene.analysis.Analyzer;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;/*** author lighter date 2006-8-7*/public class TextFileIndexer {public static void main(String[] args) throws Exception {/* 指明要索引文件夹的位置,这里是C盘的S文件夹下*/File fileDir = new File( " c:\\s " );/* 这里放索引文件的位置*/File indexDir = new File( " c:\\index " );Analyzer luceneAnalyzer = new StandardAnalyzer();IndexWriter indexWriter = new IndexWriter(indexDir, luceneAnalyzer,true );File[] textFiles = fileDir.listFiles();long startTime = new Date().getTime();// 增加document到索引去for ( int i = 0 ; i < textFiles.length; i ++ ) {if (textFiles[i].isFile()&& textFiles[i].getName().endsWith( " .txt " )) {System.out.println( " File " + textFiles[i].getCanonicalPath()+ " 正在被索引. " );String temp = FileReaderAll(textFiles[i].getCanonicalPath()," GBK " );System.out.println(temp);Document document = new Document();Field FieldPath = new Field( " path " , textFiles[i].getPath(),Field.Store.YES, Field.Index.NO);Field FieldBody = new Field( " body " , temp, Field.Store.YES,Field.Index.TOKENIZED,Field.TermVector.WITH_POSITIONS_OFFSETS);document.add(FieldPath);document.add(FieldBody);indexWriter.addDocument(document);}}// optimize()方法是对索引进行优化indexWriter.optimize();indexWriter.close();// 测试一下索引的时间long endTime = new Date().getTime();System.out.println( " 这花费了"+ (endTime - startTime)+ " 毫秒来把文档增加到索引里面去! "+ fileDir.getPath());}public static String FileReaderAll(String FileName, String charset)throws IOException {BufferedReader reader = new BufferedReader( new InputStreamReader (new FileInputStream(FileName), charset));String line = new String();String temp = new String();while ((line = reader.readLine()) != null ) {temp += line;}reader.close();return temp;}}索引的结果：File C:\s\ 1 .txt正在被索引.中华人民共和国全国人民2006年File C:\s\ 2 .txt正在被索引.中华人民共和国全国人民2006年File C:\s\ 3 .txt正在被索引.中华人民共和国全国人民2006年这花费了297 毫秒来把文档增加到索引里面去! c:\s3、建立了索引之后，查询啦....package ;import java.io.IOException;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.standard.StandardAnalyzer;import org.apache.lucene.queryParser.ParseException;import org.apache.lucene.queryParser.QueryParser;import org.apache.lucene.search.Hits;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;public class TestQuery {public static void main(String[] args) throws IOException, ParseExce ption {Hits hits = null ;String queryString = " 中华" ;Query query = null ;IndexSearcher searcher = new IndexSearcher( " c:\\index " );Analyzer analyzer = new StandardAnalyzer();try {QueryParser qp = new QueryParser( " body " , analyzer);query = qp.parse(queryString);} catch (ParseException e) {}if (searcher != null ) {hits = searcher.search(query);if (hits.length() > 0 ) {System.out.println( " 找到: " + hits.length() + " 个结果! " );}}}}其运行结果：找到: 3 个结果!Lucene 其实很简单的,它最主要就是做两件事:建立索引和进行搜索来看一些在lucene中使用的术语,这里并不打算作详细的介绍,只是点一下而已----因为这一个世界有一种好东西，叫搜索。

合集下载

Lucene入门+实现

Lucene入门+实现

Lucene⼊门+实现Lucene简介详情见：（）lucene实现原理其实⽹上很多资料表明了，lucene底层实现原理就是倒排索引（invertedindex）。

那么究竟什么是倒排索引呢？经过Lucene分词之后，它会维护⼀个类似于“词条--⽂档ID”的对应关系，当我们进⾏搜索某个词条的时候，就会得到相应的⽂档ID。

不同于传统的顺排索引根据⼀个词，知道有哪⼏篇⽂章有这个词。

图解：Lucene在搜索前⾃⾏⽣成倒排索引，相⽐数据库中like的模糊搜索效率更⾼！Lucene 核⼼API索引过程中的核⼼类1. Document⽂档：他是承载数据的实体（他可以集合信息域Field），是⼀个抽象的概念，⼀条记录经过索引之后，就是以⼀个Document的形式存储在索引⽂件中的。

2. Field：Field 索引中的每⼀个Document对象都包含⼀个或者多个不同的域(Field),域是由域名(name)和域值(value)对组成，每⼀个域都包含⼀段相应的数据信息。

3. IndexWriter：索引过程的核⼼组件。

这个类⽤于创建⼀个新的索引并且把⽂档加到已有的索引中去，也就是写⼊操作。

4. Directroy：是索引的存放位置，是个抽象类。

具体的⼦类提供特定的存储索引的地址。

（FSDirectory 将索引存放在指定的磁盘中，RAMDirectory ·将索引存放在内存中。

）5. Analyzer：分词器，在⽂本被索引之前，需要经过分词器处理，他负责从将被索引的⽂档中提取词汇单元，并剔除剩下的⽆⽤信息（停⽌词汇），分词器⼗分关键，因为不同的分词器，解析相同的⽂档结果会有很⼤的不同。

Analyzer是⼀个抽象类，是所有分词器的基类。

搜索过程中的核⼼类1. IndexSearcher ：IndexSearcher 调⽤它的search⽅法，⽤于搜索IndexWriter 所创建的索引。

2. Term ：Term 使⽤于搜索的⼀个基本单元。

一步一步跟我学习lucene（1...

一步一步跟我学习lucene（1...

一步一步跟我学习lucene（1...自定义排序说明我们在做lucene搜索的时候，可能会需要排序功能，虽然lucene 内置了多种类型的排序，但是如果在需要先进行某些值的运算然后在排序的时候就有点显得无能为力了；要做自定义查询，我们就要研究lucene已经实现的排序功能，lucene的所有排序都是要继承FieldComparator,然后重写内部实现，这里以IntComparator为例子来查看其实现；IntComparator相关实现其类的声明为public static class IntComparator extends NumericComparator<Integer>,这里说明IntComparator接收的是Integer类型的参数，即只处理IntField的排序；IntComparator声明的参数为：[java] view plain copy1.private final int[] values;2.private int bottom; // Value of bottom of queue3.private int topValue;查看copy方法可知•values随着类初始化而初始化其长度•values用于存储NumericDocValues中读取到的内容具体实现如下：values的初始化[java] view plain copy1./**2.* Creates a new comparator based on {@link Integer#co mpare} for {@code numHits}.3.* When a document has no value for the field, {@code mi ssingValue} is substituted.4.*/5.public IntComparator(int numHits, String field, Integer mi ssingValue) {6.super(field, missingValue);7.values = new int[numHits];8.}values值填充(此为IntComparator的处理方式)[java] view plain copy1.@Override2.public void copy(int slot, int doc) {3.int v2 = (int) currentReaderValues.get(doc);4.// Test for v2 == 0 to save Bits.get method call for5.// the common case (doc has value and value is non-zero):6.if (docsWithField != null && v2 == 0 && !docsWithField. get(doc)) {7.v2 = missingValue;8.}9.10.values[slot] = v2;11.}这些实现都是类似的，我们的应用实现自定义排序的时候需要做的是对binaryDocValues或NumericDocValues的值进行计算，然后实现FieldComparator内部方法，对应IntComparator就是如上的值copy操作；然后我们需要实现compareTop、compareBottom和compare，IntComparator的实现为：[java] view plain copy1.@Override2.public int compare(int slot1, int slot2) {3.return pare(values[slot1], values[slot2]);4.}5.6.@Override7.public int compareBottom(int doc) {8.int v2 = (int) currentReaderValues.get(doc);9.// Test for v2 == 0 to save Bits.get method call for10.// the common case (doc has value and value is non-zero):11.if (docsWithField != null && v2 == 0 && !docsWithFi eld.get(doc)) {12.v2 = missingValue;13.}14.15.return pare(bottom, v2);16.}[java] view plain copy1.@Override2.public int compareTop(int doc) {3.int docValue = (int) currentReaderValues.get(doc);4.// Test for docValue == 0 to save Bits.get method call for5.// the common case (doc has value and value is non-zero):6.if (docsWithField != null && docValue == 0 && !docsWit hField.get(doc)) {7.docValue = missingValue;8.}9.return pare(topValue, docValue);10.}实现自己的FieldComparator要实现FieldComparator，需要对接收参数进行处理，定义处理值的集合，同时定义BinaryDocValues和接收的参数等，这里我写了一个通用的比较器，代码如下：[java] view plain copy1.package com.lucene.search;2.3.import java.io.IOException;4.5.import org.apache.lucene.index.BinaryDocValues;6.import org.apache.lucene.index.DocValues;7.import org.apache.lucene.index.LeafReaderContext;8.import org.apache.lucene.search.SimpleFieldComparator;9.10.import com.lucene.util.ObjectUtil;11.12./**自定义comparator13.* @author lenovo14.*15.*/16.public class SelfDefineComparator extends SimpleFie ldComparator<String> {17.private Object[] values;//定义的Object[]，同IntComparator18.private Object bottom;19.private Object top;20.private String field;21.private BinaryDocValues binaryDocValues;//接收的BinaryDocValues,同IntComparator中的NumericDocValues22.private ObjectUtil objectUtil;//这里为了便于拓展用接口代替抽象类23.private Object[] params;//接收的参数24.25.public SelfDefineComparator(String field, int numHits, Object[] params,ObjectUtil objectUtil) {26.values = new Object[numHits];27.this.objectUtil = objectUtil;28.this.field = field;29.this.params = params;30.}31.32.@Override33.public void setBottom(int slot) {34.this.bottom = values[slot];35.}36.37.@Override38.public int compareBottom(int doc) throws IOExcepti on {39.Object distance = getValues(doc);40.return (bottom.toString()).compareTo(distance.toStrin g());41.}42.43.@Override44.public int compareTop(int doc) throws IOException {45.Object distance = getValues(doc);46.return pareTo(top,distance);47.}48.49.@Override50.public void copy(int slot, int doc) throws IOException {51.values[slot] = getValues(doc);52.}53.54./**��ȡdocID��Ӧ��value55.* @param doc56.* @return57.*/58.private Object getValues(int doc) {59.Object instance = objectUtil.getValues(doc,params,bin aryDocValues) ;60.return instance;61.}62.63.@Override64.protected void doSetNextReader(LeafReaderContext context)65.throws IOException {66.binaryDocValues = DocValues.getBinary(context.reade r(), field);//context.reader().getBinaryDocValues(field);67.}68.69.@Override70.public int compare(int slot1, int slot2) {71.return pareTo(values[slot1],values[slot2]);72.}73.@Override74.public void setTopValue(String value) {75.this.top = value;76.}77.78.@Override79.public String value(int slot) {80.return values[slot].toString();81.}82.83.}其中ObjectUtil是一个接口，定义了值处理的过程，最终是要服务于comparator的compare方法的，同时对comparator的内部compare方法进行了定义ObjectUtil接口定义如下：[java] view plain copy1.package com.lucene.util;2.3.import org.apache.lucene.index.BinaryDocValues;4.5.public interface ObjectUtil {6.7./**自定义的获取处理值的方法8.* @param doc9.* @param params10.* @param binaryDocValues11.* @return12.*/13.public abstract Object getValues(int doc, Object[] par ams, BinaryDocValues binaryDocValues) ;14.15./**compare比较器实现16.* @param object17.* @param object218.* @return19.*/20.public abstract int compareTo(Object object, Object object2);21.22.}我们不仅要提供比较器和comparator，同时还要提供接收用户输入的FiledComparatorSource[java] view plain copy1.package com.lucene.search;2.3.import java.io.IOException;4.5.import org.apache.lucene.search.FieldComparator;6.import org.apache.lucene.search.FieldComparatorSource;7.8.import com.lucene.util.ObjectUtil;9.10./**comparator用于接收用户原始输入，继承自FieldComparatorSource实现了自定义comparator的构建11.* @author lenovo12.*13.*/14.public class SelfDefineComparatorSource extends Fie ldComparatorSource {15.private Object[] params;//接收的参数16.private ObjectUtil objectUtil;//这里为了便于拓展用接口代替抽象类17.18.public Object[] getParams() {19.return params;20.}21.22.public void setParams(Object[] params) {23.this.params = params;24.}25.26.public ObjectUtil getObjectUtil() {27.return objectUtil;28.}29.30.public void setObjectUtil(ObjectUtil objectUtil) {31.this.objectUtil = objectUtil;32.}33.34.public SelfDefineComparatorSource(Object[] params, ObjectUtil objectUtil) {35.super();36.this.params = params;37.this.objectUtil = objectUtil;38.}39.40.@Override41.public FieldComparator<?> newComparator(String fie ldname, int numHits,42.int sortPos, boolean reversed) throws IOException {43.//实际比较由SelfDefineComparator实现44.return new SelfDefineComparator(fieldname, numHit s, params, objectUtil);45.}46.}相关测试程序，这里我们模拟一个StringComparator，对String 值进行排序[java] view plain copy1.package com.lucene.search;2.3.import org.apache.lucene.analysis.Analyzer;4.import org.apache.lucene.analysis.standard.StandardAnal yzer;5.import org.apache.lucene.document.BinaryDocValuesFiel d;6.import org.apache.lucene.document.Document;7.import org.apache.lucene.document.Field;8.import org.apache.lucene.document.StringField;9.import org.apache.lucene.index.DirectoryReader;10.import org.apache.lucene.index.IndexReader;11.import org.apache.lucene.index.IndexWriter;12.import org.apache.lucene.index.IndexWriterConfig;13.import org.apache.lucene.index.IndexWriterConfig.Op enMode;14.import org.apache.lucene.index.Term;15.import org.apache.lucene.search.IndexSearcher;16.import org.apache.lucene.search.MatchAllDocsQuery;17.import org.apache.lucene.search.Query;18.import org.apache.lucene.search.ScoreDoc;19.import org.apache.lucene.search.Sort;20.import org.apache.lucene.search.SortField;21.import org.apache.lucene.search.TermQuery;22.import org.apache.lucene.search.TopDocs;23.import org.apache.lucene.search.TopFieldDocs;24.import org.apache.lucene.store.RAMDirectory;25.import org.apache.lucene.util.BytesRef;26.27.import com.lucene.util.CustomerUtil;28.import com.lucene.util.ObjectUtil;29.import com.lucene.util.StringComparaUtil;30.31./**32.*33.* @author 吴莹桂34.*35.*/36.public class SortTest {37.public static void main(String[] args) throws Exceptio n {38.RAMDirectory directory = new RAMDirectory();39.Analyzer analyzer = new StandardAnalyzer();40.IndexWriterConfig indexWriterConfig = new IndexWri terConfig(analyzer);41.indexWriterConfig.setOpenMode(OpenMode.CREATE_ OR_APPEND);42.IndexWriter indexWriter = new IndexWriter(directory,indexWriterConfig);43.addDocument(indexWriter, "B");44.addDocument(indexWriter, "D");45.addDocument(indexWriter, "A");46.addDocument(indexWriter, "E");mit();48.indexWriter.close();49.IndexReader reader = DirectoryReader.open(directory) ;50.IndexSearcher searcher = new IndexSearcher(reader);51.Query query = new MatchAllDocsQuery();52.ObjectUtil util = new StringComparaUtil();53.Sort sort = new Sort(new SortField("name",new SelfD efineComparatorSource(new Object[]{},util),true));54.TopDocs topDocs = searcher.search(query, Integer.MA X_VALUE, sort);55.ScoreDoc[] docs = topDocs.scoreDocs;56.for(ScoreDoc doc : docs){57.Document document = searcher.doc(doc.doc);58.System.out.println(document.get("name"));59.}60.}61.62.private static void addDocument(IndexWriter writer,S tring name) throws Exception{63.Document document = new Document();64.document.add(new StringField("name",name,Field.Sto re.YES));65.document.add(new BinaryDocValuesField("name", new BytesRef(name.getBytes())));66.writer.addDocument(document);67.}68.}其对应的ObjectUtil实现如下：[java] view plain copy1.package com.lucene.util;2.3.import org.apache.lucene.index.BinaryDocValues;4.import org.apache.lucene.util.BytesRef;5.6.public class StringComparaUtil implements ObjectUtil {7.8.@Override9.public Object getValues(int doc, Object[] params,10.BinaryDocValues binaryDocValues) {11.BytesRef bytesRef = binaryDocValues.get(doc);12.String value = bytesRef.utf8T oString();13.return value;14.}15.16.@Override17.public int compareTo(Object object, Object object2) {18.// TODO Auto-generated method stub19.return object.toString().compareTo(object2.toString());20.}21.22.}。

lucene基础学习

lucene基础学习

搜索引擎Lucene第一章Lucene简介Lucene是apache软件基金会jakarta项目组的一个子项目，是一个开放源代码[的全文检索引擎工具包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。

Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。

第二章lucene索引的建立的五个基础类索引的建立，Lucene 提供了五个基础类，分别是Document, Field, IndexWriter, Analyzer, Directory。

以下是他们的用途：DocumentDocument的含义为文档，在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在一个文档被索引之前，首先需要对文档内容进行分词处理，这部分工作就是由Analyzer 来做的。

lucene简单使用一之文件索引

lucene简单使用一之文件索引

到此索引生成的核心都贴完了，大家领会下，下面在来看看索引的使用
Directory dir = new SimpleFSDirectory(new File(path)); List<Map<String, String>> indLs = searchTemplateList(dir,root, siteId, dirFileName); Searcher searcher = new IndexSearcher(dir); try { //分词器，与索引的分词器一致 Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30); //查询器 Query query = LuceneTemplate.createQuery(null, null, null, siteId, root, dirFileName, dirFileName, dirFileName, analyzer); //TODO要做翻页,收索索引 TopDocs docs = searcher.search(query, 5000); List<Map<String, String>> indLs = LuceneTemplate.getResultList(searcher, docs,0, 5000); return indLs; } finally { searcher.close(); } public static Query createQuery(String queryString, String category,String workplace, Integer siteId, String root,String filePath,String fileName,String fileContent, Analyzer analyzer) throws ParseException{ BooleanQuery bq = new BooleanQuery(); Query q; //注意我的查询器使用的是WildcardQuery，这个做like查询，配合通配符* if(StringUtils.isNotBlank(fileName)) { q = new WildcardQuery(new Term(FILENAME, "*"+fileName+"*")); bq.add(q, BooleanClause.Occur.SHOULD); } if(StringUtils.isNotBlank(filePath)) { q = new WildcardQuery(new Term(FILEPATH, "*"+filePath+"*")); bq.add(q, BooleanClause.Occur.SHOULD); }