Lucene是apache軟件基金會世界盃足球競猜網站開發dsluntan.com 企娥3393756370世界盃足球競猜網站開發發佈的一個開放源代碼的全文檢索引擎工具包，由資深全文檢索專家Doug Cutting所撰寫,它是一個全文檢索引擎的架構，提供了完整的創建索引和查詢索引，以及部分文本分析的引擎，Lucene的目的是爲軟件開發人員提供一個簡單易用的工具包，以方便在目標系統中實現全文檢索的功能，或者是以此爲基礎建立起完整的全文檢索引擎，Lucene在全文檢索領域是一個經典的祖先，現在很多檢索引擎都是在其基礎上創建的，思想是相通的。

Lucene是根據關健字來搜索的文本搜索工具，只能在某個網站內部搜索文本內容，不能跨網站搜索

既然談到了網站內部的搜索，那麼我們就談談我們熟悉的百度、google那些搜索引擎又是基於什麼搜索的呢....

從圖上已經看得很清楚，baidu、google等搜索引擎其實是通過網絡爬蟲的程序來進行搜索的...

爲什麼我們要用Lucene？

在介紹Lucene的時候，我們已經說了：Lucene又不是搜索引擎，僅僅是在網站內部進行文本的搜索。那我們爲什麼要學他呢？？？

我們之前編寫納稅服務系統的時候，其實就已經使用過SQL來進行站內的搜索..

既然SQL能做的功能，我們還要學Lucene，爲什麼呢？？？

我們來看看我們用SQL來搜索的話，有什麼缺點：

（1）SQL只能針對數據庫表搜索，不能直接針對硬盤上的文本搜索
（2）SQL沒有相關度排名
（3）SQL搜索結果沒有關健字高亮顯示
（4）SQL需要數據庫的支持，數據庫本身需要內存開銷較大，例如：Oracle
（5）SQL搜索有時較慢，尤其是數據庫不在本地時，超慢，例如：Oracle

我們來看看在baidu中搜索Lucene爲關鍵字搜索出的內容是怎麼樣的：

以上所說的，我們如果使用SQL的話，是做不到的。因此我們就學習Lucene來幫我們在站內根據文本關鍵字來進行搜索數據！

我們如果網站需要根據關鍵字來進行搜索，可以使用SQL，也可以使用Lucene...那麼我們Lucene和SQL是一樣的，都是在持久層中編寫代碼的。。

一、快速入門

接下來，我們就講解怎麼使用Lucene了.....在講解Lucene的API之前，我們首先來講講Lucene存放的究竟是什麼內容...我們的SQL使用的是數據庫中的內存，在硬盤中爲DBF文件...那麼我們Lucene內部又是什麼東西呢？？

Lucene中存的就是一系列的二進制壓縮文件和一些控制文件，它們位於計算機的硬盤上，
這些內容統稱爲索引庫，索引庫有二部份組成：

（1）原始記錄
- 存入到索引庫中的原始文本，例如：我是鍾福成
（2）詞彙表
- 按照一定的拆分策略（即分詞器）將原始記錄中的每個字符拆開後，存入一個供將來搜索的表

也就是說：Lucene存放數據的地方我們通常稱之爲索引庫，索引庫又分爲兩部分組成：原始記錄和詞彙表....

1.1原始記錄和詞彙表

當我們想要把數據存到索引庫的時候，我們首先存入的是將數據存到原始記錄上面去....

又由於我們給用戶使用的時候，用戶使用的是關鍵字來進行查詢我們的具體記錄。因此，我們需要把我們原始存進的數據進行拆分！將拆分出來的數據存進詞彙表中。

詞彙表就是類似於我們在學Oracle中的索引表，拆分的時候會給出對應的索引值。

一旦用戶根據關鍵字來進行搜索，那麼程序就先去查詢詞彙表中有沒有該關鍵字，如果有該關鍵字就定位到原始記錄表中，將符合條件的原始記錄返回給用戶查看。

我們查看以下的圖方便理解：

