Lucene.Net 介紹，lucene.net介紹

1 lucene簡介
1.1 什麼是lucenepowered by 25175.net
Lucene是一個全文搜索框架，而不是應用產品。因此它並不像www.baidu.com 或者google Desktop那麼拿來就能用，它只是提供了一種工具讓你能實現這些產品。

1.2 lucene能做什麼
要 回答這個問題，先要了解lucene的本質。實際上lucene的功能很單一，說到底，就是你給它若干個字符串，然後它為你提供一個全文搜索服務，告訴你 你要搜索的關鍵詞出現在哪裡。知道了這個本質，你就可以發揮想象做任何符合這個條件的事情了。你可以把站內新聞都索引了，做個資料庫；你可以把一個數據庫 表的若干個字段索引起來，那就不用再擔心因為“%like%”而鎖表了；你也可以寫個自己的搜索引擎……

1.3 你該不該選擇lucene
下面給出一些測試數據，如果你覺得可以接受，那麼可以選擇。
測試一：250萬記錄，300M左右文本，生成索引380M左右，800線程下平均處理時間300ms。
測試二：37000記錄，索引數據庫中的兩個varchar字段，索引文件2.6M，800線程下平均處理時間1.5ms。

2 lucene的工作方式
lucene提供的服務實際包含兩部分：一入一出。所謂入是寫入，即將你提供的源（本質是字符串）寫入索引或者將其從索引中刪除；所謂出是讀出，即向用戶提供全文搜索服務，讓用戶可以通過關鍵詞定位源。

2.1寫入流程
源字符串首先經過analyzer處理，包括：分詞，分成一個個單詞；去除stopword（可選）。
將源中需要的信息加入document．各個Field中，並把需要索引的Field索引起來，把需要存儲的Field存儲起來。
將索引寫入存儲器，存儲器可以是內存或磁盤。

2.2讀出流程
用戶提供搜索關鍵詞，經過analyzer處理。
對處理後的關鍵詞搜索索引找出對應的document．
用戶根據需要從找到的document．提取需要的Field。

3 一些需要知道的概念
lucene用到一些概念，了解它們的含義，有利於下面的講解。

3.1 analyzer
Analyzer 是分析器，它的作用是把一個字符串按某種規則劃分成一個個詞語，並去除其中的無效詞語，這裡說的無效詞語是指英文中的 “of”、 “the”，中文中的“的”、“地”等詞語，這些詞語在文章中大量出現，但是本身不包含什麼關鍵信息，去掉有利於縮小索引文件、提高效率、提高命中率。
分詞的規則千變萬化，但目的只有一個：按語義劃分。這點在英文中比較容易實現，因為英文本身就是以單詞為單位的，已經用空格分開；而中文則必須以某種方法將連成一片的句子劃分成一個個詞語。具體劃分方法下面再詳細介紹，這裡只需了解分析器的概念即可。

3.2 document．br /> 用戶提供的源是一條條記錄，它們可以是文本文件、字符串或者數據庫表的一條記錄等等。一條記錄經過索引之後，就是以一個document．形式存儲在索引文件中的。用戶進行搜索，也是以document．表的形式返回。

3.3 field
一個document．以包含多個信息域，例如一篇文章可以包含“標題”、“正文”、“最後修改時間”等信息域，這些信息域就是通過Field在document．存儲的。
Field有兩個屬性可選：存儲和索引。通過存儲屬性你可以控制是否對這個Field進行存儲；通過索引屬性你可以控制是否對該Field進行索引。這看起來似乎有些廢話，事實上對這兩個屬性的正確組合很重要，下面舉例說明：
還 是以剛才的文章為例子，我們需要對標題和正文進行全文搜索，所以我們要把索引屬性設置為真，同時我們希望能直接從搜索結果中提取文章標題，所以我們把標題 域的存儲屬性設置為真，但是由於正文域太大了，我們為了縮小索引文件大小，將正文域的存儲屬性設置為假，當需要時再直接讀取文件；我們只是希望能從搜索解 果中提取最後修改時間，不需要對它進行搜索，所以我們把最後修改時間域的存儲屬性設置為真，索引屬性設置為假。上面的三個域涵蓋了兩個屬性的三種組合，還 有一種全為假的沒有用到，事實上Field不允許你那麼設置，因為既不存儲又不索引的域是沒有意義的。

