Lucene——IndexReader单例化

最新推荐文章于 2018-02-06 20:52:26 发布
最新推荐文章于 2018-02-06 20:52:26 发布
阅读量1.3k 收藏
点赞数
分类专栏： Lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingtian_xiaozhi/article/details/8454068
版权

IndexReader单例化来提高效率

如果Reader为空，初始化

如果Reader发生改变，关闭原来的reader，用openIfChange()重新赋值，

若不为空并且未发生改变，直接发返回Searcer

IndexReader.deleteDocuments()也可可以删除Document，reader.close()关闭的 时候自动提交

 

package org.itat.index;

//创建索引
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;

public class IndexUtil {
	private String[] ids = { "1", "2", "3", "4", "5", "6" };
	private String[] emails = { "dd@@dd.org", "aa@jingtian.org",
			"bb@jingtian.org", "cc@ytu.edu", "ee@ee.org", "ff@ff.org" };
	private String[] contents = { "I like soccer", "I like football",
			"I like soccer and I like game", "I like book", "I like soccer",
			"I like soccer" };
	private int[] attachs = { 3, 6, 8, 9, 5, 4, 5 };
	private String[] names = { "zhangsan", "lisi", "wangwu", "zhaoliu", "wuba",
			"chenjiu" };
	private Directory directory = null;
	private Map<String, Float> scores = new HashMap<String, Float>();
	private Date[] dates = null;

	private static IndexReader reader = null;

