Lucene的简单使用

绝地灬酷狼 2022-06-05 11:12 115阅读 0赞

# 1、什么是“全文检索”（Full-Text Search） #

## ①全文检索的概念 ##

全文检索首先将要查询的目标文档中的词提取出来，组成索引，通过查询索引达到搜索目标文档的目的。这种先建立索引，再对索引进行搜索的过程就叫全文检索（Full-text Search）。

全文检索（Full-Text Retrieval）是指以文本作为检索对象，找出含有指定词汇的文本。

全面、准确和快速是衡量全文检索系统的关键指标。  
关于全文检索，我们要知道：

1.  只处理文本。
2.  不处理语义。
3.  搜索时英文不区分大小写。
4.  结果列表有相关度排序。

在信息检索工具中，全文检索是最具通用性和实用性的。

## ②全文检索的应用场景 ##

我们使用Lucene，主要是做站内搜索，即对一个系统内的资源进行搜索。如BBS、BLOG中的文章搜索，网上商店中的商品搜索等。使用Lucene的项目有Eclipse、Jira等。一般不做互联网中资源的搜索，因为不易获取与管理海量资源（专业搜索方向的公司除外）。

## ③全文检索与数据库搜索的不同 ##

全文检索不同于[数据库][Link 1]的SQL查询。（他们所解决的问题不一样，解决的方案也不一样，所以不应进行对比）。在数据库中的搜索就是使用SQL，如：SELECT \* FROM t WHERE content like ‘%ant%’。这样会有如下问题：

1.  匹配效果：如搜索ant会搜索出planting这类结果。这样就会搜出很多无关的信息。
2.  相关度排序：查出的结果没有相关度排序，不知道我想要的结果在哪一页。我们在使用百度搜索时，一般不需要翻页，为什么？因为百度做了相关度排序：为每一条结果打一个分数，这条结果越符合搜索条件，得分就越高，叫做相关度得分，结果列表会按照这个分数由高到低排列，所以第1页的结果就是我们最想要的结果。
3.  速度及效率：全文检索的速度大大快于SQL的like搜索的速度。这是因为查询方式不同造成的，以查字典举例：数据库的like就是一页一页的翻，一行一行的找，而全文检索是先查目录，得到结果所在的页码，再直接翻到这一页。

# 2、什么是Lucene #

Lucene是Apache下的一个开源的全文检索引擎工具包。它为软件开发人员提供一个简单易用的工具包（类库），以方便的在目标系统中实现全文检索的功能。

顺便一提，Doug Cutting是Lucene和大名鼎鼎的[Hadoop][]的创始人。

# 3、Lucene下载及安装 #

官方网站：[Welcome to Apache Lucene][]

下载地址：[Index of /dist/lucene/java][Index of _dist_lucene_java]

JDK要求：1.7及以上（从版本4.8开始，不支持1.7以下）

入门程序只需要添加以下jar包：

*  mysql5.1驱动包：mysql-connector-java-5.1.7-bin.jar
 *  核心包：lucene-core-4.10.3.jar
 *  分析器通用包：lucene-analyzers-common-4.10.3.jar
 *  查询解析器包：lucene-queryparser-4.10.3.jar
 *  junit包：junit-4.9.jar

# 4、Lucene实现全文检索流程 #

![Center][]

全文检索的流程分为两大部分：索引流程、搜索流程。

*  索引流程：即采集数据构建文档对象分析文档（分词）创建索引。
 *  搜索流程：即用户通过搜索界面创建查询执行搜索，搜索器从索引库搜索渲染搜索结果。

# 5、Lucene索引源 #

全文检索要搜索的数据信息格式多种多样，拿搜索引擎（百度， google）来说，通过搜索引擎网站能搜索互联网站上的网页(html)、互联网上的音乐(mp3..)、视频(avi..)、pdf电子书等。

全文检索搜索的这些数据称为非结构化数据。

什么是非结构化数据？

*  结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。
 *  非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等。

如何对结构化数据搜索？

由于结构化数据是固定格式，所以就可以针对固定格式的数据设计[算法][Link 2]来搜索，比如数据库like查询，like查询采用顺序扫描法，使用关键字匹配内容，对于内容量大的like查询速度慢。

