Lucene 3.6 中文分词、分页查询、高亮显示等

lucene-analyzers-3.6.1.jar 实现中文分词的lucene-analyzers-3.6.1.jar的jar 包 立即下载

1、准备工作

下载lucene 3.6.1 : http://lucene.apache.org/ 

下载中文分词IK Analyzer: http://code.google.com/p/ik-analyzer/downloads/list (注意下载的是IK Analyzer 2012_u5_source.zip,其他版本有bug) 

下载solr 3.6.1:  http://lucene.apache.org/solr/(编译IK Analyzer时需引用包) 

OK,将lucene 、solr 相关包(lucene-core-3.6.1.jar、lucene-highlighter-3.6.1.jar、lucene-analyzers-3.6.1.jar、apache-solr-core-3.6.1.jar、apache-solr-solrj-3.6.1.jar)拷贝到项目lib下,IK源码置于项目src下。

2、从Oracle数据库中取数据创建索引(使用IK分词)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package lucene.util;
 
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.Directory;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.util.Version;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.wltea.analyzer.lucene.IKAnalyzer;
 
import java.sql.Connection;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
 
import modules.gk.Gk_info;
import modules.gk.Gk_infoSub;
import web.sys.Globals;
import web.db.DBConnector;
import web.db.ObjectCtl;
import web.util.StringUtil;
//Wizzer.cn
public class LuceneIndex {
     IndexWriter writer =  null ;
     FSDirectory dir =  null ;
     boolean create =  true ;
 
