lucene---查询

╰+攻爆jí腚メ 2022-08-23 00:48 116阅读 0赞

Java代码    ![收藏代码][icon_star.png]

1.  **package** demo.first;  
2.    
3.  **import** java.io.\*;  
4.  **import** java.util.Date;  
5.    
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.IndexWriter;  
10. **import** org.apache.lucene.index.Term;  
11. **import** org.apache.lucene.queryParser.QueryParser;  
12. **import** org.apache.lucene.search.BooleanClause;  
13. **import** org.apache.lucene.search.BooleanQuery;  
14. **import** org.apache.lucene.search.Hits;  
15. **import** org.apache.lucene.search.IndexSearcher;  
16. **import** org.apache.lucene.search.PhraseQuery;  
17. **import** org.apache.lucene.search.Query;  
18. **import** org.apache.lucene.search.RangeQuery;  
19. **import** org.apache.lucene.search.TermQuery;  
20. **import** org.apache.lucene.search.WildcardQuery;  
21.   
22. **public** **class** Search \{  
23.   
24.     Date startTime,endTime;  
25.       
26.     /\*\* 
27.      \* 索引文件的存放位置 
28.      \*/  
29.     String path = "D://workspace//fwk//lucenedemo//firstLuceneIndex";  
30.       
31.     /\*\* 
32.      \* 创建索引 
33.      \*/  
34.     **public** **void** createLuceneIndex()\{  
35.         IndexWriter writer;  
36.         **try** \{  
37.             writer = **new** IndexWriter(path,**new** StandardAnalyzer(),**true**);  
38.             Document docA = **new** Document();  
39.             //相当于数据库中列的概念，因此第一个参数是列名，第二个参数是列的值，最后两个参数是enum类型的(JDK1.5)，对创建的索引的设置  
40.             //Field.Store 是否覆盖原来的索引文件，而不是重新建一个  
41.             Field fieldA = **new** Field("content","搜索引擎",Field.Store.YES,Field.Index.TOKENIZED);  
42.             //我们把列(fieldA)加到某一行(docA)中  
43.             docA.add(fieldA);  
44.             //英文 测试  
45.             docA.add(**new** Field("content","hello llying ,I love you",Field.Store.YES,Field.Index.TOKENIZED));  
46.             docA.add(**new** Field("lastModifyTime","2010个人",Field.Store.YES,Field.Index.TOKENIZED));  
47.               
48.             Document docB = **new** Document();  
49.             //相当于数据库中列的概念，因此第一个参数是列名，第二个参数是列的值，最后两个参数是enum类型的(JDK1.5)，对创建的索引的设置  
50.             Field fieldB = **new** Field("content","创建索引",Field.Store.YES,Field.Index.TOKENIZED);  
51.             //我们把列(fieldA)加到某一行(docA)中  
52.             docB.add(fieldB);  
53.             docB.add(**new** Field("content","i live in shanghai.i come from cn",Field.Store.YES,Field.Index.TOKENIZED));  
54.             docB.add(**new** Field("lastModifyTime","2020个人",Field.Store.YES,Field.Index.TOKENIZED));  
55.               
56.             writer.addDocument(docA);  
57.             writer.addDocument(docB);  
58.               
59.             //如果对海量数据进行创建索引的时候，需要对索引进行优化，以便提高速度  
60.             writer.optimize();  
61.               
62.             //跟数据库类似，打开一个连接，使用完后，要关闭它  
63.             writer.close();  
64.               
65.         \} **catch** (Exception e) \{  
66.             e.printStackTrace();  
67.         \}   
68.     \}  
69.       
70.     /\*\* 
71.      \* 创建文件索引 
72.      \*/  
73.     **public** **void** createIndexByFile()\{  
74.         IndexWriter writer;  
75.         **try** \{  
76.               
77.             String filePath = "D://workspace//fwk//lucenedemo//firstLuceneIndex//test.txt";  
78.             String content = file2String(filePath, "GBK");  
79.               
80.             //System.out.println(content);  
81.               
82.             writer = **new** IndexWriter(path,**new** StandardAnalyzer(),**true**);  
83.               
84.             Document docA = **new** Document();  
85.               
86.             Field fieldA = **new** Field("content",content,Field.Store.YES,Field.Index.TOKENIZED);  
87.             docA.add(**new** Field("path",filePath,Field.Store.YES,Field.Index.UN\_TOKENIZED));  
88.             docA.add(fieldA);  
89.               
90.             writer.addDocument(docA);  
91.               
92.             //如果对海量数据进行创建索引的时候，需要对索引进行优化，以便提高速度  
93.             writer.optimize();  
94.               
95.             //跟数据库类似，打开一个连接，使用完后，要关闭它  
96.             writer.close();  
97.               
98.         \} **catch** (Exception e) \{  
99.             e.printStackTrace();  
100.         \}   
101.     \}  
102.       
103.     **private** String file2String(String fileName,String charset) **throws** Exception\{  
104.         BufferedReader reader = **new** BufferedReader(**new** InputStreamReader(**new** FileInputStream(fileName),charset));  
105.         //StringBuilder ,StringBuffer  
106.         StringBuilder builder = **new** StringBuilder();  
107.         String line = **null**;  
108.         **while**((line = reader.readLine())!=**null**)\{  
109.             builder.append(line);  
110.         \}  
111.         **return** builder.toString();  
112.     \}  
113.       
114.     /\*\* 
115.      \* 相当于sql中where 后面的条件，WildcardQuery不推荐大家使用 
116.      \* 通配符搜索 
117.      \*/  
118.     **private** Query wildcardQuery()\{  
119.         // where username = '张xiangqiang' and password='ILoveChina'  
120.         //?代表至少有一个字符在前面  
121.         //搜索"\*搜\*"，找到一条数据；搜索"\*索\*"，找到两条数据；搜索"\*搜索\*"，找到0条数据；搜索"\*索引\*"，找到0条数据；  
122.         //为什么是这样的结果呢？流行伏笔  
123.         Term term = **new** Term("content","\*c\*");  
124.         **return** **new** WildcardQuery(term);  
125.     \}  
126.       
127.     //基于lucene的分词 -- TermQuery只能对当个中文进行搜索。英文只能对当个单词进行搜索  
128.     **public** Query termQuery()\{  
129.         Term term = **new** Term("content","19:58:25");  
130.         **return** **new** TermQuery(term);  
131.     \}  
132.     /\*\* 
133.      \* 智能搜索 
134.      \*  
135.      \* @return 
136.      \*/  
137.     **public** Query queryParser()\{  
138.         QueryParser queryParser = **new** QueryParser("content", **new** StandardAnalyzer());  
139.         **try** \{  
140.             **return** queryParser.parse("搜索 - 擎");  
141.         \} **catch** (Exception e) \{  
142.             e.printStackTrace();  
143.         \}  
144.         **return** **null**;  
145.     \}  
146.     /\*\* 
147.      \* '与或'--搜索 
148.      \* @return 
149.      \*/  
150.     **public** Query booleanQuery()\{  
151.         Term term1 = **new** Term("content","索");  
152.         Term term2 = **new** Term("content","搜");  
153.           
154.         TermQuery tempQuery1 =  **new** TermQuery(term1);  
155.         TermQuery tempQuery2 =  **new** TermQuery(term2);  
156.           
157.         //本人觉得他更应该叫做JoinQuery   
158.         BooleanQuery booleanQuery = **new** BooleanQuery();  
159.         booleanQuery.add(tempQuery1,BooleanClause.Occur.MUST);  
160.         booleanQuery.add(tempQuery2,BooleanClause.Occur.SHOULD);  
161.         **return** booleanQuery;  
162.     \}  
163.     /\*\* 
164.      \* 多关键词搜索 
165.      \* @return 
166.      \*/  
167.     **public** Query phraseQuery()\{  
168.         PhraseQuery phraseQuery = **new** PhraseQuery();  
169.         phraseQuery.setSlop(1);  
170.         phraseQuery.add(**new** Term("content","搜"));  
171.         phraseQuery.add(**new** Term("content","擎"));  
172.         **return** phraseQuery;  
173.     \}  
174.     /\*\* 
175.      \* 范围搜索 
176.      \* @return 
177.      \*/  
178.     **public** Query rangeQuery()\{  
179.         RangeQuery rangeQuery = **new** RangeQuery(**new** Term("lastModifyTime","20000808"),**new** Term("lastModifyTime","20150808"), **true**);  
180.         **return** rangeQuery;  
181.     \}  
182.       
183.     **public** **void** search()\{  
184.         **try** \{  
185.             //相当于sql中的 select \* from talbeName   
186.             IndexSearcher search = **new** IndexSearcher(path);  
187.               
188.             startTime = **new** Date();  
189.             //抽象的查询对象  
190.             Query query = queryParser();  
191.             //Query query = phraseQuery();  
192.             //搜索结果集Hits，和JDBC的查询结果集完全类似的概念 -- 为什么是这样的呢？  
193.             //lucene在设计的时候，就参照了JDBC的很多概念  
194.             Hits hits = search.search(query);  
195.             **for** (**int** i = 0; i < hits.length(); i++) \{  
196.                 System.out.println(hits.id(i));  
197.                 System.out.println(hits.doc(i));  
198.                 System.out.println(hits.score(i));  
199.             \}  
200.             endTime = **new** Date();  
201.               
202.             System.out.println("本次搜索用时：" + (endTime.getTime() - startTime.getTime()) + "毫秒");  
203.               
204.         \} **catch** (Exception e) \{  
205.             e.printStackTrace();  
206.         \}  
207.     \}  
208.       
209.       
210.       
211.   
212.       
213.     /\*\* 
214.      \* @param args 
215.      \*/  
216.     **public** **static** **void** main(String\[\] args) \{  
217.         Search search = **new** Search();  
218.         //search.createLuceneIndex();  
219.         search.createIndexByFile();  
220.           
221.         search.search();  
222.   
223.     \}  
224.   
225. \}

[icon_star.png]: /images/20220722/5cf7fd4be1af4b89a31c8a96af546d9d.png