## ①网页采集数据 ##

因为目前搜索引擎主要搜索数据的来源是互联网，搜索引擎使用一种爬虫程序抓取网页（ 通过http抓取html网页信息），以下是一些爬虫项目：

1.  Solr（[Apache Solr -][]） ，Solr是Apache的一个子项目，支持从关系数据库、xml文档中提取原始数据。
2.  Nutch（[http://lucene.apache.org/nutch][http_lucene.apache.org_nutch]）, Nutch是Apache的一个子项目，包括大规模爬虫工具，能够抓取和分辨web网站数据。
3.  Jsoup（[http://jsoup.org/][http_jsoup.org] ），Jsoup是一款[Java][] 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于[jQuery][]的操作方法来取出和操作数据。
4.  Heritrix（[Heritrix: Internet Archive Web Crawler][Heritrix_ Internet Archive Web Crawler]），Heritrix 是一个由Java开发的、开源的网络爬虫，用户可以使用它来从网上抓取想要的资源。其最出色之处在于它良好的可扩展性，方便用户实现自己的抓取逻辑。

## ②数据库 ##

针对大多数站内搜索功能，全文检索的数据源在数据库中，需要通过JDBC访问数据库中表的内容。

例如（取自互联网）：

![Center 1][]

# 6、Lucene索引文件结构 #

![Center 2][]

*  文档域：
    
    非结构化的数据统一格式为document文档格式，一个文档有多个field域，不同的文档其field的个数可以不同，建议相同类型的文档包括相同的field。  
    本例子一个document对应一条book表的记录。
 *  索引域：
    
    将Document中的Field的内容进行分词，将分好的词创建索引，索引=Field域名:词。  
    索引域用于搜索，搜索程序将从索引域中搜索一个一个词，根据词找到对应的文档（Document）。
 *  倒排索引表：
    
    传统方法是先找到文件，如何在文件中找内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大就搜索慢。  
    倒排索引结构是根据内容（词语）找文档，倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它是在索引中匹配搜索关键字，由于索引内容量有限并且采用固定优化算法搜索速度很快，找到了索引中的词汇，词汇与文档关联，从而最终找到了文档。

# 7、Lucene创建索引过程 #

![Center 3][]

*  IndexWriter是索引过程的核心组件，通过IndexWriter可以创建新索引、更新索引、删除索引操作。IndexWriter需要通过Directory对索引进行存储操作。
 *  Directory描述了索引的存储位置，底层封装了I/O操作，负责对索引进行存储。它是一个抽象类，它的子类常用的包括FSDirectory（在文件系统存储索引）、RAMDirectory（在内存存储索引）。

# 8、创建文档（Document） #

在Lucene中，采集数据（从网站爬取或连接数据库）就是为了创建索引，创建索引需要先将采集的原始数据加工为文档，再由文档分词产生索引。文档（Document）中包含若干个Field域。

## ①采集数据 ##

代码实现:

//创建文档列表,保存多个Docuemnt
        	List<Document> docList = new ArrayList<Document>();
        	
        	//指定文件所在目录
        	File dir = new File("D:\\searchsource");
        	//循环文件夹取出文件
        	for(File file : dir.listFiles()){
        		//文件名称
        		String fileName = file.getName();
    			//文件内容
    			String fileContext = FileUtils.readFileToString(file);
    			//文件大小
    			Long fileSize = FileUtils.sizeOf(file);
    			
    			//文档对象,文件系统中的一个文件就是一个Docuemnt对象
    			Document doc = new Document();
    			
    			//第一个参数:域名
    			//第二个参数:域值
    			//第三个参数:是否存储,是为yes,不存储为no
    			TextField nameFiled = new TextField("fileName", fileName, Store.YES);
    			TextField contextFiled = new TextField("fileContext", fileContext, Store.YES);
    			TextField sizeFiled = new TextField("fileSize", fileSize.toString(), Store.YES);
    			
    			//将所有的域都存入文档中
    			doc.add(nameFiled);
    			doc.add(contextFiled);
    			doc.add(sizeFiled);
    			
    			//将文档存入文档集合中
    			docList.add(doc);
        	}

## ②使用文档分词 ##

在对Docuemnt中的内容索引之前需要使用分词器进行分词 ，分词的主要过程就是分词、过滤两步。

*  分词就是将采集到的文档内容切分成一个一个的词，具体应该说是将Document中Field的value值切分成一个一个的词。
 *  过滤包括去除标点符号、去除停用词（的、是、a、an、the等）、大写转小写、词的形还原（复数形式转成单数形参、过去式转成现在式等）。

什么是停用词？

停用词是为节省存储空间和提高搜索效率，搜索引擎在索引页面或处理搜索请求时会自动忽略某些字或词，这些字或词即被称为Stop Words（停用词）。比如语气助词、副词、介词、连接词等，通常自身并无明确的意义，只有将其放入一个完整的句子中才有一定作用，如常见的“的”、“在”、“是”、“啊”等。

Lucene中自带了StandardAnalyzer，它可以对英文进行分词。

StandardAnalyzer结构：

*  Tokenizer就是分词器，对输入的语句进行分词。
 *  TokenFilter是分词过滤器，比如过滤大小写转换、去除停用词等。

举例说明：

分词前：

Java is a world-wide programming language

分词后：

Java, is, a, world-wide, programming, language

*  Term是分词、过滤后的词，存在Field域中。对于某个Field域中，Term是具有象征性的，所以注意，在同一个Field域中，Term不能相同，Token可以相同。Term对于Token是一对一或一对多的关系。
 *  Token是语汇单元，是经过分词、过滤后的。在同一个Field域中，多个相同的语汇单元

总之，不同的域中拆分出来的相同的单词对应不同的Term；相同的域中拆分出来的相同的单词对应相同的Term。

例如：

包含图书名字的Field域中的Java值与包含图书内容描述的Field域的Java值对应的是不同的Term。

## ③分词+创建索引 ##

代码实现:

/*
        	 * 创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
        	 */
        	Analyzer analyzer = new StandardAnalyzer();
    		//指定索引和文档存储的目录
    		Directory directory = FSDirectory.open(new File("D:\\dic"));
    		//创建写对象的初始化对象
    		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
    		//创建索引和文档写对象
    		IndexWriter indexWriter = new IndexWriter(directory, config);
    		
    		//将文档加入到索引和文档的写对象中
    		for(Document doc : docList){
    			indexWriter.addDocument(doc);
    		}
    		//提交
    		indexWriter.commit();
    		//关闭流
    		indexWriter.close();

在D:\\dic生成索引截图:

![Center 4][]

使用Luke工具查看索引:

![Center 5][]

# 9、搜索功能的实现 #

实现代码:

@Test
    	public void testIndexSearch() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
    		//创建查询对象,第一个参数:默认搜索域;第二个参数:分词器
    		//默认搜索域的作用:如果搜索语法中指定域名,则从指定域名中搜索,如果搜索时只写了查询关键字,则从默认搜索域中进行搜索
    		QueryParser queryParser = new QueryParser("fileContext", analyzer);
    		//查询语法=域名:搜索的关键字
    		Query query = queryParser.parse("fileName:web");
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}

搜索结果截图:

![Center 6][]

# 10、索引的维护(删除 or 修改) #

/*
    	 * 删除索引
    	 */
    	@Test
    	public void testIndexDel() throws Exception {
    		// 创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
    		Analyzer analyzer = new IKAnalyzer();
    		// 指定索引和文档存储的目录
    		Directory directory = FSDirectory.open(new File("E:\\dic"));
    		// 创建写对象的初始化对象
    		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
    		// 创建索引和文档写对象
    		IndexWriter indexWriter = new IndexWriter(directory, config);
    
    		// 删除所有索引
    		// indexWriter.deleteAll();
    
    		// 根据名称进行删除
    		// Term词元,就是一个词, 第一个参数:域名, 第二个参数:要删除含有此关键词的数据
    		indexWriter.deleteDocuments(new Term("fileName", "apache"));
    
    		// 提交
    		indexWriter.commit();
    		// 关闭
    		indexWriter.close();
    	}

/*
    	 * 更新就是按照传入的Term进行搜索,如果找到结果那么删除,将更新的内容重新生成一个Document对象
    	 * 如果没有搜索到结果,那么将更新的内容直接添加一个新的Document对象
    	 */
    	@Test
    	public void testIndexUpdate() throws Exception {
    		// 创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
    		Analyzer analyzer = new IKAnalyzer();
    		// 指定索引和文档存储的目录
    		Directory directory = FSDirectory.open(new File("E:\\dic"));
    		// 创建写对象的初始化对象
    		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
    		// 创建索引和文档写对象
    		IndexWriter indexWriter = new IndexWriter(directory, config);
    
    		// 根据文件名称进行更新
    		Term term = new Term("fileName", "web");
    		// 更新的对象
    		Document doc = new Document();
    		doc.add(new TextField("fileName", "xxxxxx", Store.YES));
    		doc.add(new TextField("fileContext", "think in java xxxxxxx", Store.NO));
    		doc.add(new LongField("fileSize", 100L, Store.YES));
    
    		// 更新
    		indexWriter.updateDocument(term, doc);
    
    		// 提交
    		indexWriter.commit();
    		// 关闭
    		indexWriter.close();
    	}

# 11、多种搜索方式 #

package com.lucene;
    
    import java.io.File;
    
    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.document.Document;
    import org.apache.lucene.index.IndexReader;
    import org.apache.lucene.index.Term;
    import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
    import org.apache.lucene.queryparser.classic.QueryParser;
    import org.apache.lucene.search.BooleanQuery;
    import org.apache.lucene.search.IndexSearcher;
    import org.apache.lucene.search.MatchAllDocsQuery;
    import org.apache.lucene.search.NumericRangeQuery;
    import org.apache.lucene.search.Query;
    import org.apache.lucene.search.ScoreDoc;
    import org.apache.lucene.search.TermQuery;
    import org.apache.lucene.search.TopDocs;
    import org.apache.lucene.search.BooleanClause.Occur;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    import org.junit.Test;
    import org.wltea.analyzer.lucene.IKAnalyzer;
    
    public class IndexSearch {
    	/*
    	 * 根据域名进行搜索,可以设置默认搜索域(推荐使用),只能在文本中进行搜索
    	 */
    	@Test
    	public void testIndexSearch() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
    		//创建查询对象,第一个参数:默认搜索域;第二个参数:分词器
    		//默认搜索域的作用:如果搜索语法中指定域名,则从指定域名中搜索,如果搜索时只写了查询关键字,则从默认搜索域中进行搜索
    		QueryParser queryParser = new QueryParser("fileContext", analyzer);
    		//查询语法=域名:搜索的关键字
    		Query query = queryParser.parse("fileName:web");
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    	
    	/*
    	 * 词源搜索:根据词进行搜索(只能从文本中进行搜索)
    	 */
    	@Test
    	public void testIndexTermQuery() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
            
    		//创建词源,就是词
    		Term term = new Term("fileName", "apache");
    		//使用TermQuery查询,根据term对象进行查询
    		TermQuery termQuery = new TermQuery(term);
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(termQuery, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    	
    	/*
    	 * 根据数值范围查询
    	 */
    	@Test
    	public void testNumericRangeQuery() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
            
            //根据数字范围查询
    		//查询文件大小,大于100小于1000的文章
    		//第一个参数:域名   第二个参数:最小值   第三个参数:最大值    第四个参数:是否包含最小值    第五个参数:是否包含最大值
    		Query query = NumericRangeQuery.newLongRange("fileSize", 100L, 1000L, true, true);		
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    	
    	/*
    	 * 布尔查询,多个条件组合查询
    	 */
    	@Test
    	public void testBooleanQuery() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
            
    		//布尔查询,就是可以根据多个条件进行查询
    		BooleanQuery query = new BooleanQuery();
    		
            //根据数字范围查询
    		//查询文件大小,大于100小于1000的文章
    		//第一个参数:域名   第二个参数:最小值   第三个参数:最大值    第四个参数:是否包含最小值    第五个参数:是否包含最大值
    		Query numericQuery = NumericRangeQuery.newLongRange("fileSize", 10L, 1000L, true, true);	
    		
    		//创建词源,就是词
    		Term term = new Term("fileName", "apache");
    		//使用TermQuery查询,根据term对象进行查询
    		TermQuery termQuery = new TermQuery(term);
    		
    		//Occur是逻辑条件
    		//must相当于and关键字,是并且的意思
    		//should相当于or关键字,是或者的意思
    		//must_no相当于not关键字,是非的意思
    		//注意:单独使用must_not 或者独自使用must_not没有任何意思
    		query.add(termQuery, Occur.MUST);
    		query.add(numericQuery, Occur.MUST);
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    	
    	/*
    	 * 查询所有文档
    	 */
    	@Test
    	public void testMathAllQuery() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
            
    		//查询所有文档
    		MatchAllDocsQuery query = new MatchAllDocsQuery();
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    	
    	/*
    	 * 从多个域中进行查询,只要这些域中存在关键词的就搜索出来 
    	 */
    	@Test
    	public void testMultiFieldQueryParser() throws Exception{
    		//创建索引所用的分词器必须一致
    		Analyzer analyzer = new IKAnalyzer();
            
    		String [] fields = {"fileName","fileContext"};
    		//从文件名称和文件内容中查询,只要含有apache的就查询出来
    		MultiFieldQueryParser multiQuery = new MultiFieldQueryParser(fields, analyzer);
    		//输入需要搜索的关键字
    		Query query = multiQuery.parse("apache");
    		
    		//指定索引和文档的目录
    		Directory dir = FSDirectory.open(new File("D:\\dic"));
    		//索引和文档的读取对象
    		IndexReader indexReader = IndexReader.open(dir);
    		//创建索引的搜索对象
    		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    		//搜索:第一个参数为:查询语句对象,第二个参数为:指定显示多少条
    		TopDocs topdocs = indexSearcher.search(query, 5);
    		//一共搜索到多少条记录
    		System.out.println("=====count=====" + topdocs.totalHits);
    		//从搜索对象中获取结果集
    		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
    		
    		for(ScoreDoc scoreDoc : scoreDocs){
    			//获取docID
    			int docID = scoreDoc.doc;
    			//通过文档ID,从磁盘中读取出对应的文档
    			Document document = indexReader.document(docID);
    			//从get域名中可以取出值打印
    			System.out.println("fileName:" + document.get("fileName"));
    			System.out.println("fileSize:" + document.get("fileSize"));
    			System.out.println("============================================================");
    		}
    	}
    }

本文章相关源码下载:点击----->[下载源码][Link 3]

[Link 1]: http://link.zhihu.com/?target=http%3A//lib.csdn.net/base/mysql
[Hadoop]: http://link.zhihu.com/?target=http%3A//lib.csdn.net/base/hadoop
[Welcome to Apache Lucene]: http://link.zhihu.com/?target=http%3A//lucene.apache.org/
[Index of _dist_lucene_java]: http://link.zhihu.com/?target=http%3A//archive.apache.org/dist/lucene/java/
[Center]: /images/20220605/cc0f2cdee1804778b9ebc515660b99e6.png
[Link 2]: http://link.zhihu.com/?target=http%3A//lib.csdn.net/base/datastructure
[Apache Solr -]: http://link.zhihu.com/?target=http%3A//lucene.apache.org/solr
[http_lucene.apache.org_nutch]: http://link.zhihu.com/?target=http%3A//lucene.apache.org/nutch
[http_jsoup.org]: http://link.zhihu.com/?target=http%3A//jsoup.org/
[Java]: http://link.zhihu.com/?target=http%3A//lib.csdn.net/base/javase
[jQuery]: http://link.zhihu.com/?target=http%3A//lib.csdn.net/base/jquery
[Heritrix_ Internet Archive Web Crawler]: http://link.zhihu.com/?target=http%3A//sourceforge.net/projects/archive-crawler/files/
[Center 1]: /images/20220605/8699d90091914d78bd8b8bdbb35ea438.png
[Center 2]: /images/20220605/486fb684749d4993bd97897a9a473b0e.png
[Center 3]: /images/20220605/80d5310786a04c77b7b83002dbf197b5.png
[Center 4]: /images/20220605/c4cff55e36774e5e97d107d790a7509c.png
[Center 5]: /images/20220605/b35998891f504dc795de60c1abf0c9cd.png
[Center 6]: /images/20220605/62a9583c02c74cf2a2fb9398dc169e4b.png
[Link 3]: http://download.csdn.net/download/linhaiyun_ytdx/10132924