Lucene

時間 2019-11-17

標籤 lucene 简体版

原文原文鏈接

爬蟲從網絡上爬取巨量數據，數據保存若是放DB中不只插入慢，隨着數據量增大，查詢性能也會愈加差。最近有一個設想，可否將爬取的數據以文件形式保存，經過lucene框架創建索引的方式來知足快速搜索呢。html

菜鳥起飛：前端

1、Lucene簡介：

Lucene是Apache Jakarta家族中的一個開源項目，是一個開放源代碼的全文檢索引擎工具包，但它不是一個完整的全文檢索引擎，而是一個全文檢索引擎的架構，提供了完整的查詢引擎、索引引擎和部分文本分析引擎。java

Lucene提供了一個簡單卻強大的應用程式接口，可以作全文索引和搜尋。在Java開發環境裏Lucene是一個成熟的免費開源工具，是目前最爲流行的基於 Java 開源全文檢索工具包。git

數據整體分爲兩種：github

結構化數據：指具備固定格式或有限長度的數據，如數據庫、元數據等。
非結構化數據：指不定長或無固定格式的數據，如郵件、word文檔等磁盤上的文件。
對於結構化數據的全文搜索很簡單，由於數據都是有固定格式的，例如搜索數據庫中數據使用SQL語句便可。web

對於非結構化數據，有如下兩種方法：算法

順序掃描法(Serial Scanning)
全文檢索(Full-text Search)spring

順序掃描法
若是要找包含某一特定內容的文件，對於每個文檔，從頭至尾掃描內容，若是此文檔包含此字符串，則此文檔爲咱們要找的文件，接着看下一個文件，直到掃描完全部的文件，所以速度很慢。數據庫

全文檢索
將非結構化數據中的一部分信息提取出來，從新組織，使其變得具備必定結構，而後對此有必定結構的數據進行搜索，從而達到搜索相對較快的目的。這部分從非結構化數據中提取出的而後從新組織的信息，咱們稱之索引。apache

例如字典的拼音表和部首檢字表就至關於字典的索引，經過查找拼音表或者部首檢字表就能夠快速的查找到咱們要查的字。

這種先創建索引，再對索引進行搜索的過程就叫全文檢索(Full-text Search)。

2、全文檢索流程

2.1 索引過程

綠色表示索引過程，對要搜索的原始內容進行索引構建一個索引庫，索引過程包括：

得到原始文檔（原始內容即要搜索的內容）
採集文檔
建立文檔
分析文檔
索引文檔

2.1.1 得到原始文檔

原始文檔是指要索引和搜索的內容。原始內容包括互聯網上的網頁、數據庫中的數據、磁盤上的文件等等。

從互聯網、數據庫、文件系統中獲取要搜索的原始信息，這個過程就是信息採集，信息採集的目的是對原始內容進行索引。

在互聯網上採集信息的程序稱爲爬蟲。Lucene不提供信息採集的類庫，須要本身編寫一個爬蟲程序實現信息採集，也可使用一些開源軟件實現信息採集，如Nutch、JSoup、Heritrix等等。

對於磁盤上文件內容，能夠經過IO流來讀取文本文件內容，對於pdf、doc、xls等文件能夠經過第三方解析工具來讀取文件內容，如Apache POI等。

2.1.2 建立文檔對象

得到原始內容的目的是爲了建立索引，在索引前須要將原始內容建立成文檔（Document），文檔中包含多個域（Field），在域中存儲內容。

域能夠被理解爲一個原始文檔的屬性。例若有一個文本文件test.txt，咱們將這個文本文件的內容建立成文檔（Document），它就包含了許多域，好比有文件名、文件大小、最後修改時間等等，如圖：

注意：每一個Document能夠有多個Field，不一樣的Document能夠有不一樣的Field，同一個Document能夠有相同的Field。

2.1.3 分析文檔

將原始內容建立和包含域（Field）的文檔（Document）後，須要對域中的內容進行分析，分析的過程是通過對原始文檔提取單詞、字母大小寫轉換、去除符號、去除停用詞等過程後生成最終的語彙單元。