到了這裏，有人可能就會疑問：難道原始記錄拆分的數據都是一個一個漢字進行拆分的嗎？？然後在詞彙表中不就有很多的關鍵字了？？？

其實，我們在存到原始記錄表中的時候，可以指定我們使用哪種算法來將數據拆分，存到詞彙表中.....我們的圖是Lucene的標準分詞算法，一個一個漢字進行拆分。我們可以使用別的分詞算法，兩個兩個拆分或者其他的算法。

1.2編寫第一個Lucene程序

首先，我們來導入Lucene的必要開發包：

lucene-core-3.0.2.jar【Lucene核心】
lucene-analyzers-3.0.2.jar【分詞器】
lucene-highlighter-3.0.2.jar【Lucene會將搜索出來的字，高亮顯示，提示用戶】
lucene-memory-3.0.2.jar【索引庫優化策略】

創建User對象，User對象封裝了數據....


/**
 * Created by ozc on 2017/7/12.
 */
public class User {


    private String id ;
    private String userName;
    private String sal;

    public User() {

    }
    public User(String id, String userName, String sal) {
        this.id = id;
        this.userName = userName;
        this.sal = sal;
    }
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSal() {
        return sal;
    }

    public void setSal(String sal) {
        this.sal = sal;
    }
}

我們想要使用Lucene來查詢出站內的數據，首先我們得要有個索引庫吧！於是我們先創建索引庫，將我們的數據存到索引庫中。

創建索引庫的步驟：

1）創建JavaBean對象
2）創建Docment對象
3）將JavaBean對象所有的屬性值，均放到Document對象中去，屬性名可以和JavaBean相同或不同
4）創建IndexWriter對象
5）將Document對象通過IndexWriter對象寫入索引庫中
6）關閉IndexWriter對象


    @Test
    public void createIndexDB() throws Exception {

        //把數據填充到JavaBean對象中
        User user = new User("1", "鍾福成", "未來的程序員");

        //創建Document對象【導入的是Lucene包下的Document對象】
        Document document = new Document();

        //將JavaBean對象所有的屬性值，均放到Document對象中去，屬性名可以和JavaBean相同或不同


        /**
         * 向Document對象加入一個字段
         * 參數一：字段的關鍵字
         * 參數二：字符的值
         * 參數三：是否要存儲到原始記錄表中
         *      YES表示是
         *      NO表示否
         * 參數四：是否需要將存儲的數據拆分到詞彙表中
         *      ANALYZED表示拆分
         *      NOT_ANALYZED表示不拆分
         *
         * */
        document.add(new Field("id", user.getId(), Field.Store.YES, Field.Index.ANALYZED));
        document.add(new Field("userName", user.getUserName(), Field.Store.YES, Field.Index.ANALYZED));
        document.add(new Field("sal", user.getSal(), Field.Store.YES, Field.Index.ANALYZED));

        //創建IndexWriter對象
        //目錄指定爲E:/createIndexDB
        Directory directory = FSDirectory.open(new File("E:/createIndexDB"));

        //使用標準的分詞算法對原始記錄表進行拆分
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);

        //LIMITED默認是1W個
        IndexWriter.MaxFieldLength maxFieldLength = IndexWriter.MaxFieldLength.LIMITED;
        /**
         * IndexWriter將我們的document對象寫到硬盤中
         *
         * 參數一：Directory d,寫到硬盤中的目錄路徑是什麼
         * 參數二：Analyzer a, 以何種算法來對document中的原始記錄表數據進行拆分成詞彙表
         * 參數三：MaxFieldLength mfl 最多將文本拆分出多少個詞彙
         *
         * */
        IndexWriter indexWriter = new IndexWriter(directory, analyzer, maxFieldLength);

        //將Document對象通過IndexWriter對象寫入索引庫中
        indexWriter.addDocument(document);

        //關閉IndexWriter對象
        indexWriter.close();

    }

程序執行完，我們就會在硬盤中見到我們的索引庫。

那我們現在是不知道記錄是否真真正正存儲到索引庫中的，因爲我們看不見。索引庫存放的數據放在cfs文件下，我們也是不能打開cfs文件的。