	public IndexUtil() {

		try {
			scores.put("jingtian.org", 8f);
			scores.put("ytu.edu", 6f);

			setDate();

			directory = FSDirectory.open(new File("e:/lucene/index02"));
			
			reader = IndexReader.open(directory,false);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public IndexSearcher getSearcher() {
		try {
			if (reader == null) {
				reader = IndexReader.open(directory);
				System.out.println("1");
			} else {
				IndexReader tr = IndexReader.openIfChanged(reader);
				if (tr != null)
					{
					reader.close();
					reader = tr;
					}
				System.out.println("2");
			}
			System.out.println("3");
			return new IndexSearcher(reader);
		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		System.out.println("到这里了");
		return null;

	}

	public void setDate() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD"); // 时间转换，这个不会有点丢人
		try {
			dates = new Date[ids.length];
			dates[0] = sdf.parse("2010-08-17");
			dates[1] = sdf.parse("2011-02-17");
			dates[2] = sdf.parse("2012-03-17");
			dates[3] = sdf.parse("2011-04-17");
			dates[4] = sdf.parse("2012-05-17");
			dates[5] = sdf.parse("2011-07-17");
		} catch (Exception e) {
			e.printStackTrace();
			// TODO: handle exception
		}
	}

	public void query() {
		try {
			IndexReader reader = IndexReader.open(directory);
			System.out.println("numdocs:" + reader.numDocs());
			System.out.println("maxDocs:" + reader.maxDoc());
			System.out.println("detelemaxDocs:" + reader.numDeletedDocs());
			reader.close();

		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	public void index() {

		IndexWriter writer = null;
		Document doc = null;
		try {
			// writer.deleteAll();
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
			for (int i = 0; i < ids.length; i++) {
				doc = new Document();
				doc.add(new Field("id", ids[i], Field.Store.YES,
						Field.Index.NOT_ANALYZED_NO_NORMS));
				doc.add(new Field("email", emails[i], Field.Store.YES,
						Field.Index.ANALYZED));
				doc.add(new Field("content", contents[i], Field.Store.NO,
						Field.Index.ANALYZED));
				doc.add(new Field("name", names[i], Field.Store.YES,
						Field.Index.NOT_ANALYZED_NO_NORMS));

				// 存储数字
				doc.add(new NumericField("attach", Field.Store.YES, true)
						.setIntValue(attachs[i]));
				// 存储日期
				doc.add(new NumericField("date", Field.Store.YES, true)
						.setLongValue(dates[i].getTime()));

				String et = emails[i].substring(emails[i].lastIndexOf("@") + 1);
				System.out.println(et);
				if (scores.containsKey(et)) {
					doc.setBoost(scores.get(et));
				} else {
					doc.setBoost(5f);
				}

				writer.addDocument(doc);
			}
		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (CorruptIndexException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	// 删除
	public void delete() {
		IndexWriter writer = null;
		try {
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
			// 参数是一个选项.可以是一个query，也可以是一个term term就是一个精确查找的值
			// 此时删除的文档并未完全删除，而是存储在回收站中，可以恢复的
			writer.deleteDocuments(new Term("id", "1"));
		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (CorruptIndexException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	// 恢复
	public void undelete() {
		try {
			// 恢复时必须把reader的只读设为false
			IndexReader reader = IndexReader.open(directory, false);
			reader.undeleteAll();

			reader.close();
		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	// 清空回收站，强制优化
	public void forceDelete() {
		IndexWriter writer = null;
		try {
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
			writer.forceMergeDeletes();
		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (CorruptIndexException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	// 删除，利用Reader执行删除
	public void delete02() {
			try {
				reader.deleteDocuments(new Term("id", "1"));
				reader.close();
			} catch (StaleReaderException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (CorruptIndexException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (LockObtainFailedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		
	}

	// 更新索引
	public void update() {
		// lucene本身不支持更新
		// 通过删除索引然后再建立索引来更新

		IndexWriter writer = null;
		Document doc = null;
		try {
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));

			doc = new Document();
			doc.add(new Field("id", "111", Field.Store.YES,
					Field.Index.NOT_ANALYZED_NO_NORMS));
			doc.add(new Field("emails", emails[0], Field.Store.YES,
					Field.Index.ANALYZED));
			doc.add(new Field("contents", contents[0], Field.Store.NO,
					Field.Index.ANALYZED));
			doc.add(new Field("name", names[0], Field.Store.YES,
					Field.Index.NOT_ANALYZED_NO_NORMS));
			writer.updateDocument(new Term("id", "1"), doc);

		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (CorruptIndexException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	public void search() {
		try {
			IndexReader reader = IndexReader.open(directory);
			IndexSearcher searcher = new IndexSearcher(reader);
			TermQuery query = new TermQuery(new Term("content", "like"));
			TopDocs tds = searcher.search(query, 10);

			for (ScoreDoc sd : tds.scoreDocs) {
				Document doc = searcher.doc(sd.doc);
				SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-DD");
				System.out.println("(" + sd.doc + "-" + doc.getBoost() + "-"
						+ sd.score + ")--------------" + doc.get("name") + "["
						+ doc.get("email") + "]--------------------"
						+ doc.get("id") + "," + doc.get("attach") + ","
						+ doc.get("date"));
			}
			reader.close();
		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch blocket
			e.printStackTrace();
		}

	}

	//单例化之后逇Reader
	public void search02() {
		try {
			IndexSearcher searcher = getSearcher();
			TermQuery query = new TermQuery(new Term("content", "like"));
			TopDocs tds = searcher.search(query, 10);

			for (ScoreDoc sd : tds.scoreDocs) {
				Document doc = searcher.doc(sd.doc);
				System.out.println("(" + sd.doc + "-" + doc.getBoost() + "-"
						+ sd.score + ")--------------" + doc.get("name") + "["
						+ doc.get("email") + "]--------------------"
						+ doc.get("id") + "," + doc.get("attach") + ","
						+ doc.get("date"));

			}
			searcher.close();
		} catch (CorruptIndexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch blocket
			e.printStackTrace();
		}
	}
}


 


 

景天晓志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lucene7 demo 例子
12-05
使用maven，Lucene7.1.0，JDK8，SmartChineseAnalyzer中文分词器。使用方法：1. LuceneApp.java运行main方法。 2.Constants.java修改index_path路径为你自己的路径。3.浏览器中输入：http://localhost:8000/
lucene7.7.2稳定版本
04-10
lucene7.7.2稳定版本
Lucene查询方式总结
Jonney's house
04-04 1491
-------------------------------------------------- IndexReader的设计 -------------------------------------------------- IndexReader的创建需要消耗大量内存空间, 所以通过将IndexReader设计出属性值，进行一次创建 整个项目周期就只有一个IndexRead
Lucene5 学习笔记（3） —— 重用 IndexReader 和常用的搜索方法
李威威的博客
03-01 4991
02_lucene简介和搜索初步.avi
Lucene的多线程访问原则和同步,锁机制
yiihsia的学习阵地
03-24 2002
 本文介绍lucene多线程环境下的使用原则和commit.lock与write.lock实现的锁机制。设计之初就是服务于多线程环境，大多数情况下索引会被不至一个线程访问。索引时一个关键资源。在对这样的资源进行访问时，不可避免地会出现同步访问的问题。因此需要有很好的策略来处理这些并发访问，以保证资源的合理使用。对索引的非法访问可能导致索引数据异常，进而毁坏重要的数据，导致整个系统的失败。
Lucene 入门和简单封装
wwhhff11
03-06 909
管理package com.whf.demo;import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; import java.util.concurren
Lucene.net(4.8.0) 学习问题记录四: IndexWriter 索引的优化以及思考
weixin_30517001的博客
01-29 271
前言：目前自己在做使用Lucene.net和PanGu分词实现全文检索的工作，不过自己是把别人做好的项目进行迁移。因为项目整体要迁移到ASP.NET Core 2.0版本,而Lucene使用的版本是3.6.0 ，PanGu分词也是对应Lucene3.6.0版本的。不过好在Lucene.net 已经有了Core 2.0版本（4.8.0 bate版），而PanGu分词，目前有人正在做，貌似已经做完，只...
19) 第二章 索引：用IndexReader删除文档
为中华之崛起而编码
04-19 152
  除了IndexWriter外，IndexReader也可以用来删除文档。那么两者之间有什么区别呢?     A. IndexReader可以按文档id删除一个文档。     IndexReader用来删除文档的核心方法为： public synchronized void deleteDocument(int docNum) throws StaleReaderException, ...
lucene可视化工具 Luck-6.5.0
11-26
而 Luck 是 Lucene 的一个可视化工具，版本为 6.5.0，它为 Lucene 的索引提供了直观的界面，帮助用户更好地理解和调试 Lucene 索引。 Luck 可视化工具的主要特性包括： 1. **索引浏览器**：Luck 允许用户浏览 ...
Lucene初试——关于大文本建立索引和中文乱码以及QueryParser检索的一些体会 - sheen口开河 - CSDN博客
08-03
【Lucene大文本建索引】 在使用Lucene处理大文本时，遇到的主要问题是内存溢出。当尝试一次性处理200M左右的文本时，可能会遇到`java.lang.OutOfMemoryError: Java heap space`错误。这主要是由于Lucene在内存中缓冲...
自己写的使用lucene6.4.0对非结构化数据进行检索的例子
04-24
本例使用了lucene6.4.0与lire，可对各文档(word\excel\pdf\txt)中关键字进行检索，并调用tess4j通过图片内容识别，对图片中文字进行检索。ImageCreatIndex、ImageSearch分别建立图片索引与检索功能，为以图搜图实例 ...
lucene:lucene技术细节
05-01
Field可以设置不同的存储和索引属性，如是否存储原始值、是否参与全文搜索、是否进行词干化处理等。Field的定义决定了数据如何被分析、存储和检索。 6. **Lucene的分词过程** Lucene的分词过程是由Analyzer负责的...
luke5.5版本可视化工具
05-10
Luke是一款专为Apache Lucene索引提供可视化界面的工具，它的全名是Lucidworks Luke。这款工具能够帮助开发者和分析师深入洞察Lucene索引的内部结构，进行索引浏览、文档查看以及查询操作。在描述中提到的是Luke的...
结合ehcache缓存对lucene使用单例模式搜索
一个今天胜过两个明天
03-23 153
我采用和ehcache缓存结合使用单例模式 ,其实就是给indexsearcher加了个缓存 使用ehcache在内存中设置一个缓存，时间为10分钟。 当IndexSearcher对象不存在时，创建静态对象同时在缓存中写入一个值，表示对象已经存在了. 搜索时如果缓存过期，则重新创建IndexSearcher [code="java"] public class MySearche...
构造单例的IndexWriter对象
wwty
07-02 332
问题由来： 参考一些资料，以及自己知道的io操作的资源消耗，知道IndexWriter也有同样的问题，同时IndexWriter同一时间只能有一个实例存在(如果在第一个IndexWriter实例存在之后，索引目录下会产生一个write.lock文件，这个时候你想实例化第二个IndexWriter时，肯定会报错的)。所以考虑能否构造一个单例IndexWriter出来，然后一直持有。   参考了...
7、学习Lucene3.5之IndexReader和IndexWriter注意事项
panchang199266的博客
02-06 993
（1）IndexReader     一般全局唯一，无需关闭。在搜索索引时，创建IndexSearcher对象即可，关闭IndexSearcher即可 /** * 创建创建读索引工具:IndexReader * 问题：若IndexReader全局唯一，则当我们在搜索索引的过程中，索引发生改变（比如：用IndexWriter删除某个索引），但是搜 * 索到的索引并没有改变？
lucene的简单实例<一>
泡泡还是泡泡,本博客属于个人收藏
02-17 147
说明一下,这一篇文章的用到的lucene,是用2.0版本的,主要在查询的时候2.0版本的lucene与以前的版本有了一些区别. 其实这一些代码都是早几个月写的,自己很懒,所以到今天才写到自己的博客上,高深的文章自己写不了，只能记录下一些简单的记录与点滴，其中的代码算是自娱自乐的，希望高手不要把重构之类的砸下来... 1、在windows系统下的的C盘，建一个名叫s的文件夹,在该文件夹里面随便建三个...
关于lucene的IndexSearcher单实例,对于索引的实时搜索
weixin_34199335的博客
12-20 143
Lucene版本:3.0 一般情况下,lucene的IndexSearcher都要写成单实例,因为每次创建IndexSearcher对象的时候,它都需要把索引文件加载进来,如果访问量比较大,而索引也比较大,那就很容易造成内存溢出! 但是如果仅仅按照一般的单实例来写的话,如果更新了索引,那么在不重启服务的情况下,Searcher对象是搜索不到索引更新后的内容的.如何解决呢,这里给出一个方法! ...
lucene7与lucene8
最新发布
07-12
lucene7与lucene8是Apache Lucene搜索引擎的两个主要版本。Lucene是一个开源的全文搜索引擎库，用于构建强大的搜索功能。 Lucene7是在2017年发布的一个重要版本，它引入了许多新功能和改进。其中一些改进包括更快的搜索速度、更高效的内存使用、更好的压缩算法以及更强大的查询语法支持。此外，Lucene7还引入了一些新的模块和API，使其更易于使用和扩展。 Lucene8是在2018年发布的下一个主要版本，它进一步改进了Lucene7的功能和性能。其中一些更新包括更快的索引和搜索速度、更好的压缩率、更强大的查询语法和更灵活的排序功能。此外，Lucene8还引入了一些新的特性，如动态文档、索引分类和重用索引数据等。 总的来说，Lucene8在性能、功能和扩展性方面都有所提升，使开发者能够构建更高效和强大的搜索应用程序。不过，具体使用哪个版本还需要根据项目需求和实际情况来决定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值