3.4 term
term是搜索的最小單位，它表示文檔的一個詞語，term由兩部分組成：它表示的詞語和這個詞語所出現的field。

3.5 tocken
tocken是term的一次出現，它包含trem文本和相應的起止偏移，以及一個類型字符串。一句話中可以出現多次相同的詞語，它們都用同一個term表示，但是用不同的tocken，每個tocken標記該詞語出現的地方。

3.6 segment
添加索引時並不是每個document．馬上添加到同一個索引文件，它們首先被寫入到不同的小文件，然後再合並成一個大索引文件，這裡每個小文件都是一個segment。

4 lucene的結構
lucene包括core和sandbox兩部分，其中core是lucene穩定的核心部分，sandbox包含了一些附加功能，例如highlighter、各種分析器。
Lucene core有七個包：analysis，document．index，queryParser，search，store，util。
4.1 analysis
Analysis包含一些內建的分析器，例如按空白字符分詞的WhitespaceAnalyzer，添加了stopwrod過濾的StopAnalyzer，最常用的StandardAnalyzer。
4.2 document．br /> document．含文檔的數據結構，例如document．定義了存儲文檔的數據結構，Field類定義了document．一個域。
4.3 index
Index 包含了索引的讀寫類，例如對索引文件的segment進行寫、合並、優化的IndexWriter類和對索引進行讀取和刪除操作的 IndexReader類，這裡要注意的是不要被IndexReader這個名字誤導，以為它是索引文件的讀取類，實際上刪除索引也是由它完成， IndexWriter只關心如何將索引寫入一個個segment，並將它們合並優化；IndexReader則關注索引文件中各個文檔的組織形式。
4.4 queryParser
QueryParser 包含了解析查詢語句的類，lucene的查詢語句和sql語句有點類似，有各種保留字，按照一定的語法可以組成各種查詢。 Lucene有很多種Query類，它們都繼承自Query，執行各種特殊的查詢，QueryParser的作用就是解析查詢語句，按順序調用各種 Query類查找出結果。
4.5 search
Search包含了從索引中搜索結果的各種類，例如剛才說的各種Query類，包括TermQuery、BooleanQuery等就在這個包裡。
4.6 store
Store包含了索引的存儲類，例如Directory定義了索引文件的存儲結構，FSDirectory為存儲在文件中的索引，RAMDirectory為存儲在內存中的索引，MmapDirectory為使用內存映射的索引。
4.7 util
Util包含一些公共工具類，例如時間和字符串之間的轉換工具。
5 如何建索引
5.1 最簡單的能完成索引的代碼片斷

IndexWriter writer = new IndexWriter(“/data/index/”, new StandardAnalyzer(), true);
document．doc = new document．);
doc.add(new Field("title", "lucene introduction", Field.Store.YES, Field.Index.TOKENIZED));
doc.add(new Field("content", "lucene works well", Field.Store.YES, Field.Index.TOKENIZED));
writer.adddocument．doc);
writer.optimize();
writer.close();

下面我們分析一下這段代碼。
首先我們創建了一個writer，並指定存放索引的目錄為“/data/index”，使用的分析器為StandardAnalyzer，第三個參數說明如果已經有索引文件在索引目錄下，我們將覆蓋它們。
然後我們新建一個document．
我們向document．加一個field，名字是“title”，內容是“lucene introduction”，對它進行存儲並索引。
再添加一個名字是“content”的field，內容是“lucene works well”，也是存儲並索引。
然後我們將這個文檔添加到索引中，如果有多個文檔，可以重復上面的操作，創建document．添加。
添加完所有document．我們對索引進行優化，優化主要是將多個segment合並到一個，有利於提高索引速度。
隨後將writer關閉，這點很重要。