於是，我們現在用一個關鍵字，把索引庫的數據讀取。看看讀取數據是否成功。

根據關鍵字查詢索引庫中的內容：

1）創建IndexSearcher對象
2）創建QueryParser對象
3）創建Query對象來封裝關鍵字
4）用IndexSearcher對象去索引庫中查詢符合條件的前100條記錄，不足100條記錄的以實際爲準
5）獲取符合條件的編號
6）用indexSearcher對象去索引庫中查詢編號對應的Document對象
7）將Document對象中的所有屬性取出，再封裝回JavaBean對象中去，並加入到集合中保存，以備將之用


    @Test
    public void findIndexDB() throws Exception {

        /**
         * 參數一： IndexSearcher(Directory path)查詢以xxx目錄的索引庫
         *
         * */
        Directory directory = FSDirectory.open(new File("E:/createIndexDB"));
        //創建IndexSearcher對象
        IndexSearcher indexSearcher = new IndexSearcher(directory);

        //創建QueryParser對象
        /**
         * 參數一： Version matchVersion 版本號【和上面是一樣的】
         * 參數二：String f,【要查詢的字段】
         * 參數三：Analyzer a【使用的拆詞算法】
         * */
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
        QueryParser queryParser = new QueryParser(Version.LUCENE_30, "userName", analyzer);

        //給出要查詢的關鍵字
        String keyWords = "鍾";

        //創建Query對象來封裝關鍵字
        Query query = queryParser.parse(keyWords);

        //用IndexSearcher對象去索引庫中查詢符合條件的前100條記錄，不足100條記錄的以實際爲準
        TopDocs topDocs = indexSearcher.search(query, 100);

        //獲取符合條件的編號

        for (int i = 0; i < topDocs.scoreDocs.length; i++) {

            ScoreDoc scoreDoc = topDocs.scoreDocs[i];
            int no = scoreDoc.doc;
            //用indexSearcher對象去索引庫中查詢編號對應的Document對象
            Document document = indexSearcher.doc(no);

            //將Document對象中的所有屬性取出，再封裝回JavaBean對象中去
            String id = document.get("id");
            String userName = document.get("userName");
            String sal = document.get("sal");

            User user = new User(id, userName, sal);
            System.out.println(user);
            
        }

效果：

1.3進一步說明Lucene代碼

我們的Lucene程序就是大概這麼一個思路：將JavaBean對象封裝到Document對象中，然後通過IndexWriter把document寫入到索引庫中。當用戶需要查詢的時候，就使用IndexSearcher從索引庫中讀取數據，找到對應的Document對象，從而解析裏邊的內容，再封裝到JavaBean對象中讓我們使用。

二、對Lucene代碼優化

我們再次看回我們上一篇快速入門寫過的代碼，我來截取一些有代表性的：

以下代碼在把數據填充到索引庫，和從索引庫查詢數據的時候，都出現了。是重複代碼！


        Directory directory = FSDirectory.open(new File("E:/createIndexDB"));

        //使用標準的分詞算法對原始記錄表進行拆分
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);

以下的代碼其實就是將JavaBean的數據封裝到Document對象中，我們是可以通過反射來對其進行封裝....如果不封裝的話，我們如果有很多JavaBean都要添加到Document對象中，就會出現很多類似的代碼。


        document.add(new Field("id", user.getId(), Field.Store.YES, Field.Index.ANALYZED));
        document.add(new Field("userName", user.getUserName(), Field.Store.YES, Field.Index.ANALYZED));
        document.add(new Field("sal", user.getSal(), Field.Store.YES, Field.Index.ANALYZED));

以下代碼就是從Document對象中把數據取出來，封裝到JavaBean去。如果JavaBean中有很多屬性，也是需要我們寫很多次類似代碼....



            //將Document對象中的所有屬性取出，再封裝回JavaBean對象中去
            String id = document.get("id");
            String userName = document.get("userName");
            String sal = document.get("sal");
            User user = new User(id, userName, sal);