     public void init() {
         long a1 = System.currentTimeMillis();
         System.out.println( "[Lucene 开始执行:" +  new Date() +  "]" );
         Connection con = DBConnector.getconecttion();  //取得一个数据库连接
         try {
             final File docDir =  new File(Globals.SYS_COM_CONFIG.get( "sys.index.path" ).toString()); //E:\lucene
             if (!docDir.exists()) {
                 docDir.mkdirs();
             }
             String cr = Globals.SYS_COM_CONFIG.get( "sys.index.create" ).toString(); //true or false
             if ( "false" .equals(cr.toLowerCase())) {
                 create =  false ;
             }
             Directory dir = FSDirectory.open(docDir);
//            Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_36);
             Analyzer analyzer =  new IKAnalyzer( true );
             IndexWriterConfig iwc =  new IndexWriterConfig(Version.LUCENE_36, analyzer);
             if (create) {
                 // Create a new index in the directory, removing any
                 // previously indexed documents:
                 iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
             }  else {
                 // Add new documents to an existing index:
                 iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
             }
             IndexWriter writer =  new IndexWriter(dir, iwc);
             String sql =  "SELECT indexno,title,describes,pdate,keywords FROM TABLEA WHERE STATE=1 AND SSTAG<>1 " ;
             int rowCount = ObjectCtl.getRowCount(con, sql);
             int pageSize = StringUtil.StringToInt(Globals.SYS_COM_CONFIG.get( "sys.index.size" ).toString());    //每页记录数
             int pages = (rowCount -  1 ) / pageSize +  1 ;  //计算总页数
             ArrayList list =  null ;
             Gk_infoSub gk =  null ;
             for ( int i =  1 ; i < pages+ 1 ; i++) {
                 long a = System.currentTimeMillis();
                 list = ObjectCtl.listPage(con, sql, i, pageSize,  new Gk_infoSub());
                 for ( int j =  0 ; j < list.size(); j++) {
                     gk = (Gk_infoSub) list.get(j);
                     Document doc =  new Document();
                     doc.add( new Field( "indexno" , StringUtil.null2String(gk.getIndexno()), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS)); //主键不分词
                     doc.add( new Field( "title" , StringUtil.null2String(gk.getTitle()), Field.Store.YES, Field.Index.ANALYZED));
                     doc.add( new Field( "describes" , StringUtil.null2String(gk.getDescribes()), Field.Store.YES, Field.Index.ANALYZED));
                     doc.add( new Field( "pdate" , StringUtil.null2String(gk.getPdate()), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS)); //日期不分词
                     doc.add( new Field( "keywords" , StringUtil.null2String(gk.getKeywords()), Field.Store.YES, Field.Index.ANALYZED));
                     writer.addDocument(doc);
                     ObjectCtl.executeUpdateBySql(con, "UPDATE TABLEA SET SSTAG=1 WHERE indexno='" +gk.getIndexno()+ "'" ); //更新已索引状态
                 }
 
                 long b = System.currentTimeMillis();
                 long c = b - a;
                 System.out.println( "[Lucene " + rowCount +  "条," + pages +  "页,第" + i +  "页花费时间:" + c +  "毫秒]" );
             }
             writer.commit();
 
         }  catch (Exception e) {
             e.printStackTrace();
         }  finally {
             DBConnector.freecon(con);  //释放数据库连接
             try {
                 if (writer !=  null ) {
                     writer.close();
                 }
             }  catch (CorruptIndexException e) {
                 e.printStackTrace();
             }  catch (IOException e) {
                 e.printStackTrace();
             }  finally {
                 try {
                     if (dir !=  null && IndexWriter.isLocked(dir)) {
                         IndexWriter.unlock(dir); //注意解锁
                     }
                 }  catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         long b1 = System.currentTimeMillis();
         long c1 = b1 - a1;
         System.out.println( "[Lucene 执行完毕,花费时间:" + c1 +  "毫秒,完成时间:" +  new Date() +  "]" );
     }
}
 

3、单字段查询以及多字段分页查询高亮显示

 
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
package lucene.util;
 
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.Directory;
import org.apache.lucene.search.*;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.KeywordAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.util.Version;
import modules.gk.Gk_infoSub;
 
import java.util.ArrayList;
import java.io.File;
import java.io.StringReader;
import java.lang.reflect.Constructor;
 
import web.util.StringUtil;
import web.sys.Globals;
import org.wltea.analyzer.lucene.IKAnalyzer;
//Wizzer.cn
public class LuceneQuery {
     private static String indexPath; // 索引生成的目录
     private int rowCount; // 记录数
     private int pages; // 总页数
     private int currentPage; // 当前页数
     private int pageSize;    //每页记录数
 
     public LuceneQuery() {
         this .indexPath = Globals.SYS_COM_CONFIG.get( "sys.index.path" ).toString();
     }
 
     public int getRowCount() {
         return rowCount;
     }
 
     public int getPages() {
         return pages;
     }
 
     public int getPageSize() {
         return pageSize;
     }
 
     public int getCurrentPage() {
         return currentPage;
     }
 
     /**
      * 函数功能:根据字段查询索引
      */
     public ArrayList queryIndexTitle(String keyWord,  int curpage,  int pageSize) {
         ArrayList list =  new ArrayList();
         try {
             if (curpage <=  0 ) {
                 curpage =  1 ;
             }
             if (pageSize <=  0 ) {
                 pageSize =  20 ;
             }
             this .pageSize = pageSize;    //每页记录数
             this .currentPage = curpage;    //当前页
             int start = (curpage -  1 ) * pageSize;
             Directory dir = FSDirectory.open( new File(indexPath));
             IndexReader reader = IndexReader.open(dir);
             IndexSearcher searcher =  new IndexSearcher(reader);
             Analyzer analyzer =  new IKAnalyzer( true );
             QueryParser queryParser =  new QueryParser(Version.LUCENE_36,  "title" , analyzer);
             queryParser.setDefaultOperator(QueryParser.AND_OPERATOR);
             Query query = queryParser.parse(keyWord);
             int hm = start + pageSize;
             TopScoreDocCollector res = TopScoreDocCollector.create(hm,  false );
             searcher.search(query, res);
 
             SimpleHTMLFormatter simpleHTMLFormatter =  new SimpleHTMLFormatter( "<span style='color:red'>" ,  "</span>" );
             Highlighter highlighter =  new Highlighter(simpleHTMLFormatter,  new QueryScorer(query));
             this .rowCount = res.getTotalHits();
             this .pages = (rowCount -  1 ) / pageSize +  1 ;  //计算总页数
             TopDocs tds = res.topDocs(start, pageSize);
             ScoreDoc[] sd = tds.scoreDocs;
             for ( int i =  0 ; i < sd.length; i++) {
                 Document hitDoc = reader.document(sd[i].doc);
                 list.add(createObj(hitDoc, analyzer, highlighter));
             }
 
         }  catch (Exception e) {
             e.printStackTrace();
         }
 
         return list;
 
     }
     /**
      * 函数功能:根据字段查询索引
      */
     public ArrayList queryIndexFields(String allkeyword, String onekeyword, String nokeyword,  int curpage,  int pageSize) {
         ArrayList list =  new ArrayList();
         try {
             if (curpage <=  0 ) {
                 curpage =  1 ;
             }
             if (pageSize <=  0 ) {
                 pageSize =  20 ;
             }
             this .pageSize = pageSize;    //每页记录数
             this .currentPage = curpage;    //当前页
             int start = (curpage -  1 ) * pageSize;
             Directory dir = FSDirectory.open( new File(indexPath));
             IndexReader reader = IndexReader.open(dir);
             IndexSearcher searcher =  new IndexSearcher(reader);
             BooleanQuery bQuery =  new BooleanQuery();   //组合查询
             if (! "" .equals(allkeyword)) { //包含全部关键词
                 KeywordAnalyzer analyzer =  new KeywordAnalyzer();
                 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD}; //AND
                 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, allkeyword,  new String[]{ "title" ,  "describes" ,  "keywords" }, flags, analyzer);
                 bQuery.add(query, BooleanClause.Occur.MUST);   //AND
             }
             if (! "" .equals(onekeyword)) {  //包含任意关键词
                 Analyzer analyzer =  new IKAnalyzer( true );
                 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD}; //OR
                 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, onekeyword,  new String[]{ "title" ,  "describes" ,  "keywords" }, flags, analyzer);
                 bQuery.add(query, BooleanClause.Occur.MUST);   //AND
             }
             if (! "" .equals(nokeyword)) {  //排除关键词
                 Analyzer analyzer =  new IKAnalyzer( true );
                 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD}; //NOT
                 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, nokeyword,  new String[]{ "title" ,  "describes" ,  "keywords" }, flags, analyzer);
                 bQuery.add(query, BooleanClause.Occur.MUST_NOT);   //AND
 
             }
             int hm = start + pageSize;
             TopScoreDocCollector res = TopScoreDocCollector.create(hm,  false );
             searcher.search(bQuery, res);
             SimpleHTMLFormatter simpleHTMLFormatter =  new SimpleHTMLFormatter( "<span style='color:red'>" ,  "</span>" );
             Highlighter highlighter =  new Highlighter(simpleHTMLFormatter,  new QueryScorer(bQuery));
             this .rowCount = res.getTotalHits();
             this .pages = (rowCount -  1 ) / pageSize +  1 ;  //计算总页数
             System.out.println( "rowCount:" + rowCount);
             TopDocs tds = res.topDocs(start, pageSize);
             ScoreDoc[] sd = tds.scoreDocs;
             Analyzer analyzer =  new IKAnalyzer();
             for ( int i =  0 ; i < sd.length; i++) {
                 Document hitDoc = reader.document(sd[i].doc);
                 list.add(createObj(hitDoc, analyzer, highlighter));
             }
 
         }  catch (Exception e) {
             e.printStackTrace();
         }
 
         return list;
 
     }
 
     /**
      * 创建返回对象(高亮)
      */
 
     private synchronized static Object createObj(Document doc, Analyzer analyzer, Highlighter highlighter) {
 
         Gk_infoSub gk =  new Gk_infoSub();
         try {
 
             if (doc !=  null ) {
                 gk.setIndexno(StringUtil.null2String(doc.get( "indexno" )));
                 gk.setPdate(StringUtil.null2String(doc.get( "pdate" )));
                 String title = StringUtil.null2String(doc.get( "title" ));
                 gk.setTitle(title);
                 if (! "" .equals(title)) {
                     highlighter.setTextFragmenter( new SimpleFragmenter(title.length()));
                     TokenStream tk = analyzer.tokenStream( "title" ,  new StringReader(title));
                     String htext = StringUtil.null2String(highlighter.getBestFragment(tk, title));
                     if (! "" .equals(htext)) {
                         gk.setTitle(htext);
                     }
                 }
                 String keywords = StringUtil.null2String(doc.get( "keywords" ));
                 gk.setKeywords(keywords);
                 if (! "" .equals(keywords)) {
                     highlighter.setTextFragmenter( new SimpleFragmenter(keywords.length()));
                     TokenStream tk = analyzer.tokenStream( "keywords" ,  new StringReader(keywords));
                     String htext = StringUtil.null2String(highlighter.getBestFragment(tk, keywords));
                     if (! "" .equals(htext)) {
                         gk.setKeywords(htext);
                     }
                 }
                 String describes = StringUtil.null2String(doc.get( "describes" ));
                 gk.setDescribes(describes);
                 if (! "" .equals(describes)) {
                     highlighter.setTextFragmenter( new SimpleFragmenter(describes.length()));
                     TokenStream tk = analyzer.tokenStream( "keywords" ,  new StringReader(describes));
                     String htext = StringUtil.null2String(highlighter.getBestFragment(tk, describes));
                     if (! "" .equals(htext)) {
                         gk.setDescribes(htext);
                     }
                 }
 
             }
             return gk;
         }
         catch (Exception e) {
 
             e.printStackTrace();
             return null ;
         }
         finally {
             gk =  null ;
         }
 
     }
 
     private synchronized static Object createObj(Document doc) {
 
         Gk_infoSub gk =  new Gk_infoSub();
         try {
 
             if (doc !=  null ) {
                 gk.setIndexno(StringUtil.null2String(doc.get( "indexno" )));
                 gk.setPdate(StringUtil.null2String(doc.get( "pdate" )));
                 gk.setTitle(StringUtil.null2String(doc.get( "title" )));
                 gk.setKeywords(StringUtil.null2String(doc.get( "keywords" )));
                 gk.setDescribes(StringUtil.null2String(doc.get( "describes" )));
             }
             return gk;
         }
         catch (Exception e) {
 
             e.printStackTrace();
             return null ;
         }
         finally {
             gk =  null ;
         }
 
     }
}
  单字段查询:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
