lucene3.5的查询语法

lucene3.5的查询语法
1、工程结构

2、查询语法代码
[java] view plain copy
1. package org.itat.index;
2. 
3. import java.io.File;
4. import java.io.IOException;
5. import java.io.StringReader;
6. import java.text.ParseException;
7. import java.text.SimpleDateFormat;
8. import java.util.Date;
9. import java.util.HashMap;
10. import java.util.Map;
11. import org.apache.lucene.analysis.Analyzer;
12. import org.apache.lucene.analysis.TokenStream;
13. import org.apache.lucene.analysis.standard.StandardAnalyzer;
14. import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
15. import org.apache.lucene.document.Document;
16. import org.apache.lucene.document.Field;
17. import org.apache.lucene.document.NumericField;
18. import org.apache.lucene.index.CorruptIndexException;
19. import org.apache.lucene.index.IndexReader;
20. import org.apache.lucene.index.IndexWriter;
21. import org.apache.lucene.index.IndexWriterConfig;
22. import org.apache.lucene.index.Term;
23. import org.apache.lucene.queryParser.QueryParser;
24. import org.apache.lucene.search.BooleanClause.Occur;
25. import org.apache.lucene.search.BooleanQuery;
26. import org.apache.lucene.search.FuzzyQuery;
27. import org.apache.lucene.search.IndexSearcher;
28. import org.apache.lucene.search.NumericRangeQuery;
29. import org.apache.lucene.search.PhraseQuery;
30. import org.apache.lucene.search.PrefixQuery;
31. import org.apache.lucene.search.Query;
32. import org.apache.lucene.search.ScoreDoc;
33. import org.apache.lucene.search.TermQuery;
34. import org.apache.lucene.search.TermRangeQuery;
35. import org.apache.lucene.search.TopDocs;
36. import org.apache.lucene.search.WildcardQuery;
37. import org.apache.lucene.store.Directory;
38. import org.apache.lucene.store.FSDirectory;
39. import org.apache.lucene.store.LockObtainFailedException;
40. import org.apache.lucene.util.Version;
41. import org.wltea.analyzer.lucene.IKAnalyzer;
42. 
43. public class SearcherUtil {
44. private Directory directory;
45. private Analyzer analyzer = new IKAnalyzer();
46. private IndexReader reader;
47. private String[] ids = {"1","2","3","4","5","6"};
48. private String[] emails = {"aa@itat.org","bb@itat.org","cc@cc.org","dd@sina.org","ee@zttc.edu","ff@itat.org"};
49. private String[] contents = {
50. "welcome to visited the space,I like book",
51. "hello boy, I like pingpeng ball",
52. "my name is cc I like game",
53. "I like football",
54. "I like football and I like basketball too",
55. "I like movie and swim"
56. };
57. private Date[] dates = null;
58. private int[] attachs = {2,3,1,4,5,5};
59. private String[] names = {"zhangsan","lisi","john","jetty","mike","jake"};
60. private Map<String,Float> scores = new HashMap<String,Float>();
61. 
62. public SearcherUtil() {
63. // directory = new RAMDirectory();
64. try {
65. directory = FSDirectory.open(new File("F:\\Workspaces\\lucenes\\02_lucene_searcher\\index"));
66. setDates();
67. scores.put("itat.org",2.0f);
68. scores.put("zttc.edu", 1.5f);
69. // index();
70. } catch (IOException e) {
71. e.printStackTrace();
72. }
73. }
74. 
75. private void setDates() {
76. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
77. try {
78. dates = new Date[ids.length];
79. dates[0] = sdf.parse("2010-02-19");
80. dates[1] = sdf.parse("2012-01-11");
81. dates[2] = sdf.parse("2011-09-19");
82. dates[3] = sdf.parse("2010-12-22");
83. dates[4] = sdf.parse("2012-01-01");
84. dates[5] = sdf.parse("2011-05-19");
85. } catch (ParseException e) {
86. e.printStackTrace();
87. }
88. }
89. 
90. 
91. public void index() {
92. IndexWriter writer = null;
93. try {
94. writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
95. writer.deleteAll();
96. Document doc = null;
97. for(int i=0;i<ids.length;i++) {
98. doc = new Document();
99. doc.add(new Field("id",ids[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
100. doc.add(new Field("email",emails[i],Field.Store.YES,Field.Index.NOT_ANALYZED));
101. doc.add(new Field("content",contents[i],Field.Store.NO,Field.Index.ANALYZED));
102. doc.add(new Field("name",names[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
103. //存储数字
104. doc.add(new NumericField("attach",Field.Store.YES,true).setIntValue(attachs[i]));
105. //存储日期
106. doc.add(new NumericField("date",Field.Store.YES,true).setLongValue(dates[i].getTime()));
107. String et = emails[i].substring(emails[i].lastIndexOf("@")+1);
108. if(scores.containsKey(et)) {
109. doc.setBoost(scores.get(et));
110. } else {
111. doc.setBoost(0.5f);
112. }
113. writer.addDocument(doc);
114. }
115. } catch (CorruptIndexException e) {
116. e.printStackTrace();
117. } catch (LockObtainFailedException e) {
118. e.printStackTrace();
119. } catch (IOException e) {
120. e.printStackTrace();
121. } finally {
122. try {
123. if(writer!=null)writer.close();
124. } catch (CorruptIndexException e) {
125. e.printStackTrace();
126. } catch (IOException e) {
127. e.printStackTrace();
128. }
129. }
130. }
131. 
132. public IndexSearcher getSearcher() {
133. try {
134. if(reader==null) {
135. reader = IndexReader.open(directory);
136. } else {
137. IndexReader tr = IndexReader.openIfChanged(reader);
138. if(tr!=null) {
139. reader.close();
140. reader = tr;
141. }
142. }
143. return new IndexSearcher(reader);
144. } catch (CorruptIndexException e) {
145. e.printStackTrace();
146. } catch (IOException e) {
147. e.printStackTrace();
148. }
149. return null;
150. }
151. 
152. public IndexSearcher getSearcher(Directory directory) {
153. try {
154. if(reader==null) {
155. reader = IndexReader.open(directory);
156. } else {
157. IndexReader tr = IndexReader.openIfChanged(reader);
158. if(tr!=null) {
159. reader.close();
160. reader = tr;
161. }
162. }
163. return new IndexSearcher(reader);
164. } catch (CorruptIndexException e) {
165. e.printStackTrace();
166. } catch (IOException e) {
167. e.printStackTrace();
168. }
169. return null;
170. }
171. 
172. public void searchByTerm(String field,String name,int num) {
173. try {
174. IndexSearcher searcher = getSearcher();
175. Query query = new TermQuery(new Term(field,name));
176. TopDocs tds = searcher.search(query, num);
177. printDocument(searcher, tds);
178. searcher.close();
179. } catch (CorruptIndexException e) {
180. e.printStackTrace();
181. } catch (IOException e) {
182. e.printStackTrace();
183. }
184. }
185. public void searchByTermToken(String field,String name,int num) {
186. try {
187. IndexSearcher searcher = getSearcher();
188. // Query query = new TermQuery(new Term(field,name));
189. //当用户输入两个关键字时，QueryParser默认它们之间的关系为“或”关系
190. //下面这么写的话在对用户输入进行扫描时，就会用空格分开的关键字理解为“与”，
191. //其实也就是构建了一个“与”关系的布尔型查询
192. // parser.setDefaultOperator(Operator.AND);
193. QueryParser parser = new QueryParser(Version.LUCENE_35, field, analyzer);
194. String k = analyzerKey(name);
195. Query query = parser.parse(name);
196. TopDocs tds = searcher.search(query, num);
197. printDocument(searcher, tds);
198. searcher.close();
199. } catch (CorruptIndexException e) {
200. e.printStackTrace();
201. } catch (Exception e) {
202. e.printStackTrace();
203. }
204. }
205. private String analyzerKey(String key){
206. // StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_35);
207. StringReader reader = new StringReader(key);
208. TokenStream tokenStream = analyzer.tokenStream("", reader);
209. CharTermAttribute termattr = tokenStream.addAttribute(CharTermAttribute.class);
210. StringBuilder sb = new StringBuilder();
211. try {
212. while(tokenStream.incrementToken()){
213. String k = termattr.toString();
214. sb.append(k).append(" ");
215. }
216. } catch (IOException e) {
217. e.printStackTrace();
218. }
219. key = sb.toString().trim();
220. key = key.replaceAll("\\s+", " AND ");
221. return sb.toString();
222. }
223. public void printDocument(IndexSearcher searcher,TopDocs tds){
224. System.out.println("共查询了【"+tds.totalHits+"】条");
225. for(ScoreDoc sd : tds.scoreDocs){
226. try {
227. Document doc = searcher.doc(sd.doc);
228. System.out.println("filename:"+doc.get("filename"));
229. System.out.println("path:"+doc.get("path"));
230. System.out.println("date:"+doc.get("date"));
231. System.out.println("size:"+doc.get("size"));
232. System.out.println("content:"+doc.get("content"));
233. System.out.println("-------------------------------------------");
234. } catch (CorruptIndexException e) {
235. e.printStackTrace();
236. } catch (IOException e) {
237. e.printStackTrace();
238. }
239. }
240. }
241. public void searchByTermRange(String field,String start,String end,int num) {
242. try {
243. IndexSearcher searcher = getSearcher();
244. Query query = new TermRangeQuery(field,start,end,true, true);
245. TopDocs tds = searcher.search(query, num);
246. printDocument(searcher, tds);
247. searcher.close();
248. } catch (CorruptIndexException e) {
249. e.printStackTrace();
250. } catch (IOException e) {
251. e.printStackTrace();
252. }
253. }
254. /**
255. * 建立索引时：使用的Field，而使用NumericRangeQuery，必须使用NumericField
256. * @param field
257. * @param start
258. * @param end
259. * @param num
260. */
261. public void searchByNumricRange(String field,int start,int end,int num) {
262. try {
263. IndexSearcher searcher = getSearcher();
264. Query query = NumericRangeQuery.newIntRange(field,start, end,true,true);
265. // DateTools.dateToString(new Date(), null);
266. TopDocs tds = searcher.search(query, num);
267. printDocument(searcher, tds);
268. searcher.close();
269. } catch (CorruptIndexException e) {
270. e.printStackTrace();
271. } catch (IOException e) {
272. e.printStackTrace();
273. }
274. }
275. 
276. public void searchByPrefix(String field,String value,int num) {
277. try {
278. IndexSearcher searcher = getSearcher();
279. Query query = new PrefixQuery(new Term(field,value));
280. TopDocs tds = searcher.search(query, num);
281. printDocument(searcher, tds);
282. searcher.close();
283. } catch (CorruptIndexException e) {
284. e.printStackTrace();
285. } catch (IOException e) {
286. e.printStackTrace();
287. }
288. }
289. 
290. public void searchByWildcard(String field,String value,int num) {
291. try {
292. IndexSearcher searcher = getSearcher();
293. //在传入的value中可以使用通配符:?和*,?表示匹配一个字符，*表示匹配任意多个字符
294. Query query = new WildcardQuery(new Term(field,value));
295. TopDocs tds = searcher.search(query, num);
296. printDocument(searcher, tds);
297. searcher.close();
298. } catch (CorruptIndexException e) {
299. e.printStackTrace();
300. } catch (IOException e) {
301. e.printStackTrace();
302. }
303. }
304. 
305. public void searchByBoolean(int num) {
306. try {
307. IndexSearcher searcher = getSearcher();
308. BooleanQuery query = new BooleanQuery();
309. /*
310. * BooleanQuery可以连接多个子查询
311. * Occur.MUST表示必须出现
312. * Occur.SHOULD表示可以出现
313. * Occur.MUSE_NOT表示不能出现
314. */
315. query.add(new TermQuery(new Term("name","3")), Occur.MUST_NOT);
316. query.add(new TermQuery(new Term("content","健壮")),Occur.SHOULD);
317. TopDocs tds = searcher.search(query, num);
318. printDocument(searcher, tds);
319. searcher.close();
320. } catch (CorruptIndexException e) {
321. e.printStackTrace();
322. } catch (IOException e) {
323. e.printStackTrace();
324. }
325. }
326. 
327. public void searchByPhrase(int num) {
328. try {
329. IndexSearcher searcher = getSearcher();
330. PhraseQuery query = new PhraseQuery();
331. query.setSlop(10);
332. query.add(new Term("content","java"));
333. //第一个Term
334. query.add(new Term("content","程序"));
335. //产生距离之后的第二个Term
336. // query.add(new Term("content","football"));
337. TopDocs tds = searcher.search(query, num);
338. printDocument(searcher, tds);
339. searcher.close();
340. } catch (CorruptIndexException e) {
341. e.printStackTrace();
342. } catch (IOException e) {
343. e.printStackTrace();
344. }
345. }
346. /**
347. * 查询用于匹配与指定项相似的项
348. * 默认是匹配一个有不同的，其他一样的，比如like 和 mike，就是距离算法的相似距离为1
349. * 这种方式少用，影响效率
350. */
351. public void searchByFuzzy(int num) {
352. try {
353. IndexSearcher searcher = getSearcher();
354. //最后两个参数为匹配率和距离
355. FuzzyQuery query = new FuzzyQuery(new Term("content","总统"),0.4f,0);
356. System.out.println(query.getPrefixLength());
357. System.out.println(query.getMinSimilarity());
358. TopDocs tds = searcher.search(query, num);
359. printDocument(searcher, tds);
360. searcher.close();
361. } catch (CorruptIndexException e) {
362. e.printStackTrace();
363. } catch (IOException e) {
364. e.printStackTrace();
365. }
366. }
367. 
368. public void searchByQueryParse(Query query,int num) {
369. try {
370. IndexSearcher searcher = getSearcher();
371. TopDocs tds = searcher.search(query, num);
372. System.out.println("一共查询了:"+tds.totalHits);
373. for(ScoreDoc sd:tds.scoreDocs) {
374. Document doc = searcher.doc(sd.doc);
375. System.out.println(doc.get("id")+"---->"+
376. doc.get("name")+"["+doc.get("email")+"]-->"+doc.get("id")+","+
377. doc.get("attach")+","+doc.get("date")+"=="+sd.score);
378. }
379. searcher.close();
380. } catch (CorruptIndexException e) {
381. e.printStackTrace();
382. } catch (IOException e) {
383. e.printStackTrace();
384. }
385. }
386. /**
387. * lucene3.5之前采用的是一种再查询的方式，也就是说先把全部的结果的docid查询出来，然后
388. * 分页得到该页的docid，然后根据docid得到document信息，
389. * lucene官方是说他的速度已经够快，再查询不会有效率问题
390. * @param query
391. * @param pageIndex
392. * @param pageSize
393. */
394. public void searchPage(String query,int pageIndex,int pageSize) {
395. try {
396. Directory dir = FileIndexUtils.getDirectory();
397. IndexSearcher searcher = getSearcher(dir);
398. QueryParser parser = new QueryParser(Version.LUCENE_35,"content",analyzer);
399. Query q = parser.parse(query);
400. TopDocs tds = searcher.search(q, 500);
401. ScoreDoc[] sds = tds.scoreDocs;
402. int start = (pageIndex-1)*pageSize;
403. int end = pageIndex*pageSize;
404. for(int i=start;i<end;i++) {
405. Document doc = searcher.doc(sds[i].doc);
406. System.out.println("filename:"+doc.get("filename"));
407. System.out.println("path:"+doc.get("path"));
408. System.out.println("date:"+doc.get("date"));
409. System.out.println("size:"+doc.get("size"));
410. System.out.println("content:"+doc.get("content"));
411. System.out.println("-------------------------------------------");
412. }
413. 
414. searcher.close();
415. } catch (org.apache.lucene.queryParser.ParseException e) {
416. e.printStackTrace();
417. } catch (IOException e) {
418. e.printStackTrace();
419. }
420. }
421. 
422. /**
423. * 目前没有办法只取当前这页的数据，而是要全部查询然后得到docid
424. * 一种增加效率的方式是取的条数做下限制，比如不要每次都取500条，
425. * 也是把取的条数设置为当前页的所在位置数，比如每页10条，
426. * 取第一页数据则取10条，取第二页则取20条，取五页则去50条
427. * 根据页码和分页大小获取上一次的最后一个ScoreDoc
428. */
429. private ScoreDoc getLastScoreDoc(int pageIndex,int pageSize,Query query,IndexSearcher searcher) throws IOException {
430. if(pageIndex==1)return null;//如果是第一页就返回空
431. int num = pageSize*(pageIndex-1);//获取上一页的数量
432. TopDocs tds = searcher.search(query, num);
433. return tds.scoreDocs[num-1];
434. }
435. /**
436. * 使用这种方式的话是把上一页的最后一个元素给拿到，然后再把pagesize传入，
437. * 就可以得到当页的数据，其实就是简便了查询，原理还是把全部的docid查询后在得到document
438. * @param query
439. * @param pageIndex
440. * @param pageSize
441. */
442. public void searchPageByAfter(String query,int pageIndex,int pageSize) {
443. try {
444. Directory dir = FileIndexUtils.getDirectory();
445. IndexSearcher searcher = getSearcher(dir);
446. QueryParser parser = new QueryParser(Version.LUCENE_35,"content",analyzer);
447. Query q = parser.parse(query);
448. //先获取上一页的最后一个元素
449. ScoreDoc lastSd = getLastScoreDoc(pageIndex, pageSize, q, searcher);
450. //通过最后一个元素搜索下页的pageSize个元素
451. TopDocs tds = searcher.searchAfter(lastSd,q, pageSize);
452. printDocument(searcher, tds);
453. searcher.close();
454. } catch (org.apache.lucene.queryParser.ParseException e) {
455. e.printStackTrace();
456. } catch (IOException e) {
457. e.printStackTrace();
458. }
459. }
460. 
461. public void searchNoPage(String query) {
462. try {
463. Directory dir = FileIndexUtils.getDirectory();
464. IndexSearcher searcher = getSearcher(dir);
465. QueryParser parser = new QueryParser(Version.LUCENE_35,"content",new StandardAnalyzer(Version.LUCENE_35));
466. Query q = parser.parse(query);
467. TopDocs tds = searcher.search(q, 20);
468. ScoreDoc[] sds = tds.scoreDocs;
469. for(int i=0;i<sds.length;i++) {
470. Document doc = searcher.doc(sds[i].doc);
471. System.out.println(sds[i].doc+":"+doc.get("path")+"-->"+doc.get("filename"));
472. }
473. 
474. searcher.close();
475. } catch (org.apache.lucene.queryParser.ParseException e) {
476. e.printStackTrace();
477. } catch (IOException e) {
478. e.printStackTrace();
479. }
480. }
481. }
3、查询语法的测试单元类
[java] view plain copy
1. package org.itat.test;
2. 
3. import java.io.File;
4. import java.io.IOException;
5. import org.apache.commons.io.FileUtils;
6. import org.apache.commons.io.FilenameUtils;
7. import org.apache.lucene.analysis.Analyzer;
8. import org.apache.lucene.analysis.standard.StandardAnalyzer;
9. import org.apache.lucene.queryParser.ParseException;
10. import org.apache.lucene.queryParser.QueryParser;
11. import org.apache.lucene.search.Query;
12. import org.apache.lucene.util.Version;
13. import org.itat.index.FileIndexUtils;
14. import org.itat.index.SearcherUtil;
15. import org.junit.Before;
16. import org.junit.Test;
17. import org.wltea.analyzer.lucene.IKAnalyzer;
18. 
19. public class TestSearch {
20. private SearcherUtil su;
21. private Analyzer analyzer = new IKAnalyzer();
22. @Before
23. public void init() {
24. su = new SearcherUtil();
25. }
26. 
27. @Test
28. public void testCopyFiles() {
29. try {
30. File file = new File("F:\\Workspaces\\lucenes\\02_lucene_searcher\\resource");
31. for(File f:file.listFiles()) {
32. String destFileName = FilenameUtils.getFullPath(f.getAbsolutePath())+
33. FilenameUtils.getBaseName(f.getName())+".she";
34. FileUtils.copyFile(f, new File(destFileName));
35. }
36. } catch (IOException e) {
37. e.printStackTrace();
38. }
39. }
40. 
41. @Test
42. public void searchByTerm() {
43. // su.searchByTerm("content","",10);
44. su.searchByTermToken("content","头脑风暴",10);
45. }
46. 
47. @Test
48. public void searchByTermRange() {
49. //查询name以a开头和s结尾的
50. // su.searchByTermRange("name","a","s",10);
51. //由于attachs是数字类型，使用TermRange无法查询
52. // su.searchByTermRange("size",new NumericField("200").stringValue(),new NumericField("500").stringValue(), 10);
53. QueryParser parser = new QueryParser(Version.LUCENE_35, "size", analyzer);
54. Query query;
55. try {
56. query = parser.parse("size:[100 TO 500]");
57. su.searchByQueryParse(query, 10);
58. } catch (ParseException e) {
59. e.printStackTrace();
60. } 
61. }
62. 
63. @Test
64. public void searchByNumRange() {
65. // su.searchByNumricRange("attach",2,10, 5);
66. su.searchByNumricRange("size",100,300, 10);
67. }
68. 
69. @Test
70. public void searchByPrefix() {
71. su.searchByPrefix("content", "人", 10);
72. }
73. 
74. @Test
75. public void searchByWildcard() {
76. //匹配@itat.org结尾的所有字符
77. // su.searchByWildcard("email", "*@itat.org", 10);
78. //匹配j开头的有三个字符的name
79. // su.searchByWildcard("name", "j???", 10);
80. su.searchByWildcard("content", "类?", 10);
81. }
82. 
83. @Test
84. public void searchByBoolean() {
85. su.searchByBoolean(10);
86. }
87. 
88. @Test
89. public void searchByPhrase() {
90. su.searchByPhrase(10);
91. }
92. 
93. @Test
94. public void searchByFuzzy() {
95. su.searchByFuzzy(10);
96. }
97. 
98. @Test
99. public void searchByQueryParse() throws ParseException {
100. //1、创建QueryParser对象,默认搜索域为content
101. QueryParser parser = new QueryParser(Version.LUCENE_35, "content", new StandardAnalyzer(Version.LUCENE_35));
102. //改变空格的默认操作符，以下可以改成AND
103. //parser.setDefaultOperator(Operator.AND);
104. //开启第一个字符的通配符匹配，默认关闭因为效率不高
105. parser.setAllowLeadingWildcard(true);
106. //搜索content中包含有like的
107. Query query = parser.parse("like");
108. 
109. //有basketball或者football的，空格默认就是OR
110. query = parser.parse("basketball football");
111. 
112. //改变搜索域为name为mike
113. //query = parser.parse("content:like");
114. 
115. //同样可以使用*和?来进行通配符匹配
116. // query = parser.parse("name:j*");
117. 
118. //通配符默认不能放在首位
119. // query = parser.parse("email:*@itat.org");
120. 
121. //匹配name中没有mike但是content中必须有football的，+和-要放置到域说明前面
122. query = parser.parse("- name:mike + like");
123. 
124. //匹配一个区间，注意:TO必须是大写
125. //query = parser.parse("id:[1 TO 6]");
126. 
127. //闭区间匹配只会匹配到2
128. //query = parser.parse("id:{1 TO 3}");
129. 
130. //完全匹配I Like Football的
131. //query = parser.parse("\"I like football\"");
132. 
133. //匹配I 和football之间有一个单词距离的
134. //query = parser.parse("\"I football\"~1");
135. 
136. //模糊查询
137. //query = parser.parse("name:make~");
138. 
139. //没有办法匹配数字范围（自己扩展Parser）
140. //query = parser.parse("attach:[2 TO 10]");
141. su.searchByQueryParse(query, 10);
142. }
143. 
144. @Test
145. public void indexFile() {
146. FileIndexUtils.index(true);
147. }
148. 
149. @Test
150. public void testSearchPage01() {
151. su.searchPage("java", 2,5);
152. System.out.println("-------------------------------");
153. // su.searchNoPage("java");
154. su.searchPageByAfter("java", 2,2);
155. }
156. 
157. @Test
158. public void testSearchPage02() {
159. su.searchPageByAfter("java", 3,20);
160. }
161. 
162. }
4、创建索引的类
[java] view plain copy
1. package org.itat.index;
3. import java.io.File;
4. import java.io.FileReader;
5. import java.io.IOException;
6. import org.apache.commons.io.FileUtils;
7. import org.apache.lucene.analysis.Analyzer;
8. import org.apache.lucene.analysis.standard.StandardAnalyzer;
9. import org.apache.lucene.document.Document;
10. import org.apache.lucene.document.Field;
11. import org.apache.lucene.document.NumericField;
12. import org.apache.lucene.index.CorruptIndexException;
13. import org.apache.lucene.index.IndexWriter;
14. import org.apache.lucene.index.IndexWriterConfig;
15. import org.apache.lucene.store.Directory;
16. import org.apache.lucene.store.FSDirectory;
17. import org.apache.lucene.store.LockObtainFailedException;
18. import org.apache.lucene.util.Version;
19. import org.wltea.analyzer.lucene.IKAnalyzer;
21. public class FileIndexUtils {
22. private static Directory directory = null;
23. private static Analyzer analyzer = new IKAnalyzer();
24. static{
25. try {
26. directory = FSDirectory.open(new File("F:\\Workspaces\\lucenes\\02_lucene_searcher\\index"));
27. } catch (IOException e) {
28. e.printStackTrace();
29. }
30. }
32. public static Directory getDirectory() {
33. return directory;
34. }
36. public static void index(boolean hasNew) {
37. IndexWriter writer = null;
38. try {
39. writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, analyzer));
40. if(hasNew) {
41. writer.deleteAll();
42. }
43. File file = new File("F:\\Workspaces\\lucenes\\02_lucene_searcher\\resource");
44. Document doc = null;
45. for(File f:file.listFiles()) {
46. doc = new Document();
47. doc.add(new Field("content",FileUtils.readFileToString(f),Field.Store.YES,Field.Index.ANALYZED));
48. doc.add(new Field("filename",f.getName(),Field.Store.YES,Field.Index.ANALYZED));
49. doc.add(new Field("path",f.getAbsolutePath(),Field.Store.YES,Field.Index.ANALYZED));
50. doc.add(new NumericField("date",Field.Store.YES,true).setLongValue(f.lastModified()));
51. doc.add(new NumericField("size",Field.Store.YES,true).setIntValue((int)(f.length())));
52. writer.addDocument(doc);
53. }
54. } catch (CorruptIndexException e) {
55. e.printStackTrace();
56. } catch (LockObtainFailedException e) {
57. e.printStackTrace();
58. } catch (IOException e) {
59. e.printStackTrace();
60. } finally {
61. try {
62. if(writer!=null) writer.close();
63. } catch (CorruptIndexException e) {
64. e.printStackTrace();
65. } catch (IOException e) {
66. e.printStackTrace();
67. }
68. }
69. }
70. }
5、对索引进行操作的类
[java] view plain copy
相关阅读:
Docker和K8S
CoBot 库博源代码缺陷检测工具
 Hobot软件成分分析平台
 Black duck(黑鸭子软件)开源代码审计管理测试平台
 python之理解super及MRO列表
 Python中MRO排序原理
 python中with的用法
 使用微服务架构重构支付网关
 支付网关的设计原则
 python内存管理--垃圾回收
原文地址：https://www.cnblogs.com/zwb7926/p/3115611.html