Lucene 4.7 學習及實例demo

　　很早就聽說Lucene的大名了，但一直沒空研究，今天抽了一個下午時間，學習了一下Lucene，寫了一個簡單的Demo，總的感受是使用起來簡單方便，在使用之前，首先要理解以下關鍵的類：

Document 
Document 是用來描述文檔的，這里的文檔可以指一個 HTML 頁面，一封電子郵件，或者是一個文本文件。一個 Document 對象由多個 Field 對象組成的。可以把一個 Document 對象想象成數據庫中的一個記錄，而每個 Field 對象就是記錄的一個字段。 

Field 
Field 對象是用來描述一個文檔的某個屬性的，比如一封電子郵件的標題和內容可以用兩個 Field 對象分別描述。 

Analyzer 
在一個文檔被索引之前，首先需要對文檔內容進行分詞處理，這部分工作就是由 Analyzer 來做的。Analyzer 類是一個抽象類，它有多個實現。針對不同的語言和應用需要選擇適合的 Analyzer。Analyzer 把分詞后的內容交給 IndexWriter 來建立索引。 

IndexWriter 
IndexWriter 是 Lucene 用來創建索引的一個核心的類，他的作用是把一個個的 Document 對象加到索引中來。 

Directory 
這個類代表了 Lucene 的索引的存儲的位置，這是一個抽象類，它目前有兩個實現，第一個是 FSDirectory，它表示一個存儲在文件系統中的索引的位置。第二個是 RAMDirectory，它表示一個存儲在內存當中的索引的位置。 

Query 
這是一個抽象類，他有多個實現，比如 TermQuery, BooleanQuery, PrefixQuery. 這個類的目的是把用戶輸入的查詢字符串封裝成 Lucene 能夠識別的 Query。 

IndexSearcher 
IndexSearcher 是用來在建立好的索引上進行搜索的。它只能以只讀的方式打開一個索引，所以可以有多個 IndexSearcher 的實例在一個索引上進行操作。

Hits 
Hits 是用來保存搜索結果的。 

 

理解了這些類之后，我寫了一個簡單的demo，包括索引構建和索引搜索，以后如果要做復雜的搜索，可以根據這個demo做擴展，是不是很簡單哈。

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
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.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

/**
 * Lucene Demo
 * Author: herui
 * DateTime: 2014-3-31 下午3:39:54
 */
public class LuceneDemo {
    
    /**
     * 根據內容，構建索引
     * @param analyzer
     * @param directory
     * @param items
     * @return
     */
    private boolean buildIndexer(Analyzer analyzer, Directory directory, List<Item> items) {
        IndexWriter iwriter = null;
        try {
            // 配置索引
            iwriter = new IndexWriter(directory, new IndexWriterConfig(
                    Version.LUCENE_47, analyzer));
            // 刪除所有document
            iwriter.deleteAll();
            // 將文檔信息存入索引
            Document doc[] = new Document[items.size()];
            for (int i = 0; i < items.size(); i++) {
                doc[i] = new Document();
                
                Item item = items.get(i);
                java.lang.reflect.Field[] fields = item.getClass().getDeclaredFields();
                for (java.lang.reflect.Field field : fields) {
                    String fieldName = field.getName();
                    String getMethodName = "get"+toFirstLetterUpperCase(fieldName);
                    Object obj = item.getClass().getMethod(getMethodName).invoke(item);
                    doc[i].add(new Field(fieldName, (String)obj, TextField.TYPE_STORED));
                }
                
                iwriter.addDocument(doc[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            try {
                iwriter.close();
            } catch (IOException e) {
            }
        }
        return true;
    }
    
    /**
     * 根據keyword搜索索引
     * @param analyzer
     * @param directory
     * @param keyword
     * @return
     */
    public List<Item> searchIndexer(Analyzer analyzer, Directory directory, String keyword) {
        DirectoryReader ireader = null;
        List<Item> result = new ArrayList<Item>();
        try {
            // 設定搜索目錄
            ireader = DirectoryReader.open(directory);
            IndexSearcher isearcher = new IndexSearcher(ireader);

            // 對多field進行搜索
            java.lang.reflect.Field[] fields = Item.class.getDeclaredFields();
            int length = fields.length;
            String[] multiFields = new String[length];
            for (int i = 0; i < length; i++) {
                multiFields[i] = fields[i].getName();
            }
            MultiFieldQueryParser parser = new MultiFieldQueryParser(
                    Version.LUCENE_47, multiFields, analyzer);

            // 設定具體的搜索詞
            Query query = parser.parse(keyword);
            ScoreDoc[] hits = isearcher.search(query, null, 10).scoreDocs;

            for (int i = 0; i < hits.length; i++) {
                Document hitDoc = isearcher.doc(hits[i].doc);
                Item item = new Item();
                for (String field : multiFields) {
                    String setMethodName = "set"+toFirstLetterUpperCase(field);
                    item.getClass().getMethod(setMethodName, String.class).invoke(item, hitDoc.get(field));
                }
                result.add(item);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                ireader.close();
                directory.close();
            } catch (IOException e) {
            }
        }
        return result;
    }
    
    /**
     * 首字母轉大寫
     * @param str
     * @return
     */
    public static String toFirstLetterUpperCase(String str) {  
        if(str == null || str.length() < 2){  
            return str;  
        }  
        return str.substring(0, 1).toUpperCase() + str.substring(1, str.length());  
     }  
    
    public static void main(String[] args) throws Exception {
        LuceneDemo demo = new LuceneDemo();
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
        
        List<Item> items = new ArrayList<Item>();
        items.add(new Item("1", "first", "This is the text to be greatly indexed."));
        items.add(new Item("2", "second", "This is great"));
        items.add(new Item("3", "third", "I love apple and pear. "));
        items.add(new Item("4", "four", "我是中國人"));
        items.add(new Item("5", "five", "我叫何瑞"));
        
        // 索引存到內存中的目錄
        //Directory directory = new RAMDirectory();
        // 索引存儲到硬盤
        File file = new File("d:/lucene");
        Directory directory = FSDirectory.open(file);
        demo.buildIndexer(analyzer, directory, items);
        List<Item> result = demo.searchIndexer(analyzer, directory, "中國");
        
        for (Item item : result) {
            System.out.println(item.toString());
        }
    }
}

Item.java

public class Item {
    
    private String id;
    private String title;
    private String content;
    
    public Item() {
    }
    
    public Item(String id, String title, String content) {
        this.id = id;
        this.title = title;
        this.content = content;
    }
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[id=").append(id).append(",title=").append(title)
            .append(",content=").append(content).append("]");
        return sb.toString();
    }
}