lucene第一步，lucene基础，索引创建

出自：http://blog.youkuaiyun.com/wxwzy738/article/details/8799184 的整理

1、工程结构

2、索引创建时的属性：

Field.Store.YES或者NO(存储域选项)
设置为YES表示或把这个域中的内容完全存储到文件中，方便进行文本的还原
设置为NO表示把这个域的内容不存储到文件中，但是可以被索引，此时内容无法完全还原(doc.get)

Field.Index(索引选项)
Index.ANALYZED:进行分词和索引，适用于标题、内容等
Index.NOT_ANALYZED:进行索引，但是不进行分词，如果身份证号，姓名，ID等，适用于精确搜索
Index.ANALYZED_NOT_NORMS:进行分词但是不存储norms信息，这个norms中包括了创建索引的时间和权值等信息
norms中存储了很多排序的信息，
Index.NOT_ANALYZED_NOT_NORMS:即不进行分词也不存储norms信息
Index.NO:不进行索引

3、lucene的增删改查类

[java] view plain copy

1. packageorg.itat.index;
3. importjava.io.IOException;
4. importjava.text.ParseException;
5. importjava.text.SimpleDateFormat;
6. importjava.util.Date;
7. importjava.util.HashMap;
8. importjava.util.Map;
9. importorg.apache.lucene.analysis.standard.StandardAnalyzer;
10. importorg.apache.lucene.document.Document;
11. importorg.apache.lucene.document.Field;
12. importorg.apache.lucene.document.NumericField;
13. importorg.apache.lucene.index.CorruptIndexException;
14. importorg.apache.lucene.index.IndexReader;
15. importorg.apache.lucene.index.IndexWriter;
16. importorg.apache.lucene.index.IndexWriterConfig;
17. importorg.apache.lucene.index.StaleReaderException;
18. importorg.apache.lucene.index.Term;
19. importorg.apache.lucene.search.IndexSearcher;
20. importorg.apache.lucene.search.ScoreDoc;
21. importorg.apache.lucene.search.TermQuery;
22. importorg.apache.lucene.search.TopDocs;
23. importorg.apache.lucene.store.Directory;
24. importorg.apache.lucene.store.LockObtainFailedException;
25. importorg.apache.lucene.store.RAMDirectory;
26. importorg.apache.lucene.util.Version;
29. publicclassIndexUtil{
30. privateString[]ids={"1","2","3","4","5","6"};
31. privateString[]emails={"aa@itat.org","bb@itat.org","cc@cc.org","dd@sina.org","ee@zttc.edu","ff@itat.org"};
32. privateString[]contents={
33. "welcometovisitedthespace,Ilikebook",
34. "helloboy,Ilikepingpengball",
35. "mynameisccIlikegame",
36. "Ilikefootball",
37. "IlikefootballandIlikebasketballtoo",
38. "Ilikemovieandswim"
39. };
40. privateDate[]dates=null;
41. privateint[]attachs={2,3,1,4,5,5};
42. privateString[]names={"zhangsan","lisi","john","jetty","mike","jake"};
43. privateDirectorydirectory=null;
44. privateMap<String,Float>scores=newHashMap<String,Float>();
45. privatestaticIndexReaderreader=null;
47. publicIndexUtil(){
48. try{
49. setDates();
50. scores.put("itat.org",2.0f);
51. scores.put("zttc.edu",1.5f);
52. //directory=FSDirectory.open(newFile("d:/lucene/index02"));
53. directory=newRAMDirectory();
54. index();
55. reader=IndexReader.open(directory,false);
56. }catch(IOExceptione){
57. e.printStackTrace();
58. }
59. }
61. /**
62. *对于IndexReader而言，反复使用Index.open打开会有很大的开销，所以一般在整个程序的生命周期中
63. *只会打开一个IndexReader,通过这个IndexReader来创建不同的IndexSearcher,如果使用单例模式，
64. *可能出现的问题有：
65. *1、当使用Writer修改了索引之后不会更新信息，所以需要使用IndexReader.openIfChange方法操作
66. *如果IndexWriter在创建完成之后，没有关闭，需要进行commit操作之后才能提交
67. *@return
68. */
69. publicIndexSearchergetSearcher(){
70. try{
71. if(reader==null){
72. reader=IndexReader.open(directory,false);
73. }else{
74. IndexReadertr=IndexReader.openIfChanged(reader);
75. //如果原来的reader没改变，返回null
76. //如果原来的reader改变，则更新为新的索引
77. if(tr!=null){
78. reader.close();
79. reader=tr;
80. }
81. }
82. returnnewIndexSearcher(reader);
83. }catch(CorruptIndexExceptione){
84. e.printStackTrace();
85. }catch(IOExceptione){
86. e.printStackTrace();
87. }
88. returnnull;
90. }
92. privatevoidsetDates(){
93. SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-dd");
94. try{
95. dates=newDate[ids.length];
96. dates[0]=sdf.parse("2010-02-19");
97. dates[1]=sdf.parse("2012-01-11");
98. dates[2]=sdf.parse("2011-09-19");
99. dates[3]=sdf.parse("2010-12-22");
100. dates[4]=sdf.parse("2012-01-01");
101. dates[5]=sdf.parse("2011-05-19");
102. }catch(ParseExceptione){
103. e.printStackTrace();
104. }
105. }
106. /**
107. *把之前删除的索引数据进行恢复
108. */
109. publicvoidundelete(){
110. //使用IndexReader进行恢复
111. try{
112. IndexReaderreader=IndexReader.open(directory,false);
113. //恢复时，必须把IndexReader的只读(readOnly)设置为false
114. reader.undeleteAll();
115. reader.close();
116. }catch(CorruptIndexExceptione){
117. e.printStackTrace();
118. }catch(StaleReaderExceptione){
119. e.printStackTrace();
120. }catch(LockObtainFailedExceptione){
121. e.printStackTrace();
122. }catch(IOExceptione){
123. e.printStackTrace();
124. }
125. }
126. /**
127. *forceMerge是lucene3.5之前替代optimize方法的，其实只是改了个名称，因为优化的使效率变低
128. *因为一到优化它就会全部更新索引，这个所涉及到的负载是很大的
129. *所以改了个名称，不推荐使用，在做优化的时候会把索引回收站中的数据文件全部删除
130. *lucene会在你写索引的时候根据你的索引的段越来越多会自动帮忙优化的，force是强制优化
131. */
132. publicvoidmerge(){
133. IndexWriterwriter=null;
134. try{
135. writer=newIndexWriter(directory,
136. newIndexWriterConfig(Version.LUCENE_35,newStandardAnalyzer(Version.LUCENE_35)));
137. //会将索引合并为2段，这两段中的被删除的数据会被清空
138. //特别注意：此处Lucene在3.5之后不建议使用，因为会消耗大量的开销，
139. //Lucene会根据情况自动处理的
140. writer.forceMerge(2);
141. }catch(CorruptIndexExceptione){
142. e.printStackTrace();
143. }catch(LockObtainFailedExceptione){
144. e.printStackTrace();
145. }catch(IOExceptione){
146. e.printStackTrace();
147. }finally{
148. try{
149. if(writer!=null)writer.close();
150. }catch(CorruptIndexExceptione){
151. e.printStackTrace();
152. }catch(IOExceptione){
153. e.printStackTrace();
154. }
155. }
156. }
158. /**
159. *假如你想要强制删除回收站的信息可以调用writer.forceMergeDeletes()这个方法，
160. *但是这个方法不推荐使用，比较消耗内存，lucene会自动根据容量的大小删除所删除的文件
161. */
162. publicvoidforceDelete(){
163. IndexWriterwriter=null;
165. try{
166. writer=newIndexWriter(directory,
167. newIndexWriterConfig(Version.LUCENE_35,newStandardAnalyzer(Version.LUCENE_35)));
168. writer.forceMergeDeletes();
169. }catch(CorruptIndexExceptione){
170. e.printStackTrace();
171. }catch(LockObtainFailedExceptione){
172. e.printStackTrace();
173. }catch(IOExceptione){
174. e.printStackTrace();
175. }finally{
176. try{
177. if(writer!=null)writer.close();
178. }catch(CorruptIndexExceptione){
179. e.printStackTrace();
180. }catch(IOExceptione){
181. e.printStackTrace();
182. }
183. }
184. }
185. /**
186. *删除索引数据,默认不会完全删除，被放入索引回收站
187. */
188. publicvoiddelete(){
189. IndexWriterwriter=null;
191. try{
192. writer=newIndexWriter(directory,
193. newIndexWriterConfig(Version.LUCENE_35,newStandardAnalyzer(Version.LUCENE_35)));
194. //参数是一个选项，可以是一个Query，也可以是一个term，term是一个精确查找的值
195. //此时删除的文档并不会被完全删除，而是存储在一个回收站中的，可以恢复
196. //执行完这个操作，索引文件夹下就会多出一个名叫_0_1.del的文件，也就是删除的文件在这个文件中记录了
197. writer.deleteDocuments(newTerm("id","1"));
198. writer.commit();
199. }catch(CorruptIndexExceptione){
200. e.printStackTrace();
201. }catch(LockObtainFailedExceptione){
202. e.printStackTrace();
203. }catch(IOExceptione){
204. e.printStackTrace();
205. }finally{
206. try{
207. if(writer!=null)writer.close();
208. }catch(CorruptIndexExceptione){
209. e.printStackTrace();
210. }catch(IOExceptione){
211. e.printStackTrace();
212. }
213. }
214. }
215. /**
216. *使用reader删除，其实里面也会调用writer删除，
217. *优点是使用reader删除马上会更新索引信息
218. *现在一般还是使用writer来删除，reader.getWriter这个方法被过时了
219. */
220. publicvoiddelete02(){
221. try{
222. reader.deleteDocuments(newTerm("id","1"));
223. }catch(CorruptIndexExceptione){
224. e.printStackTrace();
225. }catch(LockObtainFailedExceptione){
226. e.printStackTrace();
227. }catch(IOExceptione){
228. e.printStackTrace();
229. }
230. }
231. /**
232. *更新操作
233. *Lucene并没有提供更新，这里的更新操作其实是如下两个操作的合集
234. *先删除之后再添加
235. */
236. publicvoidupdate(){
237. IndexWriterwriter=null;
238. try{
239. writer=newIndexWriter(directory,
240. newIndexWriterConfig(Version.LUCENE_35,newStandardAnalyzer(Version.LUCENE_35)));
241. Documentdoc=newDocument();
242. doc.add(newField("id","11",Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
243. doc.add(newField("email",emails[0],Field.Store.YES,Field.Index.NOT_ANALYZED));
244. doc.add(newField("content",contents[0],Field.Store.NO,Field.Index.ANALYZED));
245. doc.add(newField("name",names[0],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
246. writer.updateDocument(newTerm("id","1"),doc);
247. }catch(CorruptIndexExceptione){
248. e.printStackTrace();
249. }catch(LockObtainFailedExceptione){
250. e.printStackTrace();
251. }catch(IOExceptione){
252. e.printStackTrace();
253. }finally{
254. try{
255. if(writer!=null)writer.close();
256. }catch(CorruptIndexExceptione){
257. e.printStackTrace();
258. }catch(IOExceptione){
259. e.printStackTrace();
260. }
261. }
262. }
264. publicvoidquery(){
265. try{
266. IndexReaderreader=IndexReader.open(directory);
267. //通过reader可以有效的获取到文档的数量
268. System.out.println("numDocs:"+reader.numDocs());//存储的文档数//不包括被删除的
269. System.out.println("maxDocs:"+reader.maxDoc());//总存储量,包括在回收站中的索引
270. System.out.println("deleteDocs:"+reader.numDeletedDocs());
271. reader.close();
272. }catch(CorruptIndexExceptione){
273. e.printStackTrace();
274. }catch(IOExceptione){
275. e.printStackTrace();
276. }
277. }
278. /**
279. *索引文件后缀为.fmn为保存的是域的名称等
280. *.fdt和.fdx保存的是Store.YES的信息，保存域里面存储的数据
281. *.frq表示这里的域哪些出现多少次，哪些单词出现多少次，
282. *.nrm存储一些评分信息
283. *.prx存储一些偏移量等
284. *.tii和.tis专门存储索引里面的所有内容信息
285. */
286. publicvoidindex(){
287. IndexWriterwriter=null;
288. try{
289. //在2.9版本之后,lucene的就不是全部的索引格式都兼容的了,所以在使用的时候必须写明版本号
290. writer=newIndexWriter(directory,newIndexWriterConfig(Version.LUCENE_35,newStandardAnalyzer(Version.LUCENE_35)));
291. writer.deleteAll();//清空索引
292. Documentdoc=null;
293. for(inti=0;i<ids.length;i++){
294. doc=newDocument();
295. doc.add(newField("id",ids[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
296. doc.add(newField("email",emails[i],Field.Store.YES,Field.Index.NOT_ANALYZED));
297. doc.add(newField("email","test"+i+"@test.com",Field.Store.YES,Field.Index.NOT_ANALYZED));
298. doc.add(newField("content",contents[i],Field.Store.NO,Field.Index.ANALYZED));
299. doc.add(newField("name",names[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
300. //存储数字
301. //NumberTools.stringToLong("");已经被标记为过时了
302. doc.add(newNumericField("attach",Field.Store.YES,true).setIntValue(attachs[i]));
303. //存储日期
304. doc.add(newNumericField("date",Field.Store.YES,true).setLongValue(dates[i].getTime()));
305. Stringet=emails[i].substring(emails[i].lastIndexOf("@")+1);
306. System.out.println(et);
307. if(scores.containsKey(et)){
308. doc.setBoost(scores.get(et));
309. }else{
310. doc.setBoost(0.5f);//默认是1.0f
311. }
312. writer.addDocument(doc);
313. }
314. }catch(CorruptIndexExceptione){
315. e.printStackTrace();
316. }catch(LockObtainFailedExceptione){
317. e.printStackTrace();
318. }catch(IOExceptione){
319. e.printStackTrace();
320. }finally{
321. try{
322. if(writer!=null)writer.close();
323. }catch(CorruptIndexExceptione){
324. e.printStackTrace();
325. }catch(IOExceptione){
326. e.printStackTrace();
327. }
328. }
329. }
331. publicvoidsearch01(){
332. try{
333. IndexReaderreader=IndexReader.open(directory);
334. IndexSearchersearcher=newIndexSearcher(reader);
335. TermQueryquery=newTermQuery(newTerm("email","test0@test.com"));
336. TopDocstds=searcher.search(query,10);
337. for(ScoreDocsd:tds.scoreDocs){
338. Documentdoc=searcher.doc(sd.doc);
339. System.out.println("("+sd.doc+"-"+doc.getBoost()+"-"+sd.score+")"+
340. doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+
341. doc.get("attach")+","+doc.get("date")+","+doc.getValues("email")[1]);
342. }
343. reader.close();
344. }catch(CorruptIndexExceptione){
345. e.printStackTrace();
346. }catch(IOExceptione){
347. e.printStackTrace();
348. }
349. }
351. publicvoidsearch02(){
352. try{
353. IndexSearchersearcher=getSearcher();
354. TermQueryquery=newTermQuery(newTerm("content","like"));
355. TopDocstds=searcher.search(query,10);
356. for(ScoreDocsd:tds.scoreDocs){
357. Documentdoc=searcher.doc(sd.doc);
358. System.out.println(doc.get("id")+"---->"+
359. doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+
360. doc.get("attach")+","+doc.get("date")+","+doc.getValues("email")[1]);
361. }
362. searcher.close();
363. }catch(CorruptIndexExceptione){
364. e.printStackTrace();
365. }catch(IOExceptione){
366. e.printStackTrace();
367. }
368. }
370. }

4、lucene的单元测试类

[java] view plain copy

1. packageorg.itat.test;
3. importorg.itat.index.IndexUtil;
4. importorg.junit.Test;
6. publicclassTestIndex{
8. @Test
9. publicvoidtestIndex(){
10. IndexUtiliu=newIndexUtil();
11. iu.index();
12. }
14. @Test
15. publicvoidtestQuery(){
16. IndexUtiliu=newIndexUtil();
17. iu.query();
18. }
20. @Test
21. publicvoidtestDelete(){
22. IndexUtiliu=newIndexUtil();
23. iu.delete();
24. }
26. @Test
27. publicvoidtestDelete02(){
28. IndexUtiliu=newIndexUtil();
29. iu.delete02();
30. }
32. @Test
33. publicvoidtestUnDelete(){
34. IndexUtiliu=newIndexUtil();
35. iu.undelete();
36. }
38. @Test
39. publicvoidtestForceDelete(){
40. IndexUtiliu=newIndexUtil();
41. iu.forceDelete();
42. }
44. @Test
45. publicvoidtestMerge(){
46. IndexUtiliu=newIndexUtil();
47. iu.merge();
48. }
50. @Test
51. publicvoidtestUpdate(){
52. IndexUtiliu=newIndexUtil();
53. iu.update();
54. }
56. @Test
57. publicvoidtestSearch01(){
58. IndexUtiliu=newIndexUtil();
59. iu.search01();
60. }
62. @Test
63. publicvoidtestSearch02(){
64. IndexUtiliu=newIndexUtil();
65. for(inti=0;i<5;i++){
66. iu.search02();
67. System.out.println("-----------------------------");
68. try{
69. Thread.sleep(10000);
70. }catch(InterruptedExceptione){
71. e.printStackTrace();
72. }
73. }
74. }
75. }