2.1編寫Lucene工具類

在編寫工具類的時候，值得注意的地方：

當我們得到了對象的屬性的時候，就可以把屬性的get方法封裝起來
得到get方法，就可以調用它，得到對應的值
在操作對象的屬性時，我們要使用暴力訪問
如果有屬性，值，對象這三個變量，我們記得使用BeanUtils組件


import org.apache.commons.beanutils.BeanUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Created by ozc on 2017/7/12.
 */

/**
 * 使用單例事例模式
 * */
public class LuceneUtils {
    private static Directory directory;
    private static Analyzer analyzer;
    private static IndexWriter.MaxFieldLength maxFieldLength;

    private LuceneUtils() {}

    static{
        try {
            directory = FSDirectory.open(new File("E:/createIndexDB"));
            analyzer = new StandardAnalyzer(Version.LUCENE_30);
            maxFieldLength = IndexWriter.MaxFieldLength.LIMITED;
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

    public static Directory getDirectory() {
        return directory;
    }

    public static Analyzer getAnalyzer() {
        return analyzer;
    }

    public static IndexWriter.MaxFieldLength getMaxFieldLength() {
        return maxFieldLength;
    }

    /**
     * @param object 傳入的JavaBean類型
     * @return 返回Document對象
     */
    public static Document javaBean2Document(Object object) {
        try {
            Document document = new Document();
            //得到JavaBean的字節碼文件對象
            Class<?> aClass = object.getClass();

            //通過字節碼文件對象得到對應的屬性【全部的屬性，不能僅僅調用getFields()】
            Field[] fields = aClass.getDeclaredFields();

            //得到每個屬性的名字
            for (Field field : fields) {
                String name = field.getName();
                //得到屬性的值【也就是調用getter方法獲取對應的值】
                String method = "get" + name.substring(0, 1).toUpperCase() + name.substring(1);
                //得到對應的值【就是得到具體的方法，然後調用就行了。因爲是get方法，沒有參數】
                Method aClassMethod = aClass.getDeclaredMethod(method, null);
                String value = aClassMethod.invoke(object).toString();
                System.out.println(value);


                //把數據封裝到Document對象中。
                document.add(new org.apache.lucene.document.Field(name, value, org.apache.lucene.document.Field.Store.YES, org.apache.lucene.document.Field.Index.ANALYZED));
            }
            return document;
        }  catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * @param aClass   要解析的對象類型，要用戶傳入進來
     * @param document 將Document對象傳入進來
     * @return 返回一個JavaBean
     */
    public static Object Document2JavaBean(Document document, Class aClass) {
        try {
            //創建該JavaBean對象
            Object obj = aClass.newInstance();
            //得到該JavaBean所有的成員變量
            Field[] fields = aClass.getDeclaredFields();
            for (Field field : fields) {

                //設置允許暴力訪問
                field.setAccessible(true);
                String name = field.getName();
                String value = document.get(name);
                //使用BeanUtils把數據封裝到Bean中
                BeanUtils.setProperty(obj, name, value);
            }
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    @Test
    public void test() {
        User user = new User();
        LuceneUtils.javaBean2Document(user);
    }
    
}

2.2使用LuceneUtils改造程序


    @Test
    public void createIndexDB() throws Exception {
        //把數據填充到JavaBean對象中
        User user = new User("2", "鍾福成2", "未來的程序員2");
        Document document = LuceneUtils.javaBean2Document(user);
        /**
         * IndexWriter將我們的document對象寫到硬盤中
         *
         * 參數一：Directory d,寫到硬盤中的目錄路徑是什麼
         * 參數二：Analyzer a, 以何種算法來對document中的原始記錄表數據進行拆分成詞彙表
         * 參數三：MaxFieldLength mfl 最多將文本拆分出多少個詞彙
         *
         * */
        IndexWriter indexWriter = new IndexWriter(LuceneUtils.getDirectory(), LuceneUtils.getAnalyzer(), LuceneUtils.getMaxFieldLength());

        //將Document對象通過IndexWriter對象寫入索引庫中
        indexWriter.addDocument(document);
        //關閉IndexWriter對象
        indexWriter.close();
    }


    @Test
    public void findIndexDB() throws Exception {


        //創建IndexSearcher對象
        IndexSearcher indexSearcher = new IndexSearcher(LuceneUtils.getDirectory());
        //創建QueryParser對象
        QueryParser queryParser = new QueryParser(Version.LUCENE_30, "userName", LuceneUtils.getAnalyzer());
        //給出要查詢的關鍵字
        String keyWords = "鍾";
        //創建Query對象來封裝關鍵字
        Query query = queryParser.parse(keyWords);
        //用IndexSearcher對象去索引庫中查詢符合條件的前100條記錄，不足100條記錄的以實際爲準
        TopDocs topDocs = indexSearcher.search(query, 100);
        //獲取符合條件的編號
        for (int i = 0; i < topDocs.scoreDocs.length; i++) {
            ScoreDoc scoreDoc = topDocs.scoreDocs[i];
            int no = scoreDoc.doc;
            //用indexSearcher對象去索引庫中查詢編號對應的Document對象
            Document document = indexSearcher.doc(no);
            //將Document對象中的所有屬性取出，再封裝回JavaBean對象中去
            User user = (User) LuceneUtils.Document2JavaBean(document, User.class);
            System.out.println(user);

        }
    }

三、索引庫優化

我們已經可以創建索引庫並且從索引庫讀取對象的數據了。其實索引庫還有地方可以優化的....

3.1合併文件

我們把數據添加到索引庫中的時候，每添加一次，都會幫我們自動創建一個cfs文件...

這樣其實不好，因爲如果數據量一大，我們的硬盤就有非常非常多的cfs文件了.....其實索引庫會幫我們自動合併文件的，默認是10個。

如果，我們想要修改默認的值，我們可以通過以下的代碼修改：


//索引庫優化
indexWriter.optimize();

//設置合併因子爲3，每當有3個cfs文件，就合併
indexWriter.setMergeFactor(3);

3.2設置內存索引庫

我們的目前的程序是直接與文件進行操作，這樣對IO的開銷其實是比較大的。而且速度相對較慢....我們可以使用內存索引庫來提高我們的讀寫效率...

對於內存索引庫而言，它的速度是很快的，因爲我們直接操作內存...但是呢，我們要將內存索引庫是要到硬盤索引庫中保存起來的。當我們讀取數據的時候，先要把硬盤索引庫的數據同步到內存索引庫中去的。


        Article article = new Article(1,"培訓","傳智是一家Java培訓機構");
        Document document = LuceneUtil.javabean2document(article);
        
        Directory fsDirectory = FSDirectory.open(new File("E:/indexDBDBDBDBDBDBDBDB"));
        Directory ramDirectory = new RAMDirectory(fsDirectory);
        
        IndexWriter fsIndexWriter = new IndexWriter(fsDirectory,LuceneUtil.getAnalyzer(),true,LuceneUtil.getMaxFieldLength());
        IndexWriter ramIndexWriter = new IndexWriter(ramDirectory,LuceneUtil.getAnalyzer(),LuceneUtil.getMaxFieldLength());
        
        ramIndexWriter.addDocument(document);
        ramIndexWriter.close();
        
        fsIndexWriter.addIndexesNoOptimize(ramDirectory);
        fsIndexWriter.close();

四、分詞器

我們在前面中就已經說過了，在把數據存到索引庫的時候，我們會使用某些算法，將原始記錄表的數據存到詞彙表中.....那麼這些算法總和我們可以稱之爲分詞器

分詞器： ** 採用一種算法，將中英文本中的字符拆分開來，形成詞彙，以待用戶輸入關健字後搜索**

對於爲什麼要使用分詞器，我們也明確地說過：由於用戶不可能把我們的原始記錄數據完完整整地記錄下來，於是他們在搜索的時候，是通過關鍵字進行對原始記錄表的查詢....此時，我們就採用分詞器來最大限度地匹配相關的數據

4.1分詞器流程

步一：按分詞器拆分出詞彙
步二：去除停用詞和禁用詞
步三：如果有英文，把英文字母轉爲小寫，即搜索不分大小寫

4.2分詞器API

我們在選擇分詞算法的時候，我們會發現有非常非常多地分詞器API，我們可以用以下代碼來看看該分詞器是怎麼將數據分割的：


    private static void testAnalyzer(Analyzer analyzer, String text) throws Exception {
        System.out.println("當前使用的分詞器：" + analyzer.getClass());
        TokenStream tokenStream = analyzer.tokenStream("content",new StringReader(text));
        tokenStream.addAttribute(TermAttribute.class);
        while (tokenStream.incrementToken()) {
            TermAttribute termAttribute = tokenStream.getAttribute(TermAttribute.class);
            System.out.println(termAttribute.term());
        }
    }

在實驗完之後，我們就可以選擇恰當的分詞算法了....

4.3IKAnalyzer分詞器

這是一個第三方的分詞器，我們如果要使用的話需要導入對應的jar包

IKAnalyzer3.2.0Stable.jar
步二：將IKAnalyzer.cfg.xml和stopword.dic和xxx.dic文件複製到MyEclipse的src目錄下，再進行配置，在配置時，首行需要一個空行

這個第三方的分詞器有什麼好呢？？？？他是中文首選的分詞器...也就是說：他是按照中文的詞語來進行拆分的!

五、對搜索結果進行處理

5.1搜索結果高亮

我們在使用SQL時，搜索出來的數據是沒有高亮的...而我們使用Lucene，搜索出來的內容我們可以設置關鍵字爲高亮...這樣一來就更加註重用戶體驗了！


        String keywords = "鍾福成";
        List<Article> articleList = new ArrayList<Article>();
        QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),"content",LuceneUtil.getAnalyzer());
        Query query = queryParser.parse(keywords);
        IndexSearcher indexSearcher = new IndexSearcher(LuceneUtil.getDirectory());
        TopDocs topDocs = indexSearcher.search(query,1000000);
        
        //設置關鍵字高亮
        Formatter formatter = new SimpleHTMLFormatter("<font color='red'>","</font>");
        Scorer scorer = new QueryScorer(query);
        Highlighter highlighter = new Highlighter(formatter,scorer);
        
        for(int i=0;i<topDocs.scoreDocs.length;i++){
            ScoreDoc scoreDoc = topDocs.scoreDocs[i];
            int no = scoreDoc.doc;
            Document document = indexSearcher.doc(no);
            
            //設置內容高亮
            String highlighterContent = highlighter.getBestFragment(LuceneUtil.getAnalyzer(),"content",document.get("content"));
            document.getField("content").setValue(highlighterContent);
            
            Article article = (Article) LuceneUtil.document2javabean(document,Article.class);
            articleList.add(article);
        }
        for(Article article : articleList){
            System.out.println(article);
        }
    }

5.2搜索結果摘要

如果我們搜索出來的文章內容太大了，而我們只想顯示部分的內容，那麼我們可以對其進行摘要...

值得注意的是：搜索結果摘要需要與設置高亮一起使用


String keywords = "鍾福成";
        List<Article> articleList = new ArrayList<Article>();
        QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),"content",LuceneUtil.getAnalyzer());
        Query query = queryParser.parse(keywords);
        IndexSearcher indexSearcher = new IndexSearcher(LuceneUtil.getDirectory());
        TopDocs topDocs = indexSearcher.search(query,1000000);
        
        Formatter formatter = new SimpleHTMLFormatter("<font color='red'>","</font>");
        Scorer scorer = new QueryScorer(query);
        Highlighter highlighter = new Highlighter(formatter,scorer);
        
        //設置摘要
        Fragmenter fragmenter  = new SimpleFragmenter(4);
        highlighter.setTextFragmenter(fragmenter);
        
        for(int i=0;i<topDocs.scoreDocs.length;i++){
            ScoreDoc scoreDoc = topDocs.scoreDocs[i];
            int no = scoreDoc.doc;
            Document document = indexSearcher.doc(no);
            
            String highlighterContent = highlighter.getBestFragment(LuceneUtil.getAnalyzer(),"content",document.get("content"));
            document.getField("content").setValue(highlighterContent);
            
            Article article = (Article) LuceneUtil.document2javabean(document,Article.class);
            articleList.add(article);
        }
        for(Article article : articleList){
            System.out.println(article);
        }
    }