對，創建索引就這麼簡單！
當然你可能修改上面的代碼獲得更具個性化的服務。

5.2 將索引直接寫在內存
你需要首先創建一個RAMDirectory，並將其傳給writer，代碼如下：

Directory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true);
document．doc = new document．);
doc.add(new Field("title", "lucene introduction", Field.Store.YES, Field.Index.TOKENIZED));
doc.add(new Field("content", "lucene works well", Field.Store.YES, Field.Index.TOKENIZED));
writer.adddocument．doc);
writer.optimize();
writer.close();

5.3 索引文本文件
如果你想把純文本文件索引起來，而不想自己將它們讀入字符串創建field，你可以用下面的代碼創建field：

Field field = new Field("content", new FileReader(file));

這裡的file就是該文本文件。該構造函數實際上是讀去文件內容，並對其進行索引，但不存儲。

6 如何維護索引
索引的維護操作都是由IndexReader類提供。

6.1 如何刪除索引
lucene提供了兩種從索引中刪除document．方法，一種是

void deletedocument．int docNum)

這種方法是根據document．索引中的編號來刪除，每個document．進索引後都會有個唯一編號，所以根據編號刪除是一種精確刪除，但是這個編號是索引的內部結構，一般我們不會知道某個文件的編號到底是幾，所以用處不大。另一種是

void deletedocument．(Term term)

這種方法實際上是首先根據參數term執行一個搜索操作，然後把搜索到的結果批量刪除了。我們可以通過這個方法提供一個嚴格的查詢條件，達到刪除指定document．目的。
下面給出一個例子：

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexReader reader = IndexReader.open(dir);
Term term = new Term(field, key);
reader.deletedocument．(term);
reader.close();

6.2 如何更新索引
lucene並沒有提供專門的索引更新方法，我們需要先將相應的document．除，然後再將新的document．入索引。例如：

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexReader reader = IndexReader.open(dir);
Term term = new Term(“title”, “lucene introduction”);
reader.deletedocument．(term);
reader.close();

IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true);
document．doc = new document．);
doc.add(new Field("title", "lucene introduction", Field.Store.YES, Field.Index.TOKENIZED));
doc.add(new Field("content", "lucene is funny", Field.Store.YES, Field.Index.TOKENIZED));
writer.adddocument．doc);
writer.optimize();
writer.close();
7 如何搜索
　　lucene 的搜索相當強大，它提供了很多輔助查詢類，每個類都繼承自Query類，各自完成一種特殊的查詢，你可以像搭積木一樣將它們任意組合使用，完成一些復雜操 作；另外lucene還提供了Sort類對結果進行排序，提供了Filter類對查詢條件進行限制。你或許會不自覺地拿它跟SQL語句進行比 較：“lucene能執行and、or、order by、where、like ‘%xx%’操作嗎？”回答是：“當然沒問題！”

7.1 各種各樣的Query
下面我們看看lucene到底允許我們進行哪些查詢操作：

7.1.1 TermQuery
首先介紹最基本的查詢，如果你想執行一個這樣的查詢：“在content域中包含‘lucene’的document．rdquo;，那麼你可以用TermQuery：