long a = System.currentTimeMillis();
try {
     int curpage = StringUtil.StringToInt(StringUtil.null2String(form.get( "curpage" )));
     int pagesize = StringUtil.StringToInt(StringUtil.null2String(form.get( "pagesize" )));
     String title = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get( "title" )));
     LuceneQuery lu =  new LuceneQuery();
     form.addResult( "list" , lu.queryIndexTitle(title, curpage, pagesize));
     form.addResult( "curPage" , lu.getCurrentPage());
     form.addResult( "pageSize" , lu.getPageSize());
     form.addResult( "rowCount" , lu.getRowCount());
     form.addResult( "pageCount" , lu.getPages());
}  catch (Exception e) {
     e.printStackTrace();
}
long b = System.currentTimeMillis();
long c = b - a;
System.out.println( "[搜索信息花费时间:" + c +  "毫秒]" );
多字段查询:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
long a = System.currentTimeMillis();
try {
     int curpage = StringUtil.StringToInt(StringUtil.null2String(form.get( "curpage" )));
     int pagesize = StringUtil.StringToInt(StringUtil.null2String(form.get( "pagesize" )));
     String allkeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get( "allkeyword" )));
     String onekeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get( "onekeyword" )));
     String nokeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get( "nokeyword" )));
     LuceneQuery lu =  new LuceneQuery();
     form.addResult( "list" , lu.queryIndexFields(allkeyword,onekeyword,nokeyword, curpage, pagesize));
     form.addResult( "curPage" , lu.getCurrentPage());
     form.addResult( "pageSize" , lu.getPageSize());
     form.addResult( "rowCount" , lu.getRowCount());
     form.addResult( "pageCount" , lu.getPages());
}  catch (Exception e) {
     e.printStackTrace();
}
long b = System.currentTimeMillis();
long c = b - a;
System.out.println( "[高级检索花费时间:" + c +  "毫秒]" );