例如分析如下文檔後：

Lucene is a Java full-text search engine. Lucene is not a complete application, but rather a code library and API that can easily be used to add search capabilities to applications

分析後獲得的語彙單元：

lucene、java、full 、search、engine…

將每一個語彙單元叫作一個term，不一樣的域中拆分出來的相同的語彙單元是不一樣的 term 。term 中包含兩部分一部分是文檔的域名，另外一部分是內容。例如：文件名中包含 java 和文件內容中包含的 java是不一樣的 term 。

2.1.4 建立索引

對全部文檔分析得出的語彙單元進行索引，最終要實現只搜索語彙單元就可以找到文檔（Document）。

2.2 搜索過程

紅色表示搜索過程，從索引庫中搜索內容，搜索過程包括：

用戶經過搜索界面
建立查詢
執行搜索，從索引庫搜索
渲染搜索結果

2.2.1 用戶搜索

用戶經過前端頁面，將要搜索的關鍵字傳遞到後端。

2.2.2 建立查詢

用戶輸入查詢關鍵詞執行搜索前須要先構建一個查詢對象，查詢對象中能夠指定查詢要搜索的Field文檔域、查詢關鍵字等，查詢對象會生成具體的查詢語法。

2.2.3執行查詢

根據查詢對象得到對應的索引，從而找到索引所對應的文檔。

2.2.4 渲染結果

以一個友好的界面將查詢結果展現給用戶，用戶根據搜索結果找本身想要的信息，爲了幫助用戶很快找到本身的結果，提供了不少展現的效果，好比搜索結果中將關鍵字高亮顯示，百度提供的快照等。

3、實現

找了個Lucene 6.6.0 的API，湊合着用

http://lucene.apache.org/core/6_6_0/core/index.html

git-hub:

https://github.com/xiaozhuanfeng/luceneProj

用springboot搭了個工程：

