lucene 核心概念及入门

小咪咪 2022-04-01 03:52 239阅读 0赞

# lucene #

## Lucene介绍及核心概念 ##

### 什么是Lucene ###

Lucene是一套用于全文检索和搜索的开放源代码程序库，由Apache软件基金会支持和提供。Lucene提供了一个简单却强大的应用程序接口，能够做全文索引和搜索，在Java开发环境里Lucene是一个成熟的免费开放源代码工具；就其本身而论，Lucene是现在并且是这几年，最受欢迎的免费Java信息检索程序库。

### lucene可以做什么 ###

Lucene允许你向自己的应用程序中添加搜索功能。Lucene能够把你从文本中解析出来的数据进行索引和搜索。Lucene并不关心你的数据来源，格式，甚至不关心数据的语种。

### Lucene的优点 ###

*  Lucene作为一个全文检索引擎，其具有如下突出的优点：

（1）索引文件格式独立于应用平台。Lucene定义了一套以8位字节为基础的索引文件格式，使得兼容系统或者不同平台的应用能够共享建立的索引文件。

（2）在传统全文检索引擎的倒排索引的基础上，实现了分块索引，能够针对新的文件建立小文件索引，提升索引速度。然后通过与原有索引的合并，达到优化的目的。

（3）优秀的面向对象的系统架构，使得对于Lucene扩展的学习难度降低，方便扩充新功能。

（4）设计了独立于语言和文件格式的文本分析接口，索引器通过接受Token流完成索引文件的创立，用户扩展新的语言和文件格式，只需要实现文本分析的接口。

（5）已经默认实现了一套强大的查询引擎，用户无需自己编写代码即使系统可获得强大的查询能力，Lucene的查询实现中默认实现了布尔操作、模糊查询（Fuzzy Search\[11\]）、分组查询等等。

### Lucene相关名词解释 ###

1、IndexWriter

lucene中最重要的的类之一，它主要是用来将文档加入索引，同时控制索引过程中的一些参数使用。

2、Analyzer

分析器,主要用于分析搜索引擎遇到的各种文本。常用的有StandardAnalyzer分析器,StopAnalyzer分析器,WhitespaceAnalyzer分析器等。

3、Directory

索引存放的位置;lucene提供了两种索引存放的位置，一种是磁盘，一种是内存。一般情况将索引放在磁盘上；相应地lucene提供了FSDirectory和RAMDirectory两个类。

4、Document

文档;Document相当于一个要进行索引的单元，任何可以想要被索引的文件都必须转化为Document对象才能进行索引。

5、Field

类似于数据库中的一个字段，存储了key-value值。

6、IndexSearcher

是lucene中最基本的检索工具，所有的检索都会用到IndexSearcher工具;

7、Query

Query类似关系型数据库中的SQL语句。与关系型数据库类似，Lucene提供了以下的基本查询：精确查询xxx = ? TermQuery、范围查询 xxx BETWEEN? AND ? PointRangeQuery、模糊查询 xxx LIKE ‘%?%’ PrefixQuery、RegexpQuery、组合查询 (…) AND (…) OR (…) BooleanQuery

8、QueryParser

是一个解析用户输入的工具，可以通过扫描用户输入的字符串，生成Query对象。

9、Hits

在搜索完成之后，需要把搜索结果返回并显示给用户，只有这样才算是完成搜索的目的。在Lucene中，搜索的结果的集合是用Hits类的实例来表示的。

### 什么是正向索引、什么是倒排索引？ ###

正向索引（forward index），反向索引（inverted index）更熟悉的名字是倒排索引。

在搜索引擎中每个文件都对应一个文件ID，文件内容被表示为一系列关键词的集合（实际上在搜索引擎索引库中，关键词也已经转换为关键词ID）。例如“文档1”经过分词，提取了20个关键词，每个关键词都会记录它在文档中的出现次数和出现位置，得到正向索引的结构如下：

doc1 —> word1：出现次数，出现位置列表；单词2：出现次数，出现位置列表…

doc2 —> word1：出现次数，出现位置列表；单词2：出现次数，出现位置列表…