4、Lucene通配符查询

?
1
2
3
4
5
6
7
8
9
BooleanQuery bQuery =  new BooleanQuery();   //组合查询
if (! "" .equals(title)) {
     WildcardQuery w1 =  new WildcardQuery( new Term( "title" , title+  "*" ));
 
     bQuery.add(w1, BooleanClause.Occur.MUST);   //AND
}
int hm = start + pageSize;
TopScoreDocCollector res = TopScoreDocCollector.create(hm,  false );
searcher.search(bQuery, res);
 

5、Lucene嵌套查询

实现SQL:(unitid like 'unitid%'  and idml like 'id2%') or (tounitid like 'unitid%' and tomlid like 'id2%' and tostate=1)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
BooleanQuery bQuery =  new BooleanQuery();
BooleanQuery b1 =  new BooleanQuery();
WildcardQuery w1 =  new WildcardQuery( new Term( "unitid" , unitid +  "*" ));
WildcardQuery w2 =  new WildcardQuery( new Term( "idml" , id2 +  "*" ));
b1.add(w1, BooleanClause.Occur.MUST); //AND
b1.add(w2, BooleanClause.Occur.MUST); //AND
bQuery.add(b1, BooleanClause.Occur.SHOULD); //OR
BooleanQuery b2 =  new BooleanQuery();
WildcardQuery w3 =  new WildcardQuery( new Term( "tounitid" , unitid +  "*" ));
WildcardQuery w4 =  new WildcardQuery( new Term( "tomlid" , id2 +  "*" ));
WildcardQuery w5 =  new WildcardQuery( new Term( "tostate" ,  "1" ));
b2.add(w3, BooleanClause.Occur.MUST); //AND
b2.add(w4, BooleanClause.Occur.MUST); //AND
b2.add(w5, BooleanClause.Occur.MUST); //AND
bQuery.add(b2, BooleanClause.Occur.SHOULD); //OR