pom.xml

 <properties>
        <lucene.version>6.6.2</lucene.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <!--工具包 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.1</version>
        </dependency>

        <!-- 引入fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-core</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-analyzers-common</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-highlighter</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-memory</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-backward-codecs</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queries</artifactId>
            <version>${lucene.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
            <version>${lucene.version}</version>
        </dependency>

    </dependencies>

中文分詞用IKAnalyzer，只支持到Lucene5x，下載資源，導出jar包，具體放在了gitHub中，放入工程：

package com.example.pca.lucene;

import org.apache.lucene.search.TopDocs;

import java.io.IOException;

public interface ISearch {
    /**
     * 建立索引
     * @param indexPath  索引文件路徑
     * @param resourcePath  資源文件路徑
     * @return
     */
    boolean createIndex(String indexPath, String resourcePath) throws IOException;

    /**
     * 關鍵字查詢
     * @param indexPath 索引文件路徑
     * @param keyword  關鍵字
     * @return
     * @throws IOException
     */
    TopDocs queryIndex(String indexPath, String keyword)throws IOException;
}

package com.example.pca.lucene.impl;

import com.example.pca.lucene.ISearch;
import org.apache.commons.io.FileUtils;
import org.apache.lucene.analysis.Analyzer;
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.index.Term;
import org.apache.lucene.search.*;
import org.apache.lucene.search.highlight.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.File;
import java.io.IOException;
import java.util.Collection;

public abstract class AbstractSearch implements ISearch {

    protected Analyzer analyzer;

    @Override
    public boolean createIndex(String indexPath, String resourcePath) throws IOException {
        /* Step1：建立IndexWrite對象
         * （1）定義詞法分析器
         * （2）肯定索引存儲位置-->建立Directory對象
         * （3）獲得IndexWriterConfig對象
         * （4）建立IndexWriter對象
         */

        Directory directory = FSDirectory.open(new File(indexPath).toPath());
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);

        try (IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig)) {
            // 清除之前的索引
            indexWriter.deleteAll();

            // 獲得txt後綴的文件集合
            Collection<File> txtFiles = FileUtils.listFiles(new File(resourcePath), new String[]{"txt"}, true);
            for (File file : txtFiles) {
                String fileName = file.getName();
                String content = FileUtils.readFileToString(file, "UTF-8");
                /*
                 * Step2：建立Document對象，將Field地下添加到Document中
                 * Field第三個參數選項不少，具體參考API手冊
                 */
                Document document = new Document();
                document.add(new Field("fileName", fileName, TextField.TYPE_STORED));
                document.add(new Field("content", content, TextField.TYPE_STORED));

                /*
                 *Step4：使用 IndexWrite對象將Document對象寫入索引庫，並進行索引。
                 */
                indexWriter.addDocument(document);
            }
        }
        return false;
    }

    @Override
    public TopDocs queryIndex(String indexPath, String keyword) throws IOException {
        TopDocs topDocs = null;
        /*
         * Step1：建立IndexSearcher對象
         * （1）建立Directory對象
         * （2）建立DirectoryReader對象
         * （3）建立IndexSearcher對象
         */
        Directory directory = FSDirectory.open(new File(indexPath).toPath());

        try (DirectoryReader reader = DirectoryReader.open(directory)) {
            IndexSearcher indexSearcher = new IndexSearcher(reader);

            /*
             * Step2：建立TermQuery對象，指定查詢域和查詢關鍵詞
             */
            Term fTerm = new Term("fileName", keyword);
            Term cTerm = new Term("content", keyword);
            TermQuery query1 = new TermQuery(fTerm);
            TermQuery query2 = new TermQuery(cTerm);

            /*
             * Step3：建立Query對象
             */
            Query booleanBuery = new BooleanQuery.Builder().add(query1, BooleanClause.Occur.SHOULD).add(query2,
                    BooleanClause.Occur.SHOULD)
                    .build();

            topDocs = indexSearcher.search(booleanBuery, 100);
            System.out.println("共找到 " + topDocs.totalHits + " 個文件匹配");


            //打印結果
            printTopDocs(topDocs.scoreDocs, indexSearcher, getHighlighter(booleanBuery));

        } catch (InvalidTokenOffsetsException e) {
            e.printStackTrace();
        }

        return topDocs;
    }

    /**
     * 返回高亮對象
     *
     * @param query
     * @return
     */
    private Highlighter getHighlighter(Query query) {
        // 格式化器
        Formatter formatter = new SimpleHTMLFormatter("<em>", "</em>");

        //算分
        QueryScorer scorer = new QueryScorer(query);

        // 準備高亮工具
        Highlighter highlighter = new Highlighter(formatter, scorer);

        //顯示得分高的片斷,片斷字符長度fragmentSize=1000
        Fragmenter fragmenter = new SimpleSpanFragmenter(scorer, 200);

        //設置片斷
        highlighter.setTextFragmenter(fragmenter);
        return highlighter;
    }

    private void printTopDocs(ScoreDoc[] scoreDocs, IndexSearcher indexSearcher, Highlighter highlighter) throws IOException, InvalidTokenOffsetsException {

        for (ScoreDoc scoreDoc : scoreDocs) {
            Document doc = indexSearcher.doc(scoreDoc.doc);
            String fileName = doc.get("fileName");
            System.out.println("fileName=" + fileName);

            if (null != highlighter) {
                //高亮處理
                String content = doc.get("content");
                System.out.println(content);
                System.out.println("====================");
                String hContent = highlighter.getBestFragment(analyzer, "content", content);
                System.out.println(hContent);
            }
            System.out.println();
        }
    }
}

package com.example.pca.lucene.analyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.wltea.analyzer.lucene.IKAnalyzer;

@Configuration
public class AnalyzerConfig {