Term t = new Term("content", " lucene";
Query query = new TermQuery(t);

7.1.2 BooleanQuery
如果你想這麼查詢：“在content域中包含java或perl的document．rdquo;，那麼你可以建立兩個TermQuery並把它們用BooleanQuery連接起來：

TermQuery termQuery1 = new TermQuery(new Term("content", "java");
TermQuery termQuery 2 = new TermQuery(new Term("content", "perl");
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.add(termQuery 1, BooleanClause.Occur.SHOULD);
booleanQuery.add(termQuery 2, BooleanClause.Occur.SHOULD);

7.1.3 WildcardQuery
如果你想對某單詞進行通配符查詢，你可以用WildcardQuery，通配符包括’?’匹配一個任意字符和’*’匹配零個或多個任意字符，例如你搜索’use*’，你可能找到’useful’或者’useless’：

Query query = new WildcardQuery(new Term("content", "use*");

7.1.4 PhraseQuery
你可能對中日關系比較感興趣，想查找‘中’和‘日’挨得比較近（5個字的距離內）的文章，超過這個距離的不予考慮，你可以：

PhraseQuery query = new PhraseQuery();
query.setSlop(5);
query.add(new Term("content ", “中”));
query.add(new Term(“content”, “日”));

那麼它可能搜到“中日合作……”、“中方和日方……”，但是搜不到“中國某高層領導說日本欠扁”。

7.1.5 PrefixQuery
如果你想搜以‘中’開頭的詞語，你可以用PrefixQuery：

PrefixQuery query = new PrefixQuery(new Term("content ", "中");

7.1.6 FuzzyQuery
FuzzyQuery用來搜索相似的term，使用Levenshtein算法。假設你想搜索跟‘wuzza’相似的詞語，你可以：

Query query = new FuzzyQuery(new Term("content", "wuzza");

你可能得到‘fuzzy’和‘wuzzy’。

7.1.7 RangeQuery
另一個常用的Query是RangeQuery，你也許想搜索時間域從20060101到20060130之間的document．你可以用RangeQuery：

RangeQuery query = new RangeQuery(new Term(“time”, “20060101”), new Term(“time”, “20060130”), true);

最後的true表示用閉合區間。

7.2 QueryParser
看 了這麼多Query，你可能會問：“不會讓我自己組合各種Query吧，太麻煩了！”當然不會，lucene提供了一種類似於SQL語句的查詢語句，我們 姑且叫它lucene語句，通過它，你可以把各種查詢一句話搞定，lucene會自動把它們查分成小塊交給相應Query執行。下面我們對應每種 Query演示一下：
TermQuery可以用“field:key”方式，例如“content:lucene”。
BooleanQuery中‘與’用‘+’，‘或’用‘ ’，例如“content:java contenterl”。
WildcardQuery仍然用‘?’和‘*’，例如“content:use*”。
PhraseQuery用‘~’，例如“content:"中日"~5”。
PrefixQuery用‘*’，例如“中*”。
FuzzyQuery用‘~’，例如“content: wuzza ~”。
RangeQuery用‘[]’或‘{}’，前者表示閉區間，後者表示開區間，例如“time:[20060101 TO 20060130]”，注意TO區分大小寫。
你 可以任意組合query string，完成復雜操作，例如“標題或正文包括lucene，並且時間在20060101到20060130之間的文章” 可以表示為：“+ (title:lucene content:lucene) +time:[20060101 TO 20060130]”。代碼如下：

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexSearcher is = new IndexSearcher(dir);
QueryParser parser = new QueryParser("content", new StandardAnalyzer());
Query query = parser.parse("+(title:lucene content:lucene) +time:[20060101 TO 20060130]";
Hits hits = is.search(query);
for (int i = 0; i < hits.length(); i++)
{
document．doc = hits.doc(i);
System.out.println(doc.get("title");
}
is.close();

首先我們創建一個在指定文件目錄上的IndexSearcher。
然後創建一個使用StandardAnalyzer作為分析器的QueryParser，它默認搜索的域是content。
接著我們用QueryParser來parse查詢字串，生成一個Query。
然後利用這個Query去查找結果，結果以Hits的形式返回。
這個Hits對象包含一個列表，我們挨個把它的內容顯示出來。

7.3 Filter
filter 的作用就是限制只查詢索引的某個子集，它的作用有點像SQL語句裡的 where，但又有區別，它不是正規查詢的一部分，只是對數據源進行預處理，然後交給查詢語句。注意它執行的是預處理，而不是對查詢結果進行過濾，所以使 用filter的代價是很大的，它可能會使一次查詢耗時提高一百倍。
最常用的filter是RangeFilter和QueryFilter。RangeFilter是設定只搜索指定范圍內的索引；QueryFilter是在上次查詢的結果中搜索。
Filter的使用非常簡單，你只需創建一個filter實例，然後把它傳給searcher。     示例：

　　 /**
     * 分頁
     * 
     * @param pageSize 每頁顯示記錄數
     * @param curPage 當前頁
     * @throws IOException 
     */
    public static void page(int pageSize, int curPage) throws IOException{
        String indexPath=XMLPropertyConfig.getConfigXML().getString("index_path");
        IndexSearcher searcher= LuceneManager.getIndexSearcher(indexPath);
    
        TermRangeQuery timeQuery=new TermRangeQuery("birthdays", 
                "1988-03-09", "2013-01-07", true, true);
        Sort sort=new Sort(new SortField("birthdays", 
                new com.ljq.comparator.DateValComparatorSource("yyyy-MM-dd"), false));
        
        TopDocs topDocs=searcher.search(timeQuery, 100, sort);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        
        //查詢起始記錄位置
        int begin = pageSize * (curPage - 1);
        //查詢終止記錄位置
        int end = Math.min(begin + pageSize, scoreDocs.length);
        
        for(int i=begin;i<end;i++) {
            int docID = scoreDocs[i].doc;
            Document document = searcher.doc(docID);
            String id = document.get("id");
            String name = document.get("name");
            String age = document.get("age");
            String city = document.get("city");
            String birthday = document.get("birthday");
            
            System.out.println(String.format("id:%s, name:%s, age:%s, city:%s, birthday:%s.", 
                    id, name, age, city, DateUtils.longToString(Long.parseLong(birthday), Consts.FORMAT_SHORT)));
        }
    }
--------------------------------------------------------------------------
Lucene.Net進行多字段搜索的關鍵代碼：
             Lucene.Net.Search.IndexSearcher iSearcher 
            = new Lucene.Net.Search.IndexSearcher(path);

            //多字段進行搜索
            string[] fields = { "Title", "KeyWords", "Content" };
            Lucene.Net.QueryParsers.QueryParser qp
                = new Lucene.Net.QueryParsers.MultiFieldQueryParser(fields, new Lucene.Net.Analysis.Standard.StandardAnalyzer());
            qp.SetDefaultOperator(Lucene.Net.QueryParsers.QueryParser.OR_OPERATOR);

             //進行多條件檢索
            Lucene.Net.Search.BooleanQuery booleanQuery = new Lucene.Net.Search.BooleanQuery();
            Lucene.Net.Search.Query tempQuery = qp.Parse(key);
            booleanQuery.Add(tempQuery, Lucene.Net.Search.BooleanClause.Occur.MUST);
            Lucene.Net.Search.Hits hits = iSearcher.Search(booleanQuery);

/**/
        /// <summary>
        /// Does the search an stores the information about the results.
        /// </summary>
        public void search()
        {
            // 索引目錄
            //string indexDirectory = Server.MapPath(ConfigurationSettings.AppSettings["EnableCache"] );
            //創建一個Searcher用於搜索
            //記錄查詢開始的時間
            DateTime start = DateTime.Now;
            this.GetIndexDir("HTWJ", IndexDiectory);
            IndexSearcher searcher = new IndexSearcher(dir);
            //從"FullText"字段搜索
            //Console.WriteLine(this.Query);
            ChineseAnalyzer OneAnalyzer = new ChineseAnalyzer();
            BooleanClause.Occur[] flags = new BooleanClause.Occur[] {
                   BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };
           // Query query = QueryParser.Parse(this.Query, "FullText", new StandardAnalyzer());
            //多字段檢索            Query query = MultiFieldQueryParser.Parse(this.Query, new String[] { "Title", "FullText" }, flags, OneAnalyzer);
            //Query query = parser.Parse(this.Query);
            //創建結果記錄集
            //定義字段            this.Results.Columns.Add("File_Id", typeof(string));
            this.Results.Columns.Add("Title", typeof(string));
            this.Results.Columns.Add("FullText", typeof(string));
            Sort sort = new Sort(new SortField("Title", SortField.DOC, true));
            //Hits是搜索結果記錄集,不過是Lucene自己的格式,需要格式化成標准輸出            Hits hits = searcher.Search(query, sort);
            //結果個數            this.total = hits.Length();
            /**/
            ////創建高亮顯示            //Highlighter highlighter = new Highlighter(new SimpleHTMLFormatter("<font color="#C60A00">", "</font>"), new QueryScorer(query));
            //highlighter.TextFragmenter = new SimpleFragmenter(160);
            //highlighter.MaxDocBytesToAnalyze = 256;
            // initialize startAt
            ////創建高亮顯示2            SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<B><font color=\"red\">", "</font></B>");
            Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));
            this.startAt = initStartAt();
            // how many items we should show - less than defined at the end of the results            int resultsCount = smallerOf(total, this.maxResults + this.startAt);
            for (int i = startAt; i < resultsCount; i++)
            {
                Document doc = hits.Doc(i);
                DataRow row = this.Results.NewRow();
                row["File_Id"] = doc.Get("File_Id");
                //後期處理---鏈接                row["Title"] = "<a href=\"http://www.zzu.edu.cn\" target=\"_blank\"> " + doc.Get("Title") + "</a>";
                //ChineseAnalyzer analyzer1 = new ChineseAnalyzer();                TokenStream tokenStream = OneAnalyzer.TokenStream("FullText", new StringReader(doc.Get("FullText")));
                row["FullText"] = highlighter.GetBestFragment(tokenStream, doc.Get("FullText"));
                //用這種方法可直接創建高亮 可擴展為高亮鏈接
                //string fullText = doc.Get("FullText");
                //row["FullText"] = this.SimpleHighLighter(fullText, this.Query, "<B><font color=\"red\">", "</font></B>", 126);
                this.Results.Rows.Add(row);
            }
            searcher.Close();
            // result information
            this.fromItem = startAt + 1;
            this.toItem = smallerOf(startAt + maxResults, total);
            //記錄查詢使用的時間            this.duration = DateTime.Now - start;
        }

--------------------------------------------------

 1 /****
 2      * 命名不是很好
 3      * @param field:暫時麼用
 4      * @param query：query
 5      * @param first:分頁起始值，如第一頁0, first 0 max 20，第二頁 first20, max 20
 6      * @param max:每頁顯示的數目，如20
 7      * @param sort：排序
 8      * @param highLight:是否高亮,這裡不咱貼代碼
 9      * @return
10      */
11     public static SearchResultBean searchAndSort(String field, Query query, int first,
12             int max, Sort sort, boolean highLight)
13     {
14         if(query == null){
15             System.out.println(" Query is null return null ");
16             return null;
17         }
18         try
19         {
20             List<Document> docs = new ArrayList<Document>();
21             IndexSearcher searcher = LuceneFactory.getFileSearch();
22 
23             TopFieldCollector c = TopFieldCollector.create(sort, first+max, false, false, false, false);
24             searcher.search(query, c);
25             ScoreDoc[] hits = c.topDocs(first, max).scoreDocs;
26             if (hits == null || hits.length < 1)
27                 return null;
28 
29             // 高亮------------------------------
30             Formatter htmlFormatter = null;
31             if (highLight)
32                 htmlFormatter = new SimpleHTMLFormatter(
33                         "<span style='color:red;'>", "</span>");
34             else
35                 htmlFormatter = new SimpleHTMLFormatter("", "");
36 
37             Scorer scorer = new QueryScorer(query);

38             //Encoder encoder = new SimpleHTMLEncoder();
39             Fragmenter fragmenter = new SimpleFragmenter(Max_Match_Num);
40             Highlighter highlighter = new Highlighter(htmlFormatter, scorer);
41             highlighter.setTextFragmenter(fragmenter);
42 
43             for (int i = 0; i < hits.length; i++)
44             {
45                 Document doc = searcher.doc(hits[i].doc);
46                 highlight(highlighter, doc, field);
47 
48                 docs.add(doc);
49             }
50 
51             return new SearchResultBean(c.getTotalHits(), docs);
52         } catch (Exception e)
53         {
54             return null;
55         }
56     }
57