6、Lucene先根据时间排序后分页

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int hm = start + pageSize;
Sort sort =  new Sort( new SortField( "pdate" , SortField.STRING,  true ));
TopScoreDocCollector res = TopScoreDocCollector.create(pageSize,  false );
searcher.search(bQuery, res);
this .rowCount = res.getTotalHits();
this .pages = (rowCount -  1 ) / pageSize +  1 ;  //计算总页数
TopDocs tds =searcher.search(bQuery,rowCount,sort); // res.topDocs(start, pageSize);
ScoreDoc[] sd = tds.scoreDocs;
System.out.println( "rowCount:" + rowCount);
int i= 0 ;
for (ScoreDoc scoreDoc : sd) {
     i++;
     if (i<start){
         continue ;
     }
     if (i>hm){
         break ;
     }
     Document doc = searcher.doc(scoreDoc.doc);
     list.add(createObj(doc));
}
这个效率不高,正常的做饭是创建索引的时候进行排序,之后使用分页方法,不要这样进行2次查询。
lucene-analyzers-3.6.2.jar lucene-analyzers-3.6.2.jar包,需要的领走 立即下载

相关推荐

lucene-analyzers-common

一个简单的ext java web项目 有gird form tree boder布局 如果有人觉的有用,会继续完善

lucene2.4+nutch学习笔记三:lucene 在多个文本文档里找出包含一些关键字的文档...

     1运行环境lucene2.4.1,下载地址:http://apache.etoak.com/lucene/java/lucene-2.4.1.zip      2Lucene 简介 (文档参照http://www.ibm.com/developerworks/cn/java/j-lo-lucene1/ )      Lucene 是一个基于 Java 的全文信息检索工具包...

lifeneedyou的专栏 210

lucene3.6.1 所需jar整合包

lucene3.6.1 所需jar整合包里面包括 lucene-highlighter-3.6.1.jar lucene-core-3.6.0.jar lucene-analyzers-3.6.1.jar IKAnalyzer2012_u6.jar

Lucene的多域查询、结果中查询、查询结果分页、高亮查询结果和结果评分

1.针对多个域的一次性查询 1.1.三种方案         使用lucene构造搜索引擎的时候,如果要针对多个域进行一次性查询,一般来说有三种方法:     第一种实现方法是创建多值的全包含域的文本进行索引,这个方案最简单。但是这个防范有个缺点:你不能直接对每个域的加权进行控制。     第二种方法是使用MultiFieldQueryParser,它是QueryParser的子类,它会在

Huhui's Blog 7568

lucene-analyzers-smartcn-5.2.1.jar Smart Jar包