    @Bean("standardAnalyzer")
    public Analyzer getStandardAnalyzer() {
        // 使用標準分詞器,但對於中文頗爲無力
        //lucene自帶分詞器，SmartChineseAnalyzer()
        //缺點：擴展性差，擴展詞庫、禁用詞庫和同義詞庫等很差處理

       /* 第三方分詞器
       paoding：庖丁解牛，可是其最多隻支持到Lucene3，已通過時，不推薦使用。
       mmseg4j：目前支持到Lucene6 ，目前仍然活躍，使用mmseg算法。  參考：https://www.jianshu.com/p/03f4a906cfb5
       IK-Analyzer：開源的輕量級的中文分詞工具包，官方支持到Lucene5。
        */
        return new StandardAnalyzer();
    }

    @Bean("iKAnalyzer")
    public Analyzer getIKAnalyzer() {
        //IK分詞，試了下，也能夠支持中文
        return new IKAnalyzer();
    }
}

package com.example.pca.lucene.impl;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "englishSearch")
public class EnglishSearch extends AbstractSearch implements InitializingBean {

    @Resource(name = "standardAnalyzer")
    private Analyzer standardAnalyzer;

    @Override
    public void afterPropertiesSet() throws Exception {
        super.analyzer = standardAnalyzer;
    }

}

package com.example.pca.lucene.impl;

import org.apache.lucene.analysis.Analyzer;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;
import org.wltea.analyzer.lucene.IKAnalyzer;

import javax.annotation.Resource;

@Service(value = "chineseSearch")
public class ChineseSearch extends AbstractSearch implements InitializingBean {
    @Resource(name = "iKAnalyzer")
    private Analyzer iKAnalyzer;

    @Override
    public void afterPropertiesSet() throws Exception {
        super.analyzer = iKAnalyzer;
    }
}

package com.example.pca.lucene;

import com.example.pca.utils.ProjectPathUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

import java.io.IOException;

import static com.example.pca.lucene.constants.FilePkg.FILE_PKG;
import static com.example.pca.lucene.constants.FilePkg.INDEX_PKG;

@RunWith(SpringRunner.class)
@SpringBootTest
public class luceneTest {

    /**
     * F:\xxxx\ideaProjects\luceneProj\luceneResource\
     */
    private static final String RESOURCE_PATH = ProjectPathUtils.getProjPath("luceneProj") + FILE_PKG.getPkgName();

    /**
     * F:\xxxx\ideaProjects\luceneProj\luceneIndex\
     */
    private static final String INDEX_PATH = ProjectPathUtils.getProjPath("luceneProj") + INDEX_PKG.getPkgName();

    @Resource(name = "englishSearch")
    private ISearch englishSearch;

    @Resource(name = "chineseSearch")
    private ISearch chineseSearch;

    @Test
    public void test1() {
        System.out.println(RESOURCE_PATH);
        System.out.println(INDEX_PATH);
    }

    @Test
    public void test2() {
        try {
            englishSearch.createIndex(INDEX_PATH + "US\\", RESOURCE_PATH +"US\\");
            englishSearch.queryIndex(INDEX_PATH +"US\\", "spring");
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test3() {
        try {
            chineseSearch.createIndex(INDEX_PATH +"EN\\", RESOURCE_PATH + "EN\\");
            chineseSearch.queryIndex(INDEX_PATH +"EN\\", "孫悟空");
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在英文資源文件目錄下放入文件，測試test2:

中文資源測試，test3

同時測了下，IK分詞也是能夠支持英文的

@Test
    public void test4() {
        try {
            chineseSearch.createIndex(INDEX_PATH +"US\\", RESOURCE_PATH + "US\\");
            chineseSearch.queryIndex(INDEX_PATH +"US\\", "spring");
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

結束語：本人菜鳥一枚，權看成學習，知道有這麼個東東。

參考：

https://blog.csdn.net/yuanlaijike/article/details/79452884

https://blog.csdn.net/joker233/article/details/51909833

資源：

https://mvnrepository.com/artifact/com.chenlb.mmseg4j

LK分詞器資源

https://blog.csdn.net/m0_37609579/article/details/77865183