5.3搜索結果排序

我們搜索引擎肯定用得也不少，使用不同的搜索引擎來搜索相同的內容。他們首頁的排行順序也會不同...這就是它們內部用了搜索結果排序....

影響網頁的排序有非常多種：

head/meta/【keywords關鍵字】
網頁的標籤整潔
網頁執行速度
採用div+css
等等等等

而在Lucene中我們就可以設置相關度得分來使不同的結果對其進行排序：


        IndexWriter indexWriter = new IndexWriter(LuceneUtil.getDirectory(),LuceneUtil.getAnalyzer(),LuceneUtil.getMaxFieldLength());
        //爲結果設置得分
        document.setBoost(20F);
        indexWriter.addDocument(document);
        indexWriter.close();

當然了，我們也可以按單個字段排序：

    //true表示降序
    Sort sort = new Sort(new SortField("id",SortField.INT,true));
    TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);

也可以按多個字段排序：在多字段排序中，只有第一個字段排序結果相同時，第二個字段排序纔有作用提倡用數值型排序


        Sort sort = new Sort(new SortField("count",SortField.INT,true),new SortField("id",SortField.INT,true));
        TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);

5.4條件搜索

在我們的例子中，我們使用的是根據一個關鍵字來對某個字段的內容進行搜索。語法類似於下面：

    QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),"content",LuceneUtil.getAnalyzer());