lucene-analyzers-smartcn-5.2.1.jar Smart Jar包,在Solr中的使用参考http://blog.csdn.net/xuxiuning/article/details/47750701

org.wltea.analyzer.lucene.IKAnalyzer jar

solr的IK分词器JAR及配置文件 jar包和配置文件的放置位置不一样,详情可搜索 IK Analyzer 是一个开源的,基于java语言开发的轻量级的中文分词工具包。 org.wltea.analyzer.lucene.IKAnalyzer jar

lucene的使用

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34392906的博客 139

【学习笔记】一文搞懂IEPE传感器

本文介绍了IEPE(集成电路压电式)传感器的工作原理及其在振动监测中的应用。通过压电效应原理,IEPE传感器将机械振动转换为电信号,内置电荷放大器将高阻抗电荷信号转换为低阻抗电压信号输出。还介绍了传感器的三轴测量结构、4mA恒流源供电机制以及灵敏度与量程的关系,并通过风扇实验演示了故障诊断过程。实验使用USB-3123采集卡和SRD-1104信号调理器,展示了正常与异常状态下的振动数据差异,验证了IEPE传感器在设备状态监测中的有效性。

m0_62969865的博客 2816

Lucene开发实例教程:Lucene中文分词、分页查询、高亮显示

1、准备工作 下载lucene 3.6.1 : http://lucene.apache.org/ 下载中文分词IK Analyzer: http://code.google.com/p/ik-analyzer/downloads/list (注意下载的是IK Analyzer 2012_u5_source.zip,其他版本有bug) 下载solr 3.6.1:  h

北风网IT 1109

C# 实现鼠标轨迹录制与回放自动化功能(附源码)

通过本文的介绍,相信大家已经掌握了鼠标轨迹录制与回放功能的实现方式。该功能在自动化测试和重复性工作中具有重要应用价值。后续可以进一步优化,增加更多扩展功能,形成一个完整的自动化工具。

weixin_72139050的博客 1755

从零构建个人知识库:Obsidian与Git实践打造可生长的第二大脑

在信息爆炸的时代,如何有效管理个人知识资产,构建一个可检索、可关联、可生长的个人知识库,成为提升学习效率和创造力的关键。其核心原理在于通过系统化的信息架构与工作流设计,将碎片化信息转化为结构化的知识网络。从技术价值看,这不仅是笔记方法的升级,更是个人知识管理(PKM)和思维模式的革新,能有效对抗信息过载与知识孤岛。实践中,以Obsidian为代表的本地Markdown笔记软件,结合双向链接和关系图谱功能,为知识网络的构建提供了强大支撑;而引入Git进行版本控制,则确保了知识资产的历史可追溯性与安全备份。这种

weixin_28836989的博客 302

2020最全的Lucene7 入门教程

