Lucene3.6.2入门系列

文章15 |   阅读 6822 |   点赞0

来源：https://blog.csdn.net/jadyer/category_1571227.html

【Lucene3.6.2入门系列】第12节_近实时搜索

转x33g5p2x  于2021-12-24 转载在 其他  
字(6.7k)|赞(0)|评价(0)|浏览(445)

完整版见 https://jadyer.github.io/2013/08/20/lucene-nrt/

  1. package com.jadyer.lucene;
  3. import java.io.File;
  4. import java.io.IOException;
  6. import org.apache.lucene.analysis.standard.StandardAnalyzer;
  7. import org.apache.lucene.document.Document;
  8. import org.apache.lucene.document.Field;
  9. import org.apache.lucene.index.IndexReader;
  10. import org.apache.lucene.index.IndexWriter;
  11. import org.apache.lucene.index.IndexWriterConfig;
  12. import org.apache.lucene.index.Term;
  13. import org.apache.lucene.search.IndexSearcher;
  14. import org.apache.lucene.search.NRTManager;
  15. import org.apache.lucene.search.NRTManagerReopenThread;
  16. import org.apache.lucene.search.Query;
  17. import org.apache.lucene.search.ScoreDoc;
  18. import org.apache.lucene.search.TermQuery;
  19. import org.apache.lucene.search.TopDocs;
  20. import org.apache.lucene.search.NRTManager.TrackingIndexWriter;
  21. import org.apache.lucene.store.Directory;
  22. import org.apache.lucene.store.FSDirectory;
  23. import org.apache.lucene.util.Version;
  25. /**
  26.  * 【Lucene3.6.2入门系列】第12节_近实时搜索
  27.  * @see 实时搜索(near-real-time)---->只要数据发生变化,则马上更新索引(IndexWriter.commit())
  28.  * @see 近实时搜索------------------>数据发生变化时,先将索引保存到内存中,然后在一个统一的时间再对内存中的所有索引执行commit提交动作
  29.  * @see 为了实现近实时搜索,Lucene3.0提供的方式叫做reopen,后来的版本中提供了两个线程安全的类NRTManager和SearcherManager
  30.  * @see 不过这俩线程安全的类在Lucene3.5和3.6版本中的用法有点不太一样,这点要注意
  31.  * @create Aug 7, 2013 4:19:58 PM
  32.  * @author 玄玉<http://blog.csdn.net/jadyer>
  33.  */
  34. public class HelloNRTSearch {
  35. 	private IndexWriter writer;
  36. 	private NRTManager nrtManager;
  37. 	private TrackingIndexWriter trackWriter;
  39. 	public HelloNRTSearch(){
  40. 		try {
  41. 			Directory directory = FSDirectory.open(new File("myExample/myIndex/"));
  42. 			writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
  43. 			trackWriter = new NRTManager.TrackingIndexWriter(writer);
  44. //			/*
  45. //			 * Lucene3.5中的NRTManager是通过下面的方式创建的
  46. //			 * 并且Lucene3.5中可以直接使用NRTManager.getSearcherManager(true)获取到org.apache.lucene.search.SearcherManager
  47. //			 */
  48. //			nrtManager = new NRTManager(writer,new org.apache.lucene.search.SearcherWarmer() {
  49. //				@Override
  50. //				public void warm(IndexSearcher s) throws IOException {
  51. //					System.out.println("IndexSearcher.reopen时会自动调用此方法");
  52. //				}
  53. //			});
  54. 			nrtManager = new NRTManager(trackWriter, null);
  55. 			//启动一个Lucene提供的后台线程来自动定时的执行NRTManager.maybeRefresh()方法
  56. 			//这里的后俩参数,是根据这篇分析的文章写的http://blog.mikemccandless.com/2011/11/near-real-time-readers-with-lucenes.html
  57. 			NRTManagerReopenThread reopenThread = new NRTManagerReopenThread(nrtManager, 5.0, 0.025);
  58. 			reopenThread.setName("NRT Reopen Thread");
  59. 			reopenThread.setDaemon(true);
  60. 			reopenThread.start();
  61. 		} catch (Exception e) {
  62. 			e.printStackTrace();
  63. 		}
  64. 	}
  65. 	
  66. 	
  67. 	/**
  68. 	 * 创建索引
  69. 	 */
  70. 	public static void createIndex(){
  71. 		String[] ids = {"1", "2", "3", "4", "5", "6"};
  72. 		String[] names = {"Michael", "Scofield", "Tbag", "Jack", "Jade", "Jadyer"};
  73. 		String[] contents = {"my blog", "my website", "my name", "my job is JavaDeveloper", "I am from Haerbin", "I like Lucene"};
  74. 		IndexWriter writer = null;
  75. 		Document doc = null;
  76. 		try{
  77. 			Directory directory = FSDirectory.open(new File("myExample/myIndex/"));
  78. 			writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
  79. 			writer.deleteAll();
  80. 			for(int i=0; i<names.length; i++){
  81. 				doc = new Document();
  82. 				doc.add(new Field("id",ids[i],Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
  83. 				doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
  84. 				doc.add(new Field("content", contents[i], Field.Store.YES, Field.Index.ANALYZED));
  85. 				writer.addDocument(doc);
  86. 			}
  87. 		}catch(Exception e) {
  88. 			e.printStackTrace();
  89. 		}finally{
  90. 			if(null != writer){
  91. 				try {
  92. 					writer.close();
  93. 				} catch (IOException ce) {
  94. 					ce.printStackTrace();
  95. 				}
  96. 			}
  97. 		}
  98. 	}
  99. 	
  100. 	
  101. 	/**
  102. 	 * 通过IndexReader获取文档数量
  103. 	 */
  104. 	public static void getDocsCount(){
  105. 		IndexReader reader = null;
  106. 		try {
  107. 			reader = IndexReader.open(FSDirectory.open(new File("myExample/myIndex/")));
  108. 			System.out.println("maxDocs:" + reader.maxDoc());
  109. 			System.out.println("numDocs:" + reader.numDocs());
  110. 			System.out.println("deletedDocs:" + reader.numDeletedDocs());
  111. 		} catch (Exception e) {
  112. 			e.printStackTrace();
  113. 		} finally {
  114. 			if(reader != null){
  115. 				try {
  116. 					reader.close();
  117. 				} catch (IOException e) {
  118. 					e.printStackTrace();
  119. 				}
  120. 			}
  121. 		}
  122. 	}
  123. 	
  124. 	
  125. 	/**
  126. 	 * 搜索文件
  127. 	 */
  128. 	public void searchFile(){
  129. 		//Lucene3.5里面可以直接使用NRTManager.getSearcherManager(true).acquire()
  130. 		IndexSearcher searcher = nrtManager.acquire();
  131. 		Query query = new TermQuery(new Term("content", "my"));
  132. 		try{
  133. 			TopDocs tds = searcher.search(query, 10);
  134. 			for(ScoreDoc sd : tds.scoreDocs){
  135. 				Document doc = searcher.doc(sd.doc);
  136. 				System.out.print("文档编号=" + sd.doc + "  文档权值=" + doc.getBoost() + "  文档评分=" + sd.score + "    ");
  137. 				System.out.println("id=" + doc.get("id") + "  name=" + doc.get("name") + "  content=" + doc.get("content"));
  138. 			}
  139. 		}catch(Exception e) {
  140. 			e.printStackTrace();
  141. 		}finally{
  142. 			try {
  143. 				//这里就不要IndexSearcher.close()啦,而是交由NRTManager来释放
  144. 				nrtManager.release(searcher);
  145. 				//Lucene-3.6.2文档中ReferenceManager.acquire()方法描述里建议再手工设置searcher为null,以防止在其它地方被意外的使用
  146. 				searcher = null;
  147. 			} catch (IOException e) {
  148. 				e.printStackTrace();
  149. 			}
  150. 		}
  151. 	}
  152. 	
  153. 	
  154. 	/**
  155. 	 * 更新索引
  156. 	 */
  157. 	public void updateIndex(){
  158. 		Document doc = new Document();
  159. 		doc.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
  160. 		doc.add(new Field("name", "xuanyu", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
  161. 		doc.add(new Field("content", "my name is xuanyu", Field.Store.YES, Field.Index.ANALYZED));
  162. 		try{
  163. 			//Lucene3.5中可以直接使用org.apache.lucene.search.NRTManager.updateDocument(new Term("id", "1"), doc)
  164. 			trackWriter.updateDocument(new Term("id", "1"), doc);
  165. 		}catch(IOException e) {
  166. 			e.printStackTrace();
  167. 		}
  168. 	}
  169. 	
  170. 	
  171. 	/**
  172. 	 * 删除索引
  173. 	 */
  174. 	public void deleteIndex(){
  175. 		try {
  176. 			//Lucene3.5中可以直接使用org.apache.lucene.search.NRTManager.deleteDocuments(new Term("id", "2"))
  177. 			trackWriter.deleteDocuments(new Term("id", "2"));
  178. 		} catch (IOException e) {
  179. 			e.printStackTrace();
  180. 		}
  181. 	}
  182. 	
  183. 	
  184. 	/**
  185. 	 * 提交索引内容的变更情况
  186. 	 */
  187. 	public void commitIndex(){
  188. 		try {
  189. 			writer.commit();
  190. 		} catch (IOException e) {
  191. 			e.printStackTrace();
  192. 		}
  193. 	}
  194. }

下面是用JUnit4.x写的小测试

  1. package com.jadyer.test;
  3. import org.junit.After;
  4. import org.junit.Before;
  5. import org.junit.Test;
  7. import com.jadyer.lucene.HelloNRTSearch;
  9. public class HelloNRTSearchTest {
  10. 	@Before
  11. 	public void init(){
  12. 		HelloNRTSearch.createIndex();
  13. 	}
  14. 	
  15. 	@After
  16. 	public void destroy(){
  17. 		HelloNRTSearch.getDocsCount();
  18. 	}
  19. 	
  20. 	@Test
  21. 	public void searchFile(){
  22. 		HelloNRTSearch hello = new HelloNRTSearch();
  23. 		for(int i=0; i<5; i++){
  24. 			hello.searchFile();
  25. 			System.out.println("-----------------------------------------------------------");
  26. 			hello.deleteIndex();
  27. 			if(i == 2){
  28. 				hello.updateIndex();
  29. 			}
  30. 			try {
  31. 				System.out.println(".........开始休眠5s(模拟近实时搜索情景)");
  32. 				Thread.sleep(5000);
  33. 				System.out.println(".........休眠结束");
  34. 			} catch (InterruptedException e) {
  35. 				e.printStackTrace();
  36. 			}
  37. 		}
  38. 		//不能单独去new HelloNRTSearch,要保证它们是同一个对象,否则所做的delete和update不会被commit
  39. 		hello.commitIndex();
  40. 	}
  41. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/jadyer/article/details/10102765

内容来源于网络，如有侵权，请联系作者删除！

solrlucene实时搜索近实时搜索

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com