Lucene是apache組織的一個用java實現全文搜索引擎的開源項目。 其功能非常的強大，api也很簡單。總得來說用Lucene來進行建立 和搜索和操作數據庫是差不多的(有點像)，Document可以看作是 數據庫的一行記錄，Field可以看作是數據庫的字段。用lucene實 現搜索引擎就像用JDBC實現連接數據庫一樣簡單。
Lucene2.0，它與以前廣泛應用和介紹的Lucene 1.4.3并不兼容。 Lucene2.0的下載地址是http://apache.justdn.org/lucene/java/
例子一 ：
1、在windows系統下的的C盤，建一個名叫s的文件夾,在該文件夾里面隨便建三個txt文件，隨便起名啦，就叫"1.txt","2.txt"和"3.txt"啦
其中1.txt的內容如下：
中華人民共和國
全國人民
2006年
而"2.txt"和"3.txt"的內容也可以隨便寫幾寫，這里懶寫，就復制一個和1.txt文件的內容一樣吧
2、下載lucene包，放在classpath路徑中
建立索引:
package lighter.javaeye.com;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Date;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
/**
* author lighter date 2006-8-7
*/
public class TextFileIndexer {
public static void main(String[] args) throws Exception {
/* 指明要索引文件夾的位置,這里是C盤的S文件夾下 */
File fileDir = new File( " c:\\s " );
/* 這里放索引文件的位置 */
File indexDir = new File( " c:\\index " );
Analyzer luceneAnalyzer = new StandardAnalyzer();
IndexWriter indexWriter = new IndexWriter(indexDir, luceneAnalyzer,
true );
File[] textFiles = fileDir.listFiles();
long startTime = new Date().getTime();
// 增加document到索引去
for ( int i = 0 ; i < textFiles.length; i ++ ) {
if (textFiles[i].isFile()
&& textFiles[i].getName().endsWith( " .txt " )) {
System.out.println( " File " + textFiles[i].getCanonicalPath()
+ " 正在被索引 . " );
String temp = FileReaderAll(textFiles[i].getCanonicalPath(),
" GBK " );
System.out.println(temp);
Document document = new Document();
Field FieldPath = new Field( " path " , textFiles[i].getPath(),
Field.Store.YES, Field.Index.NO);
Field FieldBody = new Field( " body " , temp, Field.Store.YES,
Field.Index.TOKENIZED,
Field.TermVector.WITH_POSITIONS_OFFSETS);
document.add(FieldPath);
document.add(FieldBody);
indexWriter.addDocument(document);
}
}
// optimize()方法是對索引進行優化
indexWriter.optimize();
indexWriter.close();
// 測試一下索引的時間
long endTime = new Date().getTime();
System.out
.println( " 這花費了 "
+ (endTime - startTime)
+ " 毫秒來把文檔增加到索引里面去! "
+ fileDir.getPath());
}
public static String FileReaderAll(String FileName, String charset)
throws IOException {
BufferedReader reader = new BufferedReader( new InputStreamReader(
new FileInputStream(FileName), charset));
String line = new String();
String temp = new String();
while ((line = reader.readLine()) != null ) {
temp += line;
}
reader.close();
return temp;
}
}
索引的結果：
File C:\s\ 1 .txt正在被索引 .
中華人民共和國全國人民2006年
File C:\s\ 2 .txt正在被索引 .
中華人民共和國全國人民2006年
File C:\s\ 3 .txt正在被索引 .
中華人民共和國全國人民2006年
這花費了297 毫秒來把文檔增加到索引里面去 ! c:\s
3、建立了索引之后，查詢啦....
package lighter.javaeye.com;
import java.io.IOException;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
public class TestQuery {
public static void main(String[] args) throws IOException, ParseException {
Hits hits = null ;
String queryString = " 中華 " ;
Query query = null ;
IndexSearcher searcher = new IndexSearcher( " c:\\index " );
Analyzer analyzer = new StandardAnalyzer();
try {
QueryParser qp = new QueryParser( " body " , analyzer);
query = qp.parse(queryString);
} catch (ParseException e) {
}
if (searcher != null ) {
hits = searcher.search(query);
if (hits.length() > 0 ) {
System.out.println( " 找到: " + hits.length() + " 個結果! " );
}
}
}
}
其運行結果：
找到: 3 個結果 !
Lucene 其實很簡單的,它最主要就是做兩件事:建立索引和進行搜索
來看一些在lucene中使用的術語,這里并不打算作詳細的介紹,只是點一下而已----因為這一個世界有一種好東西，叫搜索。
IndexWriter:lucene中最重要的的類之一，它主要是用來將文檔加入索引，同時控制索引過程中的一些參數使用。
Analyzer:分析器,主要用于分析搜索引擎遇到的各種文本。常用的有StandardAnalyzer分析器,StopAnalyzer分析器,WhitespaceAnalyzer分析器等。
Directory:索引存放的位置;lucene提供了兩種索引存放的位置，一種是磁盤，一種是內存。一般情況將索引放在磁盤上；相應地lucene提供了FSDirectory和RAMDirectory兩個類。
Document:文檔;Document相當于一個要進行索引的單元，任何可以想要被索引的文件都必須轉化為Document對象才能進行索引。
Field：字段。
IndexSearcher:是lucene中最基本的檢索工具，所有的檢索都會用到IndexSearcher工具;
Query:查詢，lucene中支持模糊查詢，語義查詢，短語查詢，組合查詢等等,如有TermQuery,BooleanQuery,RangeQuery,WildcardQuery等一些類。
QueryParser: 是一個解析用戶輸入的工具，可以通過掃描用戶輸入的字符串，生成Query對象。
Hits:在搜索完成之后，需要把搜索結果返回并顯示給用戶，只有這樣才算是完成搜索的目的。在lucene中，搜索的結果的集合是用Hits類的實例來表示的。
上面作了一大堆名詞解釋，下面就看幾個簡單的實例吧:
1、簡單的的StandardAnalyzer測試例子
package lighter.javaeye.com;
import java.io.IOException;
import java.io.StringReader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
public class StandardAnalyzerTest
{
// 構造函數，
public StandardAnalyzerTest()
{
}
public static void main(String[] args)
{
// 生成一個StandardAnalyzer對象
Analyzer aAnalyzer = new StandardAnalyzer();
// 測試字符串
StringReader sr = new StringReader( " lighter javaeye com is the are on " );
// 生成TokenStream對象
TokenStream ts = aAnalyzer.tokenStream( " name " , sr);
try {
int i = 0 ;
Token t = ts.next();
while (t != null )
{
// 輔助輸出時顯示行號
i ++ ;
// 輸出處理后的字符
System.out.println( " 第 " + i + " 行: " + t.termText());
// 取得下一個字符
t = ts.next();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
顯示結果：
第1行:lighter
第2行:javaeye
第3行:com
提示一下：
StandardAnalyzer是lucene中內置的"標準分析器",可以做如下功能:
1、對原有句子按照空格進行了分詞
2、所有的大寫字母都可以能轉換為小寫的字母
3、可以去掉一些沒有用處的單詞，例如"is","the","are"等單詞，也刪除了所有的標點
查看一下結果與"new StringReader("lighter javaeye com is the are on")"作一個比較就清楚明了。
這里不對其API進行解釋了，具體見lucene的官方文檔。需要注意一點，這里的代碼使用的是lucene2的API，與1.43版有一些明顯的差別。
2、看另一個實例,簡單地建立索引，進行搜索
package lighter.javaeye.com;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.FSDirectory;
public class FSDirectoryTest {
// 建立索引的路徑
public static final String path = " c:\\index2 " ;
public static void main(String[] args) throws Exception {
Document doc1 = new Document();
doc1.add( new Field( " name " , " lighter javaeye com " ,Field.Store.YES,Field.Index.TOKENIZED));
Document doc2 = new Document();
doc2.add( new Field( " name " , " lighter blog " ,Field.Store.YES,Field.Index.TOKENIZED));
IndexWriter writer = new IndexWriter(FSDirectory.getDirectory(path, true ), new StandardAnalyzer(), true );
writer.setMaxFieldLength( 3 );
writer.addDocument(doc1);
writer.setMaxFieldLength( 3 );
writer.addDocument(doc2);
writer.close();
IndexSearcher searcher = new IndexSearcher(path);
Hits hits = null ;
Query query = null ;
QueryParser qp = new QueryParser( " name " , new StandardAnalyzer());
query = qp.parse( " lighter " );
hits = searcher.search(query);
System.out.println( " 查找\ " lighter\ " 共 " + hits.length() + " 個結果 " );
query = qp.parse( " javaeye " );
hits = searcher.search(query);
System.out.println( " 查找\ " javaeye\ " 共 " + hits.length() + " 個結果 " );
}
}
運行結果：
查找 " lighter " 共2個結果
查找 " javaeye " 共1個結果
到現在我們已經可以用lucene建立索引了
下面介紹一下幾個功能來完善一下：
1．索引格式
其實索引目錄有兩種格式，
一種是除配置文件外，每一個Document獨立成為一個文件（這種搜索起來會影響速度）。
另一種是全部的Document成一個文件，這樣屬于復合模式就快了。
2.索引文件可放的位置：
索引可以存放在兩個地方1.硬盤，2.內存
放在硬盤上可以用FSDirectory()，放在內存的用RAMDirectory()不過一關機就沒了
FSDirectory.getDirectory(File file, boolean create)
FSDirectory.getDirectory(String path, boolean create)
兩個工廠方法返回目錄
New RAMDirectory()就直接可以
再和
IndexWriter(Directory d, Analyzer a, boolean create)
一配合就行了
如：
IndexWrtier indexWriter = new IndexWriter(FSDirectory.getDirectory(“c:\\index”, true ), new StandardAnlyazer(), true );
IndexWrtier indexWriter = new IndexWriter( new RAMDirectory(), new StandardAnlyazer(), true );
3.索引的合并
這個可用
IndexWriter.addIndexes(Directory[] dirs)
將目錄加進去
來看個例子:
public void UniteIndex() throws IOException
{
IndexWriter writerDisk = new IndexWriter(FSDirectory.getDirectory( " c:\\indexDisk " , true ), new StandardAnalyzer(), true );
Document docDisk = new Document();
docDisk.add( new Field( " name " , " 程序員之家 " ,Field.Store.YES,Field.Index.TOKENIZED));
writerDisk.addDocument(docDisk);
RAMDirectory ramDir = new RAMDirectory();
IndexWriter writerRam = new IndexWriter(ramDir, new StandardAnalyzer(), true );
Document docRam = new Document();
docRam.add( new Field( " name " , " 程序員雜志 " ,Field.Store.YES,Field.Index.TOKENIZED));
writerRam.addDocument(docRam);
writerRam.close(); // 這個方法非常重要，是必須調用的
writerDisk.addIndexes( new Directory[] {ramDir} );
writerDisk.close();
}
public void UniteSearch() throws ParseException, IOException
{
QueryParser queryParser = new QueryParser( " name " , new StandardAnalyzer());
Query query = queryParser.parse( " 程序員 " );
IndexSearcher indexSearcher = new IndexSearcher( " c:\\indexDisk " );
Hits hits = indexSearcher.search(query);
System.out.println( " 找到了 " + hits.length() + " 結果 " );
for ( int i = 0 ;i
{
Document doc = hits.doc(i);
System.out.println(doc.get( " name " ));
}
}
這個例子是將內存中的索引合并到硬盤上來.
注意：合并的時候一定要將被合并的那一方的IndexWriter的close()方法調用。
4.對索引的其它操作:
IndexReader類是用來操作索引的，它有對Document,Field的刪除等操作。
下面一部分的內容是：全文的搜索
全文的搜索主要是用：IndexSearcher,Query,Hits,Document(都是Query的子類),有的時候用QueryParser
主要步驟：
1 . new QueryParser(Field字段， new 分析器)
2 .Query query = QueryParser.parser(“要查詢的字串”);這個地方我們可以用反射api看一下query究竟是什么類型
3 . new IndexSearcher(索引目錄).search(query);返回Hits
4 .用Hits.doc(n);可以遍歷出Document
5 .用Document可得到Field的具體信息了。
其實1 ，2兩步就是為了弄出個Query 實例，究竟是什么類型的看分析器了。
拿以前的例子來說吧
QueryParser queryParser = new QueryParser( " name " , new StandardAnalyzer());
Query query = queryParser.parse( " 程序員 " );
/* 這里返回的就是org.apache.lucene.search.PhraseQuery */
IndexSearcher indexSearcher = new IndexSearcher( " c:\\indexDisk " );
Hits hits = indexSearcher.search(query);
不管是什么類型，無非返回的就是Query的子類，我們完全可以不用這兩步直接new個Query的子類的實例就ok了，不過一般還是用這兩步因為它返回的是PhraseQuery這個是非常強大的query子類它可以進行多字搜索用QueryParser可以設置各個關鍵字之間的關系這個是最常用的了。
IndexSearcher:
其實IndexSearcher它內部自帶了一個IndexReader用來讀取索引的，IndexSearcher有個close()方法，這個方法不是用來關閉IndexSearche的是用來關閉自帶的IndexReader。
QueryParser呢可以用parser.setOperator()來設置各個關鍵字之間的關系（與還是或）它可以自動通過空格從字串里面將關鍵字分離出來。
注意：用QueryParser搜索的時候分析器一定的和建立索引時候用的分析器是一樣的。
Query:
可以看一個lucene2.0的幫助文檔有很多的子類:
BooleanQuery, ConstantScoreQuery, ConstantScoreRangeQuery, DisjunctionMaxQuery, FilteredQuery, MatchAllDocsQuery, MultiPhraseQuery, MultiTermQuery, PhraseQuery, PrefixQuery, RangeQuery, SpanQuery, TermQuery
各自有用法看一下文檔就能知道它們的用法了
下面一部分講一下lucene的分析器:
分析器是由分詞器和過濾器組成的，拿英文來說吧分詞器就是通過空格把單詞分開，過濾器就是把the,to,of等詞去掉不被搜索和索引。
我們最常用的是StandardAnalyzer()它是lucene的標準分析器它集成了內部的許多的分析器。
最后一部分了：lucene的高級搜索了
1.排序
Lucene有內置的排序用IndexSearcher.search(query,sort)但是功能并不理想。我們需要自己實現自定義的排序。
這樣的話得實現兩個接口: ScoreDocComparator, SortComparatorSource
用IndexSearcher.search(query,new Sort(new SortField(String Field,SortComparatorSource)));
就看個例子吧：
這是一個建立索引的例子：
public void IndexSort() throws IOException
{
IndexWriter writer = new IndexWriter( " C:\\indexStore " , new StandardAnalyzer(), true );
Document doc = new Document()
doc.add( new Field( " sort " , " 1 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 4 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 3 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 5 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 9 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 6 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
doc = new Document();
doc.add( new Field( " sort " , " 7 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
writer.close();
}
下面是搜索的例子:
[code]
public void SearchSort1() throws IOException, ParseException
{
IndexSearcher indexSearcher = new IndexSearcher("C:\\indexStore");
QueryParser queryParser = new QueryParser("sort",new StandardAnalyzer());
Query query = queryParser.parse("4");
Hits hits = indexSearcher.search(query);
System.out.println("有"+hits.length()+"個結果");
Document doc = hits.doc(0);
System.out.println(doc.get("sort"));
}
public void SearchSort2() throws IOException, ParseException
{
IndexSearcher indexSearcher = new IndexSearcher("C:\\indexStore");
Query query = new RangeQuery(new Term("sort","1"),new Term("sort","9"),true);//這個地方前面沒有提到，它是用于范圍的Query可以看一下幫助文檔.
Hits hits = indexSearcher.search(query,new Sort(new SortField("sort",new MySortComparatorSource())));
System.out.println("有"+hits.length()+"個結果");
for(int i=0;i
{
Document doc = hits.doc(i);
System.out.println(doc.get("sort"));
}
}
public class MyScoreDocComparator implements ScoreDocComparator
{
private Integer[]sort;
public MyScoreDocComparator(String s,IndexReader reader, String fieldname) throws IOException
{
sort = new Integer[reader.maxDoc()];
for(int i = 0;i
{
Document doc =reader.document(i);
sort[i]=new Integer(doc.get("sort"));
}
}
public int compare(ScoreDoc i, ScoreDoc j)
{
if(sort[i.doc]>sort[j.doc])
return 1;
if(sort[i.doc]
return -1;
return 0;
}
public int sortType()
{
return SortField.INT;
}
public Comparable sortValue(ScoreDoc i)
{
// TODO 自動生成方法存根
return new Integer(sort[i.doc]);
}
}
public class MySortComparatorSource implements SortComparatorSource
{
private static final long serialVersionUID = -9189690812107968361L;
public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
throws IOException
{
if(fieldname.equals("sort"))
return new MyScoreDocComparator("sort",reader,fieldname);
return null;
}
}[/code]
SearchSort1()輸出的結果沒有排序,SearchSort2()就排序了。
2.多域搜索MultiFieldQueryParser
如果想輸入關鍵字而不想關心是在哪個Field里的就可以用MultiFieldQueryParser了
用它的構造函數即可后面的和一個Field一樣。
MultiFieldQueryParser. parse(String[] queries, String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer) ~~~~~~~~~~~~~~~~~
第三個參數比較特殊這里也是與以前lucene1.4.3不一樣的地方
看一個例子就知道了
String[] fields = {"filename", "contents", "description"};
BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
BooleanClause.Occur.MUST,//在這個Field里必須出現的
BooleanClause.Occur.MUST_NOT};//在這個Field里不能出現
MultiFieldQueryParser.parse("query", fields, flags, analyzer);
1、lucene的索引不能太大，要不然效率會很低。大于1G的時候就必須考慮分布索引的問題
2、不建議用多線程來建索引，產生的互鎖問題很麻煩。經常發現索引被lock，無法重新建立的情況
3、中文分詞是個大問題，目前免費的分詞效果都很差。如果有能力還是自己實現一個分詞模塊，用最短路徑的切分方法，網上有教材和demo源碼，可以參考。
4、建增量索引的時候很耗cpu，在訪問量大的時候會導致cpu的idle為0
5、默認的評分機制不太合理，需要根據自己的業務定制
整體來說lucene要用好不容易，必須在上述方面擴充他的功能，才能作為一個商用的搜索引擎