搜索引擎技术系列教材 (一)- lucene - Lucene7 入门步骤1:关于JDK版本至少使用JDK8版本,请下载JDK8或者更高版本:下载以及配置JDK环境步骤2:Lucene 概念Lucene 这个开源项目,使得 Java开发人员可以很方便地得到像搜索引擎google baidu那样的搜索效果。步骤3:先运行,看到效果,再学习老规矩,先下载下载区(...

java_zdc的博客 830

告别以太网瓶颈:手把手教你为AI训练集群搭建InfiniBand网络(以NVIDIA DGX A100/H100为例)

本文详细指导如何为AI训练集群搭建InfiniBand网络,解决以太网瓶颈问题,特别针对NVIDIA DGX A100/H100系统。通过硬件选型、网络架构设计和性能调优,显著提升多机多卡训练效率,适用于大规模模型训练场景。

weixin_30336061的博客 309

lucene实现分页,排序,分词器分词的关键字高亮显示

1. 首先需要导包 需要导入lucene包,还有中文分词器ik包,还有高亮显示包 package com.ouhuizhong.search.lucene处理分页和排序; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Document; import org.apache.lu...

ouhuizhong的博客 205

微信小程序视频内容服务类目审核不过?绕过审核的两种思路!

虽然不推荐绕过官方审核,但在实际项目中,总有一些特殊情况:比如,最近开发的小程序涉及视频播放,提交审核时,被官方要求补充“教育服务 - 在线视频课程”类目。但我们的内容只是车辆使用介绍,并非教育课程,无法提供相应资质。该怎么办?很多开发者发现,小程序开发不是最难的,审核才是最难的。 微信为了规避法律风险,要求某些功能必须提供资质。例如:然而,并不是所有公司都能轻松申请到这些资质,甚至有些资质根本不适用于我们的业务,导致审核卡住,无法上线。就像我遇到的这个问题,官方要求我们补充“在线视频课程”类目,但实际业务

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 3240

ASM准入小助手卸载没有密码的方法:读取明文密码2024年7月有效

在一次工作过程中,电脑中意外的安装了一个ASM准入小助手软件,工作结束以后回来发现没有卸载,然后就决定把它卸载掉,但是居然给了我一个大大的提示框:由于联系不到当时给我安装的那个人了,所以一时陷入了焦灼的状态,因为我安装另一个终端准入,会直接提示冲突了。所以经过注册表(regedit)、任务管理器等各种折腾之后,最后都失败了,然后想起了多年前在吾爱论坛学到过的东西,最后意外的找到了密码,然后就完美成功卸载了。

布啦啦 7804

lucene学习笔记

lucene学习笔记 思路 1. 首先搜集数据 数据可以是文件系统,数据库,网络上,手工输入的,或者像本例直接写在内存上的 2. 通过数据创建索引 3. 用户输入关键字 4. 通过关键字创建查询器 5. 根据查询器到索引里获取数据 6. 然后把查询结果展示在用户面前 ...

赵客缦胡缨,吴钩霜雪明。银鞍照白马,飒沓如流星。 314

cefshap(C#)定义浏览器的右键菜单

菜单效果:复制(自带),搜索文本,打开链接,复制链接,刷新,检查,关于 public class MenuHandler : IContextMenuHandler { //public event Action<string> PopupRequest; void IContextMenuHandler.OnBeforeContextMenu(IWebBrowser browserControl, IBrows

无线智能模块 可视DIY智能专家 1705

lucene3.5 全文检索案例————0.1秒检索60万数据

lucene3.5 全文检索案例————0.1秒检索60万数据 源码发布网:http://www.qi788.com/download.html lucene3.5 开发了 批量索引入库。 单个索引入库。 分页查询。 高亮显示查询结果。 所有索引删除。 源码下载地址:http://download.csdn.net/detail/yjflinchong/4291

2577

反应动力学仿真软件:Kintecus_(3).Kintecus安装与配置

在本节中,我们将详细介绍如何安装和配置Kintecus反应动力学仿真软件。Kintecus是一款功能强大的工具,用于模拟和分析化学反应的动力学过程。正确安装和配置软件是开始使用它的第一步。我们将分步骤介绍软件的安装过程,并提供一些基本配置的示例。

kkchenjj的博客 1552

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

Lucene全文搜索学习笔记(三)

个人笔记之用,如有错误,恳请批评指正。 高亮,多字段查询,分页查询。 分页查询,接上 若查询第二页,每页5条。查询10条。遍历取回6-10条。需判断总条数与需要条数的关系 //总记录数小于end,说明scoreDocs不满end条。即返回的是start--totalHits条。否则返回的是start--end条 ScoreDoc[] score

op134972的博客 445

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

科研伦理与学术规范备考:雨课堂高频考点与判断陷阱全解析

科研伦理与学术规范是研究生从事学术研究的底层行为准则,直接影响论文发表、项目申报与职业信誉。其核心原理在于:任何科研行为都必须在诚信、透明和责任边界内运行,而判断学术不端的关键是看行为是否违背了实质性贡献、知情同意、数据原始性等基本原则。理解这些原则,不仅有助于规避论文写作、投稿和同行评议中的风险,更能提升科研成果的公信力。面对雨课堂等在线考核场景,常见学术不端行为如数据篡改、一稿多投、不当署名、引而不注、审稿泄密等,均是高频出题点,且常以情境变形题的形式出现。只有掌握底层判断规则而非死记答案,才能应对随机

weixin_34194359的博客 413

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

上一篇: Quartz的cron表达式
下一篇: ibatIS中的isNotNull、isEqual、isEmpty
OnePiece_Sky
博客等级 码龄15年 9粉丝 63原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值