当用户在主页上搜索关键词“苹果手机”时，假设只存在正向索引（forward index），那么就需要扫描索引库中的所有文档，找出所有包含关键词“苹果手机”的文档，再根据打分模型进行打分，排出名次后呈现给用户。因为互联网上收录在搜索引擎中的文档的数目是个天文数字，这样的索引结构根本无法满足实时返回排名结果的要求。

所以，搜索引擎会将正向索引重新构建为倒排索引，即把文件ID对应到关键词的映射转换为关键词到文件ID的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词，得到倒排索引的结构如下：

word1 —> doc3、doc2、doc7、doc6…

word2 —> doc1、doc2、doc5、doc6…

## lucene java客户端 ##

/**
     * <p>
     *
     * @author leone
     * @since: 2018-11-23
     **/
    public class Book {
    
        private int bookId;
    
        private String name;
    
        private float price;
    
        private String picture;
    
        private String description;
    
        public Book() {
        }
    
        public Book(int bookId, String name, float price, String picture, String description) {
            this.bookId = bookId;
            this.name = name;
            this.price = price;
            this.picture = picture;
            this.description = description;
        }
    
        public int getBookId() {
            return bookId;
        }
    
        public void setBookId(int bookId) {
            this.bookId = bookId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public float getPrice() {
            return price;
        }
    
        public void setPrice(float price) {
            this.price = price;
        }
    
        public String getPicture() {
            return picture;
        }
    
        public void setPicture(String picture) {
            this.picture = picture;
        }
    
        public String getDescription() {
            return description;
        }
    
        public void setDescription(String description) {
            this.description = description;
        }
    }

package com.andy.lucene;
    
    import org.apache.commons.io.FileUtils;
    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.analysis.standard.StandardAnalyzer;
    import org.apache.lucene.document.*;
    import org.apache.lucene.index.DirectoryReader;
    import org.apache.lucene.index.IndexReader;
    import org.apache.lucene.index.IndexWriter;
    import org.apache.lucene.index.IndexWriterConfig;
    import org.apache.lucene.queryparser.classic.QueryParser;
    import org.apache.lucene.search.IndexSearcher;
    import org.apache.lucene.search.Query;
    import org.apache.lucene.search.ScoreDoc;
    import org.apache.lucene.search.TopDocs;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.nio.file.FileSystems;
    import java.nio.file.Path;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * <p>
     *
     * @author leone
     * @since: 2018-11-23
     **/
    public class BookMain {
    
        private static final Logger logger = LoggerFactory.getLogger(BookMain.class);
    
        private static List<Book> books = new ArrayList<>();
    
        private static String docPath = "E:\\tmp\\lucene\\docDir";
        private static String indexPath = "E:\\tmp\\lucene\\indexDir";
    
        static {
            books.add(new Book(1, "Java核心编程思想", 23, "http://www.taobao.com/image.jpg", "Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程"));
            books.add(new Book(2, "mysql数据库设计", 47, "http://www.taobao.com/image.jpg", "MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件。"));
            books.add(new Book(3, "JavaWeb进阶", 75, "http://www.jd.com/image.jpg", "Java Web，是用Java技术来解决相关web互联网领域的技术总和。web包括：web服务器和web客户端两部分。Java在客户端的应用有java applet，不过使用得很少，Java在服务器端的应用非常的丰富，比如Servlet，JSP和第三方框架等等。Java技术对Web领域的发展注入了强大的动力。"));
            books.add(new Book(4, "spring入门", 38, "http://www.tianmao.com/image.jpg", "Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架"));
            books.add(new Book(5, "springCloud微服务实战", 42, "http://www.yamaxun.com/image.jpg", "Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。"));
            books.add(new Book(5, "JavaScript高级", 71, "http://www.tianmao.com/image.jpg", "JavaScript 是属于网络的脚本语言 JavaScript 被数百万计的网页用来改进设计、验证表单、检测浏览器、创建cookies，以及更多的应用。"));
        }
    
        public static void main(String[] args) throws Exception {
    
            Map<String, String> doc = new HashMap<>();
            doc.put("文件名称", "fileName");
            doc.put("文件大小", "fileSize");
            doc.put("文件路径", "filePath");
            doc.put("文件内容", "fileContent");
    
            Map<String, String> book = new HashMap<>();
            book.put("商品ID", "book_id");
            book.put("商品名称", "name");
            book.put("商品价格", "price");
            book.put("商品图片地址", "picture");
            book.put("商品描述", "description");
    
            long start = System.currentTimeMillis();
    //        createIndex();
    //        indexSearch("description:spring");
            logger.info("一共花费了:{}毫秒!", (System.currentTimeMillis() - start));
        }
    
        private static void createIndex() throws IOException {
            // 将采集到的数据封装到Document对象中
            List<Document> docList = new ArrayList<>();
            Document document;
            for (Book book : books) {
                document = new Document();
                // store:如果是yes，则说明存储到文档域中
    
                // 图书ID
                Field bookId = new TextField("book_id", Integer.toString(book.getBookId()), Field.Store.YES);
                // 图书名称
                Field name = new TextField("name", book.getName(), Field.Store.YES);
                // 图书价格
                Field price = new TextField("price", Float.toString(book.getPrice()), Field.Store.YES);
                // 图书图片地址
                Field picture = new TextField("picture", book.getPicture(), Field.Store.YES);
                // 图书描述
                Field description = new TextField("description", book.getDescription(), Field.Store.YES);
                // 将field域设置到Document对象中
                document.add(bookId);
                document.add(name);
                document.add(price);
                document.add(picture);
                document.add(description);
                docList.add(document);
            }
            // 创建分词器，标准分词器
            Analyzer analyzer = new StandardAnalyzer();
            // 创建IndexWriter
            IndexWriterConfig cfg = new IndexWriterConfig(analyzer);
            // 指定索引库的地址
            Directory directory = FSDirectory.open(FileSystems.getDefault().getPath(indexPath));
            // 创建索引writer
            IndexWriter writer = new IndexWriter(directory, cfg);
            // 清除以前的index
            writer.deleteAll();
            // 通过IndexWriter对象将Document写入到索引库中
            for (Document doc : docList) {
                writer.addDocument(doc);
            }
            // 关闭writer
            writer.close();
        }
    
    
        /**
         * @param query
         * @throws IOException
         */
        private static void searchDocument(Query query, Map<String, String> map) throws IOException {
            // 1.创建DirectoryJDK 1.7以后 open只能接收Path
            Directory directory = FSDirectory.open(FileSystems.getDefault().getPath(indexPath));
            IndexReader reader = DirectoryReader.open(directory);
            IndexSearcher searcher = new IndexSearcher(reader);
            // 通过searcher来搜索索引库,第二个参数指定需要显示的顶部记录的N条
            TopDocs topDocs = searcher.search(query, 10);
    
            // 根据查询条件匹配出的记录总数
            int count = topDocs.totalHits;
    
            System.out.println("匹配出的记录总数:[ " + count + " ]\n==========================");
            // 根据查询条件匹配出的记录
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (ScoreDoc scoreDoc : scoreDocs) {
                // 获取文档的ID
                int docId = scoreDoc.doc;
                // 通过ID获取文档
                Document doc = searcher.doc(docId);
                for (Map.Entry<String, String> entry : map.entrySet()) {
                    System.out.println(entry.getKey() + ":" + doc.get(entry.getValue()));
                }
                System.out.println("==========================");
            }
            // 关闭资源
            reader.close();
    
        }
    
        public static void indexSearch(String name, Map<String, String> map) throws Exception {
            // 创建query对象
            Analyzer analyzer = new StandardAnalyzer();
            // 使用QueryParser搜索时，需要指定分词器，搜索时的分词器要和索引时的分词器一致,第一个参数：默认搜索的域的名称
            QueryParser parser = new QueryParser("description", analyzer);
            // 参数：输入的lucene的查询语句(关键字一定要大写)
            Query query = parser.parse(name);
            searchDocument(query, map);
        }
    
    
    }