Lucene筆記
Lucene學習筆記
Lucene的概述：
1.1 什麼是lucene html
http://cloudera.iteye.com/blog/656459java
這是一篇很好的文章。下面即是取自這裏。算法
Lucene是一個全文搜索框架，而不是應用產品。所以它並不像http://www.baidu.com/ 或者google Desktop那麼拿來就能用，它只是提供了一種工具讓你能實現這些產品。sql
1.2 lucene能作什麼 數據庫
要回答這個問題，先要了解lucene的本質。實際上lucene的功能很單一，說到底，就是你給它若干個字符串，而後它爲你提供一個全文搜索服務，告訴你你要搜索的關鍵詞出如今哪裏。知道了這個本質，你就能夠發揮想象作任何符合這個條件的事情了。你能夠把站內新聞都索引了，作個資料庫；你能夠把一個數據庫表的若干個字段索引發來，那就不用再擔憂由於「%like%」而鎖表了；你也能夠寫個本身的搜索引擎……apache
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
用戶提供的源是一條條記錄，它們能夠是文本文件、字符串或者數據庫表的一條記錄等等。一條記錄通過索引以後，就是以一個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.5版本不是這7個包，而是以下：
關於這些的詳細介紹，後面再說。
環境的準備：
1. 先下載開發的jar包：http://lucene.apache.org/
http://apache.dataguru.cn/lucene/java/4.5.0/
咱們把zip和src下載下來就能夠了。
2. 對於開源的框架，通常使用都有2個步驟
a) 添加jar包
爲了項目的可移植性，咱們應該創建一個lib文件夾，專門放外部的jar包，而後把須要的jar包放入到這個目錄，最後在連接進項目裏面
b) 配置文件
3. 根據開發文檔搭建環境
a) 先讀readme文件，他會告訴你怎麼用，告訴你這項目是什麼
b) 再根據a)的指導，讀取相應的文件，也就是docs/index.html
c) Index只指導咱們看demon，因而只能網上搜索demo怎麼用
下面是demon的使用方法：
http://blog.csdn.net/wyj0613/article/details/12318825
咱們按照這個作法作就是了(預告：最後沒有找到怎麼搭建工程的方法)
i) 定義環境變量：CLASSPATH的值以下：
D:\soft_framework_utiles\lucene-4.5.0\lucene-4.5.0\core\lucene-core-4.5.0.jar;
D:\soft_framework_utiles\lucene-4.5.0\lucene-4.5.0\demo\lucene-demo-4.5.0.jar;D:\soft_framework_utiles\lucene-4.5.0\lucene-4.5.0\queryparser\lucene-queryparser-4.5.0.jar;
D:\soft_framework_utiles\lucene-4.5.0\lucene-4.5.0\analysis\common\lucene-analyzers-common-4.5.0.jar;
把這個4個jar放進去就是了。
j) 開始測試demonà創建索引
java org.apache.lucene.demo.IndexFiles -index [index folder] -docs[docs folder]
設置要生成的索引的文件夾和要解析的docs
咱們的doc目錄用：demo\lf_test_docs_dir
生成的index目錄用：demo\lf_test_index_dir
下面就是執行過程：
咱們能夠去看index目錄的生成的文件：
k) 開始測試demonà執行查詢
java org.apache.lucene.demo.SearchFiles
將會出現「Query:」提示符，在其後輸入關鍵字，回車，便可獲得查詢結果
因爲SearchFiles是查找當前目錄下面的index目錄做爲索引文件目錄，因此這
裏報錯了，咱們能夠用-index參數指定咱們的index目錄：
能夠看到查詢mozilla獲得3個文檔有這個關鍵字。
4. 到教學的東西，那麼咱們就查資料吧，下面是作法
須要的jar包是：
Ø lucene-core-4.5.0.jar 核心包
Ø lucene-analyzers-common-4.5.0.jar 分詞器
Ø lucene-highlighter-4.5.0.jar 高亮器
添加到項目buildpath:
以下顯示就對了：
5. 寫咱們本身的代碼了
先生成索引:（代碼插件挺好用啊）
Document document = LuceneUtiles.getDocument(filePath); // 存放索引的目錄 Directory indexDirectory = FSDirectory.open( new File(indexPath)); // 這裏默認使用的模式是：openMode = OpenMode.CREATE_OR_APPEND; // IndexWriterConfig的父類構造是初始化的 IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_45, analyzer); // 索引的維護是用IndexWriter來作的，把doc添加進去,更新，刪除就好了 IndexWriter indexWriter = new IndexWriter(indexDirectory,indexWriterConfig); indexWriter.addDocument(document); // 全部io操做的，最後都應該關閉，好比file，network，database等 indexWriter.close(); 查詢: public void searchFromIndex() throws IOException { // 只能全小寫才能夠！由於咱們term沒有通過分詞器處理！ // 因此只能用直接跟索引庫的關鍵字一一對應的值 // 之後講解把索引字符串也處理的方法 String queryString = " binary " ; // 1.收索字符串--->Query對象 Query query = null ; { // 注意： // 由於文件在創建索引的時候(分詞器那裏)，就已經作了一次大小寫轉換了， // 存的索引全是小寫的 // 而咱們這裏搜索的時候沒有經過分詞器，因此咱們的數據沒有轉化， // 那麼若是這裏是大寫類型就搜不到任何東西！！！ Term term = new Term( " fileContent " ,queryString); // 至於這裏用什麼Query，之後再說 query = new TermQuery(term); } // 2.進行查詢 TopDocs topDocs = null ; IndexSearcher searcher = null ; IndexReader indexReader = null ; { // 指定索引的文件位置 indexReader = DirectoryReader.open(FSDirectory.open( new File(indexPath))); searcher = new IndexSearcher(indexReader); Filter filter = null ; // 搜索 // 過濾器，能夠過濾一些文件，null就是不用過濾器 // 數字表明每次查詢多少條，也就是一次數據的讀取讀多少條， // 1000,10000等比較合適,默認是50 // topDocs = searcher.search(query, filter, 1000 ); } // 3.打印結果 { System.out.println( " 總共有【 " + topDocs.totalHits + " 】條匹配結果 " ); // 這是返回的數據 for ( int i = 0 ; i < topDocs.scoreDocs.length; i ++ ) { int docId = topDocs.scoreDocs[i].doc; Document hittedDocument = searcher.doc(docId); LuceneUtiles.print(hittedDocument); } } indexReader.close(); }
6. 講解
點擊類名，使用ctrl+T實現查詢該類的子類，即繼承關係！
下面是Lucene的大致結構圖：
原理是先把文章根據需求用分詞器拆分，而後創建好每個關鍵詞到文章的映射關係，這就是索引表，索引表存放的就是關鍵字到文章的映射，注意這裏的映射不是直接就持有了對應的文章，而是持有的內部對文章編號的一個id。因此索引是關鍵字到文章Id的一個映射。
當用戶查詢時，也用以前的分詞器，把查詢分詞，而後每個詞都挨着找索引，把匹配的返回出來就完畢了。
（別人的圖片）
a) Analysis：分詞器
Analysis包含一些內建的分析器，例如按空白字符分詞的WhitespaceAnalyzer，添加了stopwrod過濾的StopAnalyzer，最經常使用的StandardAnalyzer。
b) Documet：文檔
就是咱們的源數據的封裝結構，咱們須要把源數據分紅不一樣的域，放入到documet裏面，到時搜索時也能夠指定搜索哪些域（Field）了。
c) Directory : 目錄，這是對目錄的一個抽象，這個目錄能夠是文件系統上面的一個dir(FSDirectory)，也能夠是內存的一塊(RAMDirectory)，MmapDirectory爲使用內存映射的索引。
放在內存的話就會避免IO的操做耗時了,根據須要選擇就是了。
d) IndexWriter ： 索引書寫器，也就是維護器，對索引進行讀取和刪除操做的類
e) IndexReader ： 索引讀取器，用於讀取指定目錄的索引。
f) IndexSearcher ： 索引的搜索器，就是把用戶輸入拿到索引列表中搜索的一個類
須要注意的是，這個搜索出來的就是（TopDocs）索引號，還不是真正的文章。
g) Query ： 查詢語句，咱們須要把咱們的查詢String封裝成Query才能夠交給Searcher來搜索 ,查詢的最小單元是Term，Lucene的Query有不少種，根據不一樣的需求選用不一樣的Query就是了.
i. TermQuery:
若是你想執行一個這樣的查詢：「在content域中包含‘lucene’的document」，那麼你能夠用TermQuery：
Term t = new Term( " content " , " lucene " ); Query query = new TermQuery(t);
ii. BooleanQuery:多個query的【與或】關係的查詢
若是你想這麼查詢：「在content域中包含java或perl的document」，那麼你能夠創建兩個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(termQuery1, BooleanClause.Occur.SHOULD); booleanQuery.add(termQuery2, BooleanClause.Occur.SHOULD);
iii. WildcardQuery ： 通配符的查詢
若是你想對某單詞進行通配符查詢，你能夠用WildcardQuery，通配符包括’?’匹配一個任意字符和’*’匹配零個或多個任意字符，例如你搜索’use*’，你可能找到’useful’或者’useless’：
Query query = new WildcardQuery(new Term("content", "use*");
iv. PhraseQuery ： 在指定的文字距離內出現的詞的查詢
你可能對中日關係比較感興趣，想查找‘中’和‘日’捱得比較近（5個字的距離內）的文章，超過這個距離的不予考慮，你能夠：
PhraseQuery query = new PhraseQuery();
query.setSlop(5);
query.add(new Term("content ", 「中」));
query.add(new Term(「content」, 「日」));
那麼它可能搜到「中日合做……」、「中方和日方……」，可是搜不到「中國某高層領導說日本欠扁」。
v. PrefixQuery : 查詢詞語是以某字符開頭的
若是你想搜以‘中’開頭的詞語，你能夠用PrefixQuery：
PrefixQuery query = new PrefixQuery(new Term("content ", "中");
vi. FuzzyQuery ： 類似的搜索
FuzzyQuery用來搜索類似的term，使用Levenshtein算法。假設你想搜索跟‘wuzza’類似的詞語，你能夠：
Query query = new FuzzyQuery(new Term("content", "wuzza");
你可能獲得‘fuzzy’和‘wuzzy’。
vii. TermRangeQuery : 範圍內搜索
你也許想搜索時間域從20060101到20060130之間的document，你能夠用TermRangeQuery：
TermRangeQuery query2 = TermRangeQuery.newStringRange("time", "20060101", "20060130", true, true);
最後的true表示用閉合區間。
viii.
h) TopDocs ：結果集，就是searcher搜索的結果，裏面就是一些ScoreDoc，這個對象的doc成員就是這個Id了！
要想獲得文章，那麼就得須要用這個Id去取文章了，searcher提供了用id獲得document的方法，因而就取到了數據了
i)
7.
使用多個Directory
由於咱們知道了FSDirectory是從文件系統的目錄中讀取數據，咱們總不可能每次查詢都從文件中讀取一次索引吧，因此咱們的作法應該是程序啓動時就把因此載入到內存，退出時再回寫，以下面的示意圖：
（也是別人的圖片）
使用內存的目錄:RAMDirectory
這樣能夠加快訪問速度
/** * 測試使用RAMDirectroy,也就是把生成的索引寫到內存而不是磁盤. * 運行這個方法，不報錯就表明成功了。 * 平時咱們是把索引文件寫道文件系統的，這裏就是寫道RAM中，之後讀取也 * 能夠在這個目錄讀取，快速！ * @throws IOException */ @Test public void testWriteInToRam() throws IOException { Directory directory = new RAMDirectory(); IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_45, analyzer); IndexWriter indexWriter = new IndexWriter(directory, config); indexWriter.addDocument(LuceneUtiles.getDocument(filePath)); indexWriter.close(); }
從文件系統的目錄載入到ram中，而後進行操做，最後保存回去
下面是實例代碼：
/** * 從磁盤的索引文件中讀取放入到RAM目錄， * 而後進行一系列的其餘操做。 * 退出時再把RAM的寫回文件系統。 * @throws IOException */ @Test public void testLoadIntoRamAndWriteBacktoFS() throws IOException { // 1.啓動時載入 Directory fsDir = FSDirectory.open( new File(indexPath)); RAMDirectory ramDir = new RAMDirectory(fsDir, new IOContext()); // 中途操做內存中的數據 IndexWriterConfig ramIndexWriterConfig = new IndexWriterConfig(Version.LUCENE_45, analyzer); IndexWriter ramIndexWriter = new IndexWriter(ramDir, ramIndexWriterConfig); // 添加一個文件,這好像沒有寫進去！！！！！！！ // 不是沒寫進去，而是這個方法沒有執行！由於test方法必定要加@Test註解！ ramIndexWriter.addDocument( LuceneUtiles.getDocument(filePath)); ramIndexWriter.close(); // 要先關閉，由於還有緩存。 // 2.退出時保存寫回，由於默認是CREATE_OR_APPEND // 因此這裏就會把AABBCC讀出來以後，加上DD // 那麼寫回去的數據時AABBCCDD，可是已經本地有存儲了， // 因此是append的方式，因而最後的結果是 // AABBCCAABBCCDD,就是重複的了。能夠search同一個關鍵字， // 看結果數量就知道了 // 會1條變3條，3條變7條，這種*2+1的形式 // // 咱們能夠每次都重寫，就能解決了 IndexWriterConfig fsIndexWriterConfig = new IndexWriterConfig(Version.LUCENE_45, analyzer); // 設置每次重寫 fsIndexWriterConfig.setOpenMode(OpenMode.CREATE); IndexWriter fsIndexWriter = new IndexWriter(fsDir, fsIndexWriterConfig); fsIndexWriter.addIndexes(ramDir); fsIndexWriter.close(); }
合併索引
由於每添加一個文檔的索引，都會創建多個小的文件存放索引，因此文檔多了以後，IO操做就很費時間了，因而咱們須要合併小文件，每個小文件就是segment。合併代碼以下,須要注意的是：
a) 咱們不能直接把索引庫打開，用Creat_OR_Append的方式強制寫回
他會出現疊加的問題
b) 要每次都用Create的方式寫回
可是不能再寫回本身的目錄，由於同一個目錄不支持又讀又寫，必須指定其餘的目錄
c) 指定其餘目錄存放Merge的索引，在寫回以前，應該把以前的索引添加到IndexWriter中，這樣才把會有數據
/** * 索引庫文件優化,貌似沒有提供保存優化的接口 * 多半內部封裝好的，外界不用管。只有一個強制合併的接口。 * 這就是用於合併。 * @throws IOException */ @Test public void testYouHua() throws IOException { Directory fsDirectory_Merged = FSDirectory.open( new File(indexPathMerged)); Directory fsDirectory = FSDirectory.open( new File(indexPath)); IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_45, analyzer); indexWriterConfig.setOpenMode(OpenMode.CREATE); IndexWriter indexWriter = new IndexWriter(fsDirectory_Merged, indexWriterConfig); // forceMerge(1)能夠把因此的段合併成1個，可是每次都會增長一份， // 就是像拷貝了一份加入同樣 // 難道是該指定OpenMode.CREATE,若是指定了CREATE， // 可是呢IndexWriter裏面沒有添加doc索引(即addDoc等方法)， // 因此寫進去就編程空索引庫了，因而須要先讀出來再寫回 // 因而還應該把索引加到writer裏面 // // 把本身加入進去，而後再用每次都create的辦法保持不會新增 // 注意不能添加到本身，因此還得新建一個庫才能夠,這樣就不會疊加了 indexWriter.addIndexes(fsDirectory); indexWriter.commit(); indexWriter.forceMerge( 1 ); indexWriter.close(); }
分詞器（Analyzer）
在前面的概念介紹中咱們已經知道了分析器的做用，就是把句子按照語義切分紅一個個詞語。英文切分已經有了很成熟的分析器： StandardAnalyzer，不少狀況下StandardAnalyzer是個不錯的選擇。甚至你會發現StandardAnalyzer也能對中文進行分詞。
可是咱們的焦點是中文分詞，StandardAnalyzer能支持中文分詞嗎？實踐證實是能夠的，可是效果並很差，搜索「若是」 會把「牛奶不若是汁好喝」也搜索出來，並且索引文件很大。那麼咱們手頭上還有什麼分析器可使用呢？core裏面沒有，咱們能夠在sandbox裏面找到兩個： ChineseAnalyzer和CJKAnalyzer。可是它們一樣都有分詞不許的問題。相比之下用StandardAnalyzer和 ChineseAnalyzer創建索引時間差很少，索引文件大小也差很少，CJKAnalyzer表現會差些，索引文件大且耗時比較長。
要解決問題，首先分析一下這三個分析器的分詞方式。StandardAnalyzer和ChineseAnalyzer都是把句子按單個字切分，也就是說 「牛奶不若是汁好喝」會被它們切分紅「牛 奶 不 如 果 汁 好 喝」；而CJKAnalyzer則會切分紅「牛奶 奶不 不如 若是 果汁 汁好好喝」。這也就解釋了爲何搜索「果汁」都能匹配這個句子。
以上分詞的缺點至少有兩個：匹配不許確和索引文件大。咱們的目標是將上面的句子分解成 「牛奶 不如 果汁好喝」。這裏的關鍵就是語義識別，咱們如何識別「牛奶」是一個詞而「奶不」不是詞語？咱們很天然會想到基於詞庫的分詞法，也就是咱們先獲得一個詞庫，裏面列舉了大部分詞語，咱們把句子按某種方式切分，當獲得的詞語與詞庫中的項匹配時，咱們就認爲這種切分是正確的。這樣切詞的過程就轉變成匹配的過程，而匹配的方式最簡單的有正向最大匹配和逆向最大匹配兩種，說白了就是一個從句子開頭向後進行匹配，一個從句子末尾向前進行匹配。基於詞庫的分詞詞庫很是重要，詞庫的容量直接影響搜索結果，在相同詞庫的前提下，聽說逆向最大匹配優於正向最大匹配。
固然還有別的分詞方法，這自己就是一個學科，我這裏也沒有深刻研究。回到具體應用，咱們的目標是能找到成熟的、現成的分詞工具，避免從新發明車輪。通過網上搜索，用的比較多的是中科院的 ICTCLAS和一個不開放源碼可是免費的JE-Analysis。ICTCLAS有個問題是它是一個動態連接庫， java調用須要本地方法調用，不方便也有安全隱患，並且口碑也確實不大好。JE-Analysis效果還不錯，固然也會有分詞不許的地方，相比比較方便放心。
下面就是分詞器的例子:
/** * <pre> * 測試分詞器的,分詞器分出來的關鍵字咱們叫作Token * 分詞器通常須要完成的工做是： * 1.詞組拆分 * 2.去掉停用詞 * 3.大小寫轉換 * 4.詞根還原 * * 對於中文分詞，一般有3種：單詞分詞，二分法，詞典分詞。 * 單詞分詞：就分紅一個一個的單個字，好比{ @link StandardAnalyzer}， * 如分紅 我-們-是-中-國-人 * 二分法分詞：按2個字分詞，即 咱們-們是-是中-中國-國人，實現是是 * { @link CJKAnalyzer} * 詞典分詞：按照某種算法構造詞，而後把詞拿到詞典裏面找，若是是詞，就算對了。 * 這是目前的好用的,能夠分詞成 咱們-中國人， * 好用的有【極易分詞：MMAnalyzer】,還有就是【庖丁分詞】目前沒有找到適用於4.5的。 * 還有一個牛的，是中科院的。能分出帽子和服裝。這些須要外界提供，須要下載jar包 * </pre> * * @author LiFeng * */ public class AnalyzerTest { String enString = " it must be made available under this Agreement,」+ 」 for more information : infor.doc " ; String zhString = " 你好，我是中國人，個人名字是李鋒。 " ; // 這個分詞器用於英文的，沒有形態還原 // 若是拿去分中文的話，每個字都被拆開了，測試下就曉得了 Analyzer enAnalyzer = new StandardAnalyzer(Version.LUCENE_45); // 能夠按點分開,沒有形態還原 // 對於中文的話，他也只按標點分：你好 我是中國人 個人名字是李鋒這3個token Analyzer simpleAnalyzer = new SimpleAnalyzer(Version.LUCENE_45); // 分中文就是二分法 // 分英文就是：單詞分開就完了 Analyzer cjkAnalyzer = new CJKAnalyzer(Version.LUCENE_45); // lucene4.5使用je-analysis-1.5.3.jar會崩潰，由於好多都改了 Analyzer jeAnalyzer = new MMAnalyzer(); // 詞庫分詞，好比極易 String testString = enString; Analyzer testAnalyzer = jeAnalyzer; /** * 獲得分詞器拆分出來的關鍵字(Token) * * @throws IOException */ @Test public void testGetTokens() throws IOException { // 獲得分出來的詞流 // fileName就是咱們當時建立document時同樣的意思 // 咱們這裏是要獲得分出的詞，跟他要歸屬哪一個filed無關，因此不用管 // 查看enAnalyzer的tokenStream的幫助，他叫們參考： // See the Analysis package documentation for some examples // demonstrating this. // 因而打開對於的文檔以下： // docs/core/org/apache/lucene/analysis/ // package-summary.html#package_description // 這裏面會有例子的！！！ // 下面是文檔的例子 { // 分詞器把文本分詞token流 TokenStream tokenStream = testAnalyzer.tokenStream( " myfield " , new StringReader(testString)); OffsetAttribute offsetAtt = tokenStream.addAttribute(OffsetAttribute. class ); try { // Resets this stream to the beginning. (Required) tokenStream.reset(); while (tokenStream.incrementToken()) { // 這裏傳入true就能夠看到更詳細的信息，調試用很好 // 打印token的信息 System.out.println( " token: " + tokenStream.reflectAsString( false )); // 能夠去除token存放的開始和結束 // System.out.println("token start offset: " // + offsetAtt.startOffset()); // System.out.println(" token end offset: " // + offsetAtt.endOffset()); } tokenStream.end(); } finally { // Release resources associated with this stream. tokenStream.close(); } } } }
高亮器highlighter
高亮器幫咱們作兩件事，第一件就是搜索結果的摘要，第二件事就是總體內容的關鍵字高亮。
高亮的原理就是在關鍵字周圍加上html標籤就是了。
String indexPath = " D:\\WorkspacesForAll\\Lucene\\Lucene-00010-HelloWorld\\lf_index " ; Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_45); @Test public void testHightlight() throws IOException, InvalidTokenOffsetsException { // 查詢fileContent字段的reproduce關鍵字 // 這裏的filed指定就是用於找到符合的document // 在高亮器初始化的時候Scorer類也用到了這個query // 其實過程就是： // 1.先把某個域出現關鍵字的doc所有找出來 // 2.再用高亮器，在找到的文章中， // 把指定域的內容提取一部分有關鍵字的文本，加上高亮就完畢了 Query query = new TermQuery( new Term( " fileContent " , " reproduce " )); // 高亮器的初始化準備 Highlighter highlighter = null ; { Formatter formatter = new SimpleHTMLFormatter( " <font color='red'> " , " </font> " ); Scorer fragmentScorer = new QueryScorer(query); highlighter = new Highlighter(formatter, fragmentScorer); // 摘要只取50個字符 Fragmenter fragmenter = new SimpleFragmenter( 50 ); highlighter.setTextFragmenter(fragmenter); } IndexReader indexReader = DirectoryReader.open( FSDirectory.open( new File(indexPath))); IndexSearcher searcher = new IndexSearcher(indexReader); TopDocs topDocs = searcher.search(query, null , 1000 ); System.out.println( " 找到【 " + topDocs.totalHits + " 】個： " ); for ( int i = 0 ; i < topDocs.scoreDocs.length; i ++ ) { int docId = topDocs.scoreDocs[i].doc; Document document = searcher.doc(docId); // 用高亮器返回摘要 // 參數1就是用指定的分詞器， // 參數2目前不知道咋用 // 參數3就是咱們須要處理哪一段文本的數據，把這段文件實現高亮並返回摘要 // 返回的就是高亮以後的摘要了，沒有就是null String ret = highlighter.getBestFragment( analyzer, " anyString " ,document.get( " fileContent " ) ); // String ret = highlighter.getBestFragment( // analyzer, "anyString",document.get("noThisFiled") ); if (ret != null ) { System.out.println(ret); } else { String defaultString = document.get( " fileContent " ); System.out.println( " 不高亮： " + defaultString); } } }
查詢
查詢有兩種大類：
第一種是使用查詢字符串，有查詢語法的。就像直接輸入sql語句同樣。
第二種就是查詢對象，即用query類來組合成複雜查詢。這個在概述的時候已經講過了。
對象查詢：
經常使用的有：TermQuery，BooleanQuery，WildcardQuery，PhraseQuery，PrefixQuery，TermRangeQuery等查詢。對象查詢對應的語法能夠直接打印出來system.out.println(query);
TermQuery:
若是你想執行一個這樣的查詢：「在content域中包含‘lucene’的document」，那麼你能夠用TermQuery：
Term t = new Term("content", " lucene");
Query query = new TermQuery(t);
BooleanQuery
多個query的【與或】關係的查詢
若是你想這麼查詢：「在content域中包含java或perl的document」，那麼你能夠創建兩個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(termQuery1, BooleanClause.Occur.SHOULD);
booleanQuery.add(termQuery2, BooleanClause.Occur.SHOULD);
反正這個就是lucene的東西,記到就是了
WildcardQuery
通配符的查詢
若是你想對某單詞進行通配符查詢，你能夠用WildcardQuery，通配符包括’?’匹配一個任意字符和’*’匹配零個或多個任意字符，例如你搜索’use*’，你可能找到’useful’或者’useless’：
Query query = new WildcardQuery(new Term("content", "use*");
PhraseQuery
在指定的文字距離內出現的詞的查詢
你可能對中日關係比較感興趣，想查找‘中’和‘日’捱得比較近（5個字的距離內）的文章，超過這個距離的不予考慮，你能夠：
PhraseQuery query = new PhraseQuery();
query.setSlop(5);
query.add(new Term("content ", 「中」));
query.add(new Term(「content」, 「日」));
那麼它可能搜到「中日合做……」、「中方和日方……」，可是搜不到「中國某高層領導說日本欠扁」。
PrefixQuery
查詢詞語是以某字符開頭的
若是你想搜以‘中’開頭的詞語，你能夠用PrefixQuery：
PrefixQuery query = new PrefixQuery(new Term("content ", "中");
FuzzyQuery ： 類似的搜索
FuzzyQuery用來搜索類似的term，使用Levenshtein算法。假設你想搜索跟‘wuzza’類似的詞語，你能夠：
Query query = new FuzzyQuery(new Term("content", "wuzza");
你可能獲得‘fuzzy’和‘wuzzy’。
TermRangeQuery
範圍查詢：範圍內搜索
你也許想搜索時間域從20060101到20060130之間的document，你能夠用TermRangeQuery：
TermRangeQuery query2 = TermRangeQuery.newStringRange("time", "20060101", "20060130", true, true);
最後的true表示用閉合區間。
查詢語法
官方的文檔裏面有: lucene-4.5.0\docs\index.html裏面就有以下的連接，能夠查看。
咱們直接調用query的toString就能夠獲得他們的查詢語法。
查詢某field的關鍵字，對應的對象就是TermQuery，咱們大印就知道了，格式是：
[域名字]:[查找的關鍵字]，好比fileContent:absc,就是查找fileContent域的關鍵字asbsc.
下面是總結：
若是遇到類找不到，那麼就多半是jar包有的沒有導入，下面的代碼就會說明這點
須要使用QueryParser須要的jar等下面都有說明：
lucene-queryparser-4.5.0.jar -à 用於QueryParser
lucene-queries-4.5.0.jar -à 有些查詢會用到，好比通配符查詢
lucene-memory-4.5.0.jar -à 有些查詢會用到，因此都導入就是了
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]」。
下面是代碼:
1 /** 2 3 * 學習查詢語句的例子。 4 5 * 查詢分兩種： 6 7 * 一個是使用查詢字符串。 8 9 * 另外一個就是使用對象來查詢，這個對象就是{ @link Query}對象的子類來查詢 10 11 * 12 13 * 對象查詢的話有幾個幾個很重要： 14 15 * @author LiFeng 16 17 * 18 19 */ 20 21 public class QueryTest { 22 23 String indexPath = 「 ****** Lucene - 00010 - HelloWorld\\lf_index " ; 24 25 Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_45); 26 27 /** 28 29 * 用查詢字符串查詢 30 31 * 若是qString中指定了查詢的域"fileContent:abdc"， 32 33 * 那麼QueryParser構造時的指定的域就被覆蓋。 34 35 * 若是qString中沒有指定域"abdc"，那麼就用QueryParser構造時的指定的域。 36 37 * @param qString 38 39 * @throws ParseException 40 41 */ 42 43 public void queryData(String qString) throws ParseException 44 45 { 46 47 // 若是qString沒有指定域就會用這個域來查詢 48 49 QueryParser parser = 50 51 new QueryParser(Version.LUCENE_45, " fileContent " , analyzer); 52 53 queryData(parser.parse(qString)); 54 55 } 56 57 /** 58 59 * 默認在fileContent域中查找高亮的數據 60 61 * @param query 62 63 */ 64 65 public void queryData(Query query) 66 67 { 68 69 System.out.println( " Query: " + query); 70 71 String fieldForHighLight = " fileContent " ; 72 73 // 高亮器的初始化準備 74 75 Highlighter highlighter = null ; 76 77 { 78 79 Formatter formatter = new SimpleHTMLFormatter( 80 81 " <font color='red'> " , " </font> " ); 82 83 Scorer fragmentScorer = new QueryScorer(query); 84 85 highlighter = new Highlighter(formatter, fragmentScorer); 86 87 // 摘要只取50個字符 88 89 Fragmenter fragmenter = new SimpleFragmenter( 50 ); highlighter.setTextFragmenter(fragmenter); 90 91 } 92 93 IndexReader indexReader = null ; 94 95 try { 96 97 indexReader = DirectoryReader.open( 98 99 FSDirectory.open( new File(indexPath))); 100 101 IndexSearcher searcher = new IndexSearcher(indexReader); 102 103 TopDocs topDocs = searcher.search(query, 1000 ); 104 105 // 打印結果 106 107 { 108 109 System.out.println( " 總共有【 " + topDocs.totalHits + 110 111 " 】條匹配結果 " ); 112 113 // 這是返回的數據 114 115 for ( int i = 0 ; i < topDocs.scoreDocs.length; i ++ ) { 116 117 int docId = topDocs.scoreDocs[i].doc; 118 119 Document hittedDocument = searcher.doc(docId); 120 121 // 用高亮器返回摘要 122 123 // 參數1就是用指定的分詞器， 124 125 // 參數2目前不知道咋用 126 127 // 參數3就是咱們須要處理哪一段文本的數據， 128 129 // 把這段文件實現高亮並返回摘要 130 131 // 返回的就是高亮以後的摘要了，沒有就是null 132 133 String ret = highlighter.getBestFragment( 134 135 analyzer, 136 137 " anyString " , 138 139 hittedDocument.get(fieldForHighLight) ); 140 141 if (ret != null ) { 142 143 System.out.println(ret); 144 145 } else { // 沒有找到就輸出全文 146 147 String defaultString = 148 149 hittedDocument.get(fieldForHighLight); 150 151 System.out.println( " 不高亮： " + defaultString); 152 153 } 154 155 } 156 157 } 158 159 indexReader.close(); 160 161 indexReader = null ; 162 163 } catch (Exception e) { 164 165 e.printStackTrace(); 166 167 } finally 168 169 { 170 171 if (indexReader != null ) { 172 173 try { 174 175 indexReader.close(); 176 177 } catch (IOException e) { 178 179 e.printStackTrace(); 180 181 } 182 183 } 184 185 } 186 187 } 188 189 /** 190 191 * 要使用QueryParser,須要導入包： 192 193 * lucene-4.5.0\queryparser\lucene-queryparser-4.5.0.jar 194 195 * 196 197 * 發現於demon的SearchFiles.java,用的是： 198 199 * org.apache.lucene.queryparser.classic.QueryParser 200 201 * @throws ParseException 202 203 */ 204 205 @Test 206 207 public void queryByQueryString() throws ParseException 208 209 { 210 211 // 查詢字符串,這裏關鍵字大寫就能夠了，由於通過了分詞器 212 213 String qString = " fileContent:Reproduce " ; // 用指定的域 214 215 String qStringNoField = " Reproduce " ; // 用Parser默認的域 216 217 queryData(qStringNoField); 218 219 } 220 221 @Test 222 223 public void termQuery() 224 225 { 226 227 // 查詢fileContent域的reproduce 228 229 // 注意term裏面是沒有通過分詞器的，由於全部的索引是小寫 230 231 // 因此這裏須要用小寫查詢 232 233 Query query = new TermQuery( 234 235 new Term( " fileContent " , " reproduce " )); 236 237 queryData(query); 238 239 } 240 241 /** 242 243 * 短語查詢，注意這裏有引號 244 245 * 246 247 * fileContent:"advertising features"~5 248 249 * fileContent:"advertising ? ? features" 250 251 */ 252 253 @Test 254 255 public void phraseQuery() 256 257 { 258 259 // 好比查詢advertising materials mentioning features 260 261 // 262 263 // 再好比想查詢lucene *** *** 教程 264 265 // 那麼咱們能夠查詢關鍵詞"lucene"和關鍵詞"教程", 266 267 // 而後他們相距5個詞之類就好了 268 269 // 270 271 // 查詢語句是Query:fileContent:"advertising features"~5 272 273 PhraseQuery query = new PhraseQuery(); 274 275 query.setSlop( 5 ); // 最多間隔5個字 276 277 query.add( new Term( " fileContent " , " advertising " )); 278 279 query.add( new Term( " fileContent " , " features " )); 280 281 queryData(query); 282 283 // 也能夠固定位置的指定,以下面0號位置就是advertising， 284 285 // 第3號位置是features。注意這個位置是相對起來的。中間隔2個. 286 287 // 咱們經過打印出出來的語句就能夠看出： 288 289 // fileContent:"advertising ? ? features",也就是指定了只隔2個 290 291 // 改爲0,4就不行了。這要的是精確的配置關係 292 293 PhraseQuery query2 = new PhraseQuery(); 294 295 query2.add( new Term( " fileContent " , " advertising " ), 0 ); 296 297 query2.add( new Term( " fileContent " , " features " ), 3 ); 298 299 // 就會找到reproduce關鍵字，也就是至關於把reproduce關鍵字的找出來 300 301 queryData(query2); 302 303 } 304 305 /** 306 307 * 關鍵字都是大寫，這裏的"TO"就是 308 309 * fileSize:[0 TO 3] 兩邊包含 310 311 * fileSize:{0 TO 3] 不包含左邊，包含右邊 312 313 */ 314 315 @Test 316 317 public void rangeQuery() 318 319 { 320 321 // 咱們文件的大小是2845，若是咱們搜索0到100000是搜不到的， 322 323 // 由於作的是字符串的比較，也就是 324 325 // "0","100000","2845"比較，明顯2845最大，不在這個區間了， 326 327 // 因此咱們查不到 328 329 // 330 331 // 若是改爲0,3之間就能夠查到 332 333 TermRangeQuery query = TermRangeQuery.newStringRange( 334 335 " fileSize " , " 0 " , " 3 " , true , true ); 336 337 queryData(query); 338 339 TermRangeQuery query2 = TermRangeQuery.newStringRange( 340 341 " fileSize " , " 0 " , " 3 " , false , true ); 342 343 queryData(query2); 344 345 } 346 347 /** 348 349 * 數字範圍的查詢，沒查到，到時再修改！！！！！！ 350 351 * 352 353 * fileSize:[0 TO 30000] 354 355 */ 356 357 @Test 358 359 public void rangeQuery2() 360 361 { 362 363 // 由於作的是字符串比較 364 365 // 因此對於數字應該保證字符寬度同樣纔對,可是數據一變， 366 367 // 咱們就又要全體都改，因而有下面的辦法,以下分析： 368 369 // 由於java的long就是最長的數據，他的十進制有19位， 370 371 // 因此咱們把全部的數字擴展成19爲的字符串就能夠解決。 372 373 // 固然Lucene已經幫咱們提供了。 374 375 // 376 377 // 對於數字的類型，lucene提供了一個工具類幫咱們處理： 378 379 // 目前沒有找到或者不會用 380 381 // precisionStep是精度，須要 >= 1 382 383 // 可是這個查不到.....???? 384 385 Query query2 = NumericRangeQuery.newLongRange( 386 387 " fileSize " , 0L , 30000L , true , true ); 388 389 queryData(query2); 390 391 } 392 393 /** 394 395 * 通配符查詢,模糊匹配的一個關鍵字， 396 397 * 而：PhraseQuery短語查詢是多個關鍵字的間隔。 398 399 * 400 401 * ? : 表明任意一個字符 402 403 * * ： 表明0到n個任意字符 404 405 * 406 407 * fileContent:reprod* 408 409 * fileContent:repro??ce 410 411 * fileContent:repro???ce 412 413 * reproduce*:reprod* 414 415 * 416 417 * java.lang.NoClassDefFoundError: 418 419 * org/apache/lucene/queries/CommonTermsQuery 420 421 * 那麼須要導入lucene-4.5.0\queries\lucene-queries-4.5.0.jar 422 423 * 424 425 * java.lang.NoClassDefFoundError: 426 427 * org/apache/lucene/index/memory/MemoryIndex 428 429 * 那麼須要導入lucene-4.5.0\memory\lucene-memory-4.5.0.jar 430 431 * 432 433 * 因此對於那些NoClassDefFoundError必定是jar沒有導全，導入便可解決。 434 435 * 436 437 * 這裏就是查詢reprod開頭的關鍵字 438 439 */ 440 441 @Test 442 443 public void wildcardQuery() 444 445 { 446 447 // 這個跟前綴查詢同樣.. 448 449 WildcardQuery query = new WildcardQuery( 450 451 new Term( " fileContent " , " reprod* " )); 452 453 queryData(query); 454 455 WildcardQuery query2 = new WildcardQuery( 456 457 new Term( " fileContent " , " repro??ce " )); 458 459 queryData(query2); 460 461 // 這個就查不到了 462 463 WildcardQuery query3 = new WildcardQuery( 464 465 new Term( " fileContent " , " repro???ce " )); 466 467 queryData(query3); 468 469 WildcardQuery query4 = new WildcardQuery( 470 471 new Term( " reproduce* " , " reprod* " )); 472 473 queryData(query4); 474 475 } 476 477 /** 478 479 * 多個查詢的boolean控制 480 481 * +fileContent:reprod* fileSize:[0 TO 3] 482 483 * -fileContent:"advertising features"~5 484 485 * 486 487 * + ： 就是Must 也能夠寫成AND 488 489 * - : 就是Must_Not 也能夠寫成NOT 490 491 * 空格 ： 就是Should 也能夠寫成OR 492 493 * 494 495 * MUST : 必須知足條件 496 497 * MUST_NOT : 必定不知足 498 499 * SHOULD : 就是或的意思 500 501 * @throws ParseException 502 503 */ 504 505 @Test 506 507 public void booleanQuery() throws ParseException 508 509 { 510 511 BooleanQuery query = new BooleanQuery(); 512 513 // 必定有reprod* 514 515 WildcardQuery must = new WildcardQuery( 516 517 new Term( " fileContent " , " reprod* " )); 518 519 // 文件大小必定在0,3的字符串之間 520 521 TermRangeQuery must_size = TermRangeQuery.newStringRange( 522 523 " fileSize " , " 0 " , " 3 " , true , true ); 524 525 // 有這個條就查不到了嘛 526 527 PhraseQuery not = new PhraseQuery(); 528 529 not.setSlop( 5 ); // 最多間隔5個字 530 531 not.add( new Term( " fileContent " , " advertising " )); 532 533 not.add( new Term( " fileContent " , " features " )); 534 535 query.add( new BooleanClause(must, Occur.MUST)); 536 537 query.add( new BooleanClause(must_size, Occur.SHOULD)); 538 539 query.add( new BooleanClause(not, Occur.MUST_NOT)); 540 541 queryData(query); 542 543 System.out.println( " 下面是使用AND，NOT，OR執行 " ); 544 545 // 兩條件相與 546 547 queryData( " fileContent:reprod* AND fileSize:[0 TO 3] " ); 548 549 System.out.println( 550 551 " ------------------李鋒------分界線----------- " ); 552 553 // 兩條件相或 554 555 queryData( " fileContent:reprod* OR fileSize:[0 TO 3] " ); 556 557 System.out.println( 558 559 " ------------------李鋒------分界線----------- " ); 560 561 // A !B 562 563 queryData( " fileContent:reprod* NOT fileSize:[0 TO 3] " ); 564 565 System.out.println( 566 567 " ------------------李鋒------分界線----------- " ); 568 569 // !A B 570 571 queryData( " NOT fileContent:reprod* AND fileSize:[0 TO 3] " ); 572 573 // 下面使用括號來用改變優先級 574 575 System.out.println( " \n使用括號 " ); 576 577 queryData( " fileContent:reprod* AND」+ 578 579 」 (fileSize:[ 0 TO 3 ] OR fileContent:reprod ? ) " ); 580 581 } 582 583 } 584 585
指定排序和相關度權重
排序分兩種，一個是修改相關度的權重來影響排序，另外一個是使用指定的域來排序。
相關度排序
Lucene 在返回查找結果的時候，會根據相關度進行打分，得分越高的就越在前面，這是默認的處理。相關度的算法不少，好比用n維空間的cos求夾角的方式。
相關度又分兩種，一種是域的相關度，另外一種是doc的相關度。修改相關度的就是boost變量。
1. 域的相關度
a) 在建立查詢語句的時候用Map<String, Float> boosts指定
b) 在建立索引的時候指定，這樣就固化到了索引文件，須要重建索引才能夠修改，或者查詢時從新指定也行。((Field)field).setBoost(1.0f);
下面是第一種的代碼，第二種的就是((Field)field).setBoost(1.0f);便可。
1 /** 2 3 * 設置域的權重,在查詢時指定 4 5 * fileContent:abcdefg.txt filePath:abcdefg.txt^3.0 6 7 * 這就是設置權重的查詢語句。 8 9 * 10 11 * 也能夠在建立索引時，給field設置權重，那麼就固化到索引文件了。 12 13 * 14 15 * @throws InvalidTokenOffsetsException 16 17 * @throws IOException 18 19 * @throws ParseException 20 21 */ 22 23 @Test 24 25 public void fieldBoostTest() throws IOException, 26 27 InvalidTokenOffsetsException, ParseException 28 29 { 30 31 String[] fileds = new String[]{ " fileContent " , " filePath " }; 32 33 Map < String, Float > boosts = new HashMap < String, Float > (); 34 35 // 設置filePath的權重高些,3.0f至關大的影響 36 37 boosts.put( " fileContent " , 1.0f ); 38 39 boosts.put( " filePath " , 3.0f ); 40 41 // 至關於(fileContent:****) (filePath:****) 42 43 // 也就是查詢fileContent或者filePath 44 45 MultiFieldQueryParser parser = new MultiFieldQueryParser( 46 47 Version.LUCENE_45, fileds, analyzer,boosts); 48 49 query(parser.parse( " abcdefg.txt " )); 50 51 // // 上面的至關於下面的 52 53 // { 54 55 // query("fileContent:abcdefg.txt filePath:abcdefg.txt^3.0"); 56 57 // query("fileContent:abcdefg.txt OR filePath:abcdefg.txt^3.0"); 58 59 // } 60 61 } 62 63
2. Doc的相關度，咱們能夠指定某個doc的權重比其餘的權重高，這樣這篇文字的索引位置就比其餘的相對靠前了。
實現方法：目前還沒找到。
指定域排序Sort
咱們能夠指定某個域升降序排列，就像order by同樣。
1 // 排序 2 3 Sort sort = new Sort(); 4 5 // 就是大小升序 6 7 // sort.setSort(new SortField("fileSize", Type.LONG,false)); 8 9 // 就是大小降序 10 11 sort.setSort( new SortField( " fileSize " , Type.LONG, true )); 12 13 TopDocs topDocs = searcher.search(query, 1000 ,sort); 14 15 // 這個簡單，直接指定傳給IndexSeacher便可 16 17 // 有時你想要一個排好序的結果集，就像SQL語句的「order by」，lucene能作到：經過Sort。 18 19 Sort sort = new Sort(「time」); // 至關於SQL的「order by time」 20 21 Sort sort = new Sort(「time」, true ); // 至關於SQL的「order by time desc」 22 23 // 下面是一個完整的例子： 24 25 Directory dir = FSDirectory.getDirectory(PATH, false ); 26 27 IndexSearcher is = new IndexSearcher(dir); 28 29 QueryParser parser = new QueryParser( " content " , new StandardAnalyzer()); 30 31 Query query = parser.parse( " title:lucene content:lucene " ); 32 33 RangeFilter filter = new RangeFilter( " time " , " 20060101 " , " 20060230 " , true , true ); 34 35 Sort sort = new Sort(「time」); 36 37 Hits hits = is.search(query, filter, sort); 38 39 for ( int i = 0 ; i < hits.length(); i ++ ) 40 41 { 42 43 Document doc = hits.doc(i); 44 45 System.out.println(doc.get( " title " ); 46 47 } 48 49 is.close(); 50 51
過濾器Filter
就是過濾一些東西，咱們在查詢的時候能夠指定：
// 使用過濾器
Filter filter = NumericRangeFilter.newLongRange(
"fileSize", 111L, 800L, true, true);
TopDocs topDocs = searcher.search(query, filter,1000);
這個就過濾文件大小，可是測試結果是查不到，須要再想一下。
filter 的做用就是限制只查詢索引的某個子集，它的做用有點像SQL語句裏的where，但又有區別，它不是正規查詢的一部分，只是對數據源進行預處理，而後交給查詢語句。注意它執行的是預處理，而不是對查詢結果進行過濾，因此使用filter的代價是很大的，它可能會使一次查詢耗時提升一百倍。
最經常使用的filter是RangeFilter和QueryFilter。RangeFilter是設定只搜索指定範圍內的索引；QueryFilter是在上次查詢的結果中搜索。
Filter的使用很是簡單，你只需建立一個filter實例，而後把它傳給searcher。繼續上面的例子，查詢「時間在20060101到20060130之間的文章」除了將限制寫在query string中，你還能夠寫在RangeFilter中：
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";
RangeFilter filter = new RangeFilter("time", "20060101", "20060230", true, true);
Hits hits = is.search(query, filter);
for (int i = 0; i < hits.length(); i++)
{
Document doc = hits.doc(i);
System.out.println(doc.get("title");
}
is.close();
學習途徑：
1. 看官方的例子程序，裏面有生成索引，查詢的方法，還有高級知識！
裏面講了生成doc時不一樣的域能夠用不用的子類域來封裝，好比文StringField，LongField，TextField，等等很好！
2. 官方文檔，裏面查詢API，當前連接了源碼以後這個文檔就沒多大意義了
3. 看官方文檔指定的wiki：
http://wiki.apache.org/lucene-java/FrontPage?action=show&redirect=FrontPageEN
4. 看Lucene 原理與代碼分析完整版.pdf
性能優化
一直到這裏，咱們仍是在討論怎麼樣使lucene跑起來，完成指定任務。利用前面說的也確實能完成大部分功能。可是測試代表lucene的性能並非很好，在大數據量大併發的條件下甚至會有半分鐘返回的狀況。另外大數據量的數據初始化創建索引也是一個十分耗時的過程。那麼如何提升lucene的性能呢？下面從優化建立索引性能和優化搜索性能兩方面介紹。
優化建立索引性能
這方面的優化途徑比較有限，IndexWriter提供了一些接口能夠控制創建索引的操做，另外咱們能夠先將索引寫入RAMDirectory，再批量寫入FSDirectory，無論怎樣，目的都是儘可能少的文件IO，由於建立索引的最大瓶頸在於磁盤IO。另外選擇一個較好的分析器也能提升一些性能。
經過設置IndexWriter的參數優化索引創建
setMaxBufferedDocs(int maxBufferedDocs)
控制寫入一個新的segment前內存中保存的document的數目，設置較大的數目能夠加快建索引速度，默認爲10。
setMaxMergeDocs(int maxMergeDocs)
控制一個segment中能夠保存的最大document數目，值較小有利於追加索引的速度，默認Integer.MAX_VALUE，無需修改。
setMergeFactor(int mergeFactor)
控制多個segment合併的頻率，值較大時創建索引速度較快，默認是10，能夠在創建索引時設置爲100。
經過RAMDirectory緩寫提升性能
咱們能夠先把索引寫入RAMDirectory，達到必定數量時再批量寫進FSDirectory，減小磁盤IO次數。
FSDirectory fsDir = FSDirectory.getDirectory("/data/index", true);
RAMDirectory ramDir = new RAMDirectory();
IndexWriter fsWriter = new IndexWriter(fsDir, new StandardAnalyzer(), true);
IndexWriter ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);
while (there are documents to index)
{
... create Document ...
ramWriter.addDocument(doc);
if (condition for flushing memory to disk has been met)
{
fsWriter.addIndexes(new Directory[] { ramDir });
ramWriter.close();
ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);
}
}
選擇較好的分析器
這個優化主要是對磁盤空間的優化，能夠將索引文件減少將近一半，相同測試數據下由600M減小到380M。可是對時間並無什麼幫助，甚至會須要更長時間，由於較好的分析器須要匹配詞庫，會消耗更多cpu，測試數據用StandardAnalyzer耗時133分鐘；用MMAnalyzer耗時150分鐘。
優化搜索性能
雖然創建索引的操做很是耗時，可是那畢竟只在最初建立時才須要，平時只是少許的維護操做，更況且這些能夠放到一個後臺進程處理，並不影響用戶搜索。咱們建立索引的目的就是給用戶搜索，因此搜索的性能纔是咱們最關心的。下面就來探討一下如何提升搜索性能。
將索引放入內存
這是一個最直觀的想法，由於內存比磁盤快不少。Lucene提供了RAMDirectory能夠在內存中容納索引：
Directory fsDir = FSDirectory.getDirectory(「/data/index/」, false);
Directory ramDir = new RAMDirectory(fsDir);
Searcher searcher = new IndexSearcher(ramDir);
可是實踐證實RAMDirectory和FSDirectory速度差很少，當數據量很小時二者都很是快，當數據量較大時（索引文件400M）RAMDirectory甚至比FSDirectory還要慢一點，這確實讓人出乎意料。
並且lucene的搜索很是耗內存，即便將400M的索引文件載入內存，在運行一段時間後都會out of memory，因此我的認爲載入內存的做用並不大。
優化時間範圍限制
既然載入內存並不能提升效率，必定有其它瓶頸，通過測試發現最大的瓶頸竟然是時間範圍限制，那麼咱們能夠怎樣使時間範圍限制的代價最小呢？
當須要搜索指定時間範圍內的結果時，能夠：
一、用RangeQuery，設置範圍，可是RangeQuery的實現其實是將時間範圍內的時間點展開，組成一個個BooleanClause加入到 BooleanQuery中查詢，所以時間範圍不可能設置太大，經測試，範圍超過一個月就會拋 BooleanQuery.TooManyClauses，能夠經過設置 BooleanQuery.setMaxClauseCount (int maxClauseCount)擴大，可是擴大也是有限的，而且隨着maxClauseCount擴大，佔用內存也擴大
二、用 RangeFilter代替RangeQuery，經測試速度不會比RangeQuery慢，可是仍然有性能瓶頸，查詢的90%以上時間耗費在 RangeFilter，研究其源碼發現RangeFilter其實是首先遍歷全部索引，生成一個BitSet，標記每一個document，在時間範圍內的標記爲true，不在的標記爲false，而後將結果傳遞給Searcher查找，這是十分耗時的。
三、進一步提升性能，這個又有兩個思路：
a、緩存Filter結果。既然RangeFilter的執行是在搜索以前，那麼它的輸入都是必定的，就是IndexReader，而 IndexReader是由Directory決定的，因此能夠認爲RangeFilter的結果是由範圍的上下限決定的，也就是由具體的 RangeFilter對象決定，因此咱們只要以RangeFilter對象爲鍵，將filter結果BitSet緩存起來便可。lucene API 已經提供了一個CachingWrapperFilter類封裝了Filter及其結果，因此具體實施起來咱們能夠 cache CachingWrapperFilter對象，須要注意的是，不要被CachingWrapperFilter的名字及其說明誤導， CachingWrapperFilter看起來是有緩存功能，但的緩存是針對同一個filter的，也就是在你用同一個filter過濾不一樣 IndexReader時，它能夠幫你緩存不一樣IndexReader的結果，而咱們的需求偏偏相反，咱們是用不一樣filter過濾同一個 IndexReader，因此只能把它做爲一個封裝類。
b、下降時間精度。研究Filter的工做原理能夠看出，它每次工做都是遍歷整個索引的，因此時間粒度越大，對比越快，搜索時間越短，在不影響功能的狀況下，時間精度越低越好，有時甚至犧牲一點精度也值得，固然最好的狀況是根本不做時間限制。
下面針對上面的兩個思路演示一下優化結果（都採用800線程隨機關鍵詞隨即時間範圍）：
第一組，時間精度爲秒：
方式 直接用RangeFilter 使用cache 不用filter
平均每一個線程耗時 10s 1s 300ms
第二組，時間精度爲天
方式 直接用RangeFilter 使用cache 不用filter
平均每一個線程耗時 900ms 360ms 300ms
由以上數據能夠得出結論：
一、 儘可能下降時間精度，將精度由秒換整天帶來的性能提升甚至比使用cache還好，最好不使用filter。
二、 在不能下降時間精度的狀況下，使用cache能帶了10倍左右的性能提升。
使用更好的分析器
這個跟建立索引優化道理差很少，索引文件小了搜索天然會加快。固然這個提升也是有限的。較好的分析器相對於最差的分析器對性能的提高在20%如下。
一些經驗
關鍵詞區分大小寫
OR AND TO等關鍵詞是區分大小寫的，lucene只認大寫的，小寫的當作普通單詞。
讀寫互斥性
同一時刻只能有一個對索引的寫操做，在寫的同時能夠進行搜索
文件鎖
在寫索引的過程當中強行退出將在tmp目錄留下一個lock文件，使之後的寫操做沒法進行，能夠將其手工刪除
時間格式
lucene只支持一種時間格式yyMMddHHmmss，因此你傳一個yy-MM-dd HH:mm:ss的時間給lucene它是不會看成時間來處理的
設置boost
有些時候在搜索時某個字段的權重須要大一些，例如你可能認爲標題中出現關鍵詞的文章比正文中出現關鍵詞的文章更有價值，你能夠把標題的boost設置的更大，那麼搜索結果會優先顯示標題中出現關鍵詞的文章（沒有使用排序的前題下）。使用方法：
Field. setBoost(float boost);默認值是1.0，也就是說要增長權重的須要設置得比1大。
Compass框架
還沒學
- 1. lucene--筆記
- 2. Lucene使用筆記
- 3. Lucene學習筆記
- 4. lucene學習筆記一之初識lucene
- 5. lucene學習筆記一(初始lucene)
- 6. lucene簡明學習筆記
- 7. Lucene學習筆記（一）
- 8. Lucene學習筆記(1)
- 9. Lucene 學習筆記（一）
- 10. Lucene筆記系列（3）——Lucene的文件結構
- 更多相關文章...
- • ASP.NET Razor - 標記 - ASP.NET 教程
- • ADO 添加記錄 - ADO 教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • Docker容器實戰(六) - 容器的隔離與限制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. lucene--筆記
- 2. Lucene使用筆記
- 3. Lucene學習筆記
- 4. lucene學習筆記一之初識lucene
- 5. lucene學習筆記一(初始lucene)
- 6. lucene簡明學習筆記
- 7. Lucene學習筆記（一）
- 8. Lucene學習筆記(1)
- 9. Lucene 學習筆記（一）
- 10. Lucene筆記系列（3）——Lucene的文件結構