其實，我們也可以使用關鍵字來對多個字段進行搜索，也就是多條件搜索。我們實際中常常用到的是多條件搜索，多條件搜索可以使用我們最大限度匹配對應的數據！


QueryParser queryParser = new MultiFieldQueryParser(LuceneUtil.getVersion(),new String[]{"content","title"},LuceneUtil.getAnalyzer());

六、總結

Lucene是全文索引引擎的祖先，後面的Solr、Elasticsearch都是基於Lucene的(後面會有一篇講Elasticsearch的，敬請期待～)
Lucene中存的就是一系列的二進制壓縮文件和一些控制文件,這些內容統稱爲索引庫,索引庫又分了兩個部分：
- 原始記錄
- 詞彙表
瞭解索引庫的優化方式：1、合併文件 2、設置內存索引庫
Lucene的分詞器有非常多種，選擇自己適合的一種進行分詞
查詢出來的結果可對其設置高亮、摘要、排序

世界盃足球競猜網站開發dsluntan.com 企娥3393756370

Lucene世界盃足球競猜網站開發就是這麼簡單

爲什麼我們要用Lucene？

一、快速入門

1.1原始記錄和詞彙表

1.2編寫第一個Lucene程序

1.3進一步說明Lucene代碼

二、對Lucene代碼優化

2.1編寫Lucene工具類

2.2使用LuceneUtils改造程序

三、索引庫優化

3.1合併文件

3.2設置內存索引庫

四、分詞器

4.1分詞器流程

4.2分詞器API

4.3IKAnalyzer分詞器

五、對搜索結果進行處理

5.1搜索結果高亮

5.2搜索結果摘要

5.3搜索結果排序

5.4條件搜索

六、總結

linux安裝cuda和cudnn

模擬手機設備：使用 Playwright 實現移動端自動化測試

Mellanox網卡開啓SR-IOV

測試人員都是畫畫大神，讓我看看誰還不會用代碼圖？

Object.values()對象遍歷

我拍了拍Redis，被移出了羣聊···

網絡現代化通向雲原生應用的高速公路

面試官：說說你對序列化的理解

我宣佈，這是我找到的史上AI最全論文體系！

Lucene世界盃足球競猜網站開發就是這麼簡單

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結