JAVA相关大数据相关

分布式--Lucene 全文检索

2018-04-23  本文已影响3人  _凌浩雨

1. Lucene 官网

1). 概述

Lucene是一款高性能的、可扩展的信息检索（IR）工具库。信息检索是指文档搜索、文档内信息搜索或者文档相关的元数据搜索等操作。Lucene工具包下载

2). 索引过程：

①获取内容
②建立文档
获取原始内容后，就需要对这些内容进行索引，必须首先将这些内容转换成部件（通常称为文档），以供搜索引擎使用。文档主要包括几个带值的域，比如标题、正文、摘要、作者和链接。
③文档分析
搜索引擎不能直接对文本进行索引：确切地说，必须将文本分割成一系列被称为语汇单元的独立的原子元素。每一个语汇单元大致与语言中的“单词”对应起来。
④文档索引
在索引步骤中，文档被加入到索引列表。

3). 搜索组件

搜索处理过程就是从索引中查找单词，从而找到包含该单词的文档。搜索质量主要由查准率和查全率来衡量。查全率用来衡量搜索系统查找相关文档的能力；而查准率用来衡量搜索系统过滤非相关文档的能力。
①用户搜索界面
Lucene不提供默认的用户搜索界面，需要自己开发。
②建立查询
用户从搜索界面提交一个搜索请求，通常以HTML表单或者Ajax请求的形式由浏览器提交到你的搜索引擎服务器。然后将这个请求转换成搜索引擎使用的查询对象格式，这称为建立查询。
③搜索查询
查询检索索引并返回与查询语句匹配的文档，结果返回时按照查询请求来排序。
④展现结果
一旦获得匹配查询语句并排好序的文档结果集，接下来就得用直观的、经济的方式为用户展现结果。

4). 索引过程的核心类
IndexWriter 
Directory 
Analyzer 
Document 
Field

①IndexWriter
索引过程的核心组件。这个类负责创建新索引或者打开已有索引，以及向索引中添加、删除或更新被索引文档的信息。可以把IndexWriter看作这样一个对象：它为你提供针对索引文件的写入操作，但不能用于读取或搜索索引。IndexWriter需要开辟一定空间来存储索引，该功能可以由Directory完成。
②Directory
该类描述了Lucene索引的存放位置。它是一个抽象类，它的子类负责具体指定索引的存储路径。用FSDirectory.open方法来获取真实文件在文件系统的存储路径，然后将它们一次传递给IndexWriter类构造方法。IndexWriter不能直接索引文本，这需要先由Analyzer将文本分割成独立的单词才行。
③Analyzer
文本文件在被索引之前，需要经过Analyzer（分析器）处理。Analyzer是由IndexWriter的构造方法来指定的，它负责从被索引文本文件中提取语汇单元，并提出剩下的无用信息。如果被索引内容不是纯文本文件，那就需要先将其转换为文本文档。对于要将Lucene集成到应用程序的开发人员来说，选择什么样Analyzer是程序设计中非常关键的一步。分析器的分析对象为文档，该文档包含一些分离的能被索引的域。
④Document
Document对象代表一些域（Field）的集合。文档的域代表文档或者文档相关的一些元数据。元数据（如作者、标题、主题和修改日期等）都作为文档的不同域单独存储并被索引。Document对象的结构比较简单，为一个包含多个Filed对象容器；Field是指包含能被索引的文本内容的类。
⑤Field
索引中的每个文档都包含一个或多个不同命名的域，这些域包含在Field类中。每个域都有一个域名和对应的域值，以及一组选项来精确控制Lucene索引操作各个域值。

5).搜索过程中的核心类
IndexSearcher 
Term 
Query 
TermQuery 
TopDocs

①IndexSearcher
该类用于搜索由IndexWriter类创建的索引，它是连接索引的中心环节。可以将IndexSearcher类看作是一个以只读方式打开索引的类。它需要利用Directory实例来掌控前期创建的索引，然后才能提供大量的搜索方法。
②Term
Term对象是搜索功能的基本单元。Term对象包含一对字符串元素：域名和单词（或域名文本值）。
③Query
包含了一些非常有用的方法，TermQuery是它的一个子类。
④TermQuery
该类提供最基本的查询，用来匹配指定域中包含特定项的文档。
⑤TopDocs
该类是一个简单的指针容器，指针一般指向前N个排名的搜索结果，搜索结果即匹配查询条件的文档。

6). 域索引选项
7).域存储选项
8). Lucene 并发处理规则

任意数量的制度只读的IndexReader类都可以同时打开一个索引。在单个JVM内，利用资源和发挥效率最好的办法是用多线程共享单个的IndexReader实例。
对于一个索引来说，一次只能打开一个Writer。lucene采用文件锁来提供保障。一旦建立起IndexWriter对象，系统会分配一个锁，该锁只有当IndexWriter对象被关闭时才会释放。
IndexReader 对象甚至可以在IndexWriter对象正在修改索引时打开。每个IndexReader对象将向索引展示自己被打开的时间点。该对象只有在IndexWriter对象提交修改或自己被重新打开后才能获知索引的修改情况。在已经有IndexReader对象被打开的情况下，打开新的IndexReader时采用参数cache=true，这样新的IndexReader会持续检查索引的情况。
任何多个线程都可以共享同一个IndexReader类或IndexWriter类。这些类不仅是线程安全的，而且是线程友好的。

9). IndexReader和IndexWriter删除文档的区别

2. 子类

1). Directory子类
2). 核心锁实现
3).搜索类
4). 常用分析器
5). 语汇单元属性
6). 主要可用分析器
7).索引文件格式

3. Luence 使用

1). 全文检索过程
图1.png
2). 创建文档对象

获取原始内容的目的是为了索引,在索引前,需要将原始内容创建成文档(Document),文档中包括一个一个的域(Field),域中存储内容;我们可以将磁盘上的一个文件当成一个 document, Document 中包括一些Field(file_name 文件名称, file_path文件路径, file_size 文件大小, file_content 文件内容);一个 Document 可以有多个 Field,同一个Document,可以有相同的 Field(域名和域值都相同);每一个 Document 都有一个唯一的编号,就是文档 id;


图2.png
3). 分析文档

将原始内容创建为包含域(Field)的文档(document),需要再对域中的内容进行分析,分析的过程是经过对原始文档提取单词,将字母转为小写,去除标点符号,去除停用词等过程生成最终的语汇单元,可以将语汇单元理解为一个一个的单词;每一个单词叫做一个Term,不同的域中拆分出来的相同的单词是不同的term; term中包含两部分,一部分是文档的域名, 另一部分是单词的内容。

Field 域的属性

4). 创建索引

对所有文档分析得出的语汇单元进行索引,索引的目的是为了搜索,最终要实现只搜索被索引的语汇单元从而找到 Document，这种索引的结构叫倒排索引结构;传统方法是根据文件找到该文件的内容,在文件内容中匹配搜索关键字,这种方法是顺序扫描方法,数据量大,搜索慢;倒排索引结构是根据内容(词语)找文档; 顺序扫描方法是根据文档查找里面的内容。


图4.png

I. 导入jar包
commons-io-2.5.jar、lucene-analyzers-common-7.3.0.jar、lucene-core-7.3.0.jar、lucene-queryparser-7.3.0.jar


图5.png

II. 测试代码

/**
 *  Lucene索引 测试
 * 使用到的Jar包：
 * commons-io-2.5.jar
 * lucene-analyzers-common-7.3.0.jar
 * lucene-core-7.3.0.jar
 * lucene-queryparser-7.3.0.jar
 * 
 * @author mazaiting
 */
public class IndexTest {
    
    /**
     * 测试创建索引
     * @throws IOException
     */
    @Test
    public void createIndexTest() throws IOException {
        // 指定索引库的存放位置(Directory 对象)
        Path path = FileSystems.getDefault().getPath("D:\\distribution\\lucene");
        // 1. 创建Directory对象
        // FSDirectory磁盘存储; Directory 保存索引
        Directory directory = FSDirectory.open(path);
        // 2. 指定分词器
        // 基于复杂的语法来生成语汇单元，该语法能识别E-mail地址、首字母缩写词词、
        // 韩语/汉语/日语等字符、字母数字等，还能完成小写转换和移除停用词
        Analyzer analyzer = new StandardAnalyzer();
        // IndexWriter配置对象
        IndexWriterConfig config = new IndexWriterConfig(analyzer);
        // 3. 创建IndexWriter对象
        IndexWriter indexWriter = new IndexWriter(directory, config);
        
        // 4. 指定原始文件的目录
        File fileDir = new File("G:\\test");
        // 获取文件夹和文件列表
        File[] fileList = fileDir.listFiles();
        
        // 遍历
        for (File file : fileList) {
            // 判断是否为路径，如果不是路径则执行里面的内容
            if (!file.isDirectory()) {
                // 5. 创建文档对象
                Document document = new Document();
                
                // 文件名称
                // 分词 索引 存储
                String fileName = file.getName();
                Field fileNameField = new TextField("fileName", fileName, Store.YES);
                
                // 文件大小
                // 分词 索引 存储
                long fileSize = FileUtils.sizeOf(file);
                Field fileSizeField = new TextField("fileSize", String.valueOf(fileSize), Store.YES);
                
                // 文件路径
                // 不分词 不索引 存储
                String filePath = file.getPath();
                Field filePathField = new StoredField("filePath", filePath);
                
                // 文件内容
                String fileContent = FileUtils.readFileToString(file, "UTF-8");
                Field fileContentField = new TextField("fileContent", fileContent, Store.YES);
                        
                // 添加字段
                document.add(fileNameField);
                document.add(fileSizeField);
                document.add(filePathField);
                document.add(fileContentField);
                
                // 使用IndexWriter对象将Document对象写入到索引库
                indexWriter.addDocument(document);
            }
        }
        // 关闭IndexWriter对象
        indexWriter.close();
    }   
    
}

III. 执行测试代码
G:\\test目录文件如下：

图6.png

在路径D:\distribution\lucene\多了些文件

图7.png
5). 查询索引

用户输入查询关键字执行搜索前,需要先创建一个查询对象,查询对象中可以指定查询要搜索的 Field 文档域,查询关键字等,查询对象会生成具体的查询语法;根据查询语法在倒排索引词典表中分别找出对应搜索词的索引,从而找到索引所链接的文档链表。


图7.png

I. 测试代码

/**
 * Lucene索引 测试
 * 使用到的Jar包：
 * commons-io-2.5.jar
 * lucene-analyzers-common-7.3.0.jar
 * lucene-core-7.3.0.jar
 * lucene-queryparser-7.3.0.jar
 * 
 * @author mazaiting
 */
public class IndexTest {
    /**
     * 查询索引
     * 步骤：
     *  1. 创建一个Directory对象，用于指定索引库存放的位置
     *  2. 创建一个IndexReader对象，需要指定Directory对象，用于读取索引库中的文件
     *  3. 创建一个IndexSearcher对象，需要指定IndexReader对象
     *  4. 创建一个TermQuery对象，指定查询的域和查询的关键词
     *  5. 执行查询
     *  6. 返回查询结果，遍历查询结果并输出
     *  7. 关闭IndexReader    
     * @throws IOException 
     */
    @Test
    public void searchIndexTest() throws IOException {
        // Directory, 指定索引库存放的位置
        Path path = FileSystems.getDefault().getPath("D:\\distribution\\lucene");
        Directory directory = FSDirectory.open(path);
        // IndexReader, 读取索引库中的文件
        IndexReader indexReader = DirectoryReader.open(directory);
        // IndexSearcher, 用于查询
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        // TermQuery, 指定查询的域和查询的关键词
        Query query = new TermQuery(new Term("fileName", "java.txt"));
        // 执行查询
        TopDocs topDocs = indexSearcher.search(query, 100);
        // 获取数组
        ScoreDoc[] scoreDocs =  topDocs.scoreDocs;
        System.out.println(scoreDocs.length);
        // 遍历结果文档
        for (ScoreDoc scoreDoc : scoreDocs) {
            // 获取文档id
            int docId = scoreDoc.doc;
            // 通过id从索引中获取对应的文档
            Document document = indexReader.document(docId);
            // 获取文件名称
            String fileName = document.get("fileName");
            // 获取文件路径
            String filePath = document.get("filePath");
            // 获取文件大小
            String fileSize = document.get("fileSize");
            // 获取文件内容
            String fileContent = document.get("fileContent");
            System.out.println("==========================================");
            System.out.println("文件名：" + fileName + "\n"
                    + "文件大小： " + fileSize + "\n"
                    + "文件路径：" + filePath + "\n"
                    + "文件内容：" + fileContent);
            
        }
        // 关闭IndexReader
        indexReader.close();
    }
    
}

II. 执行测试代码
打印结果:


图8.png
6). 分词器

支持中文的分词器： IKAnalyzer
从一个 Reader 字符流开始,创建一个基于 Reader 的 Tokenizer分词器,经过三个 TokenFilter,生成语汇单元 Tokens。

图9.png
I. 代码 
/**
 * Lucene索引 测试
 * 使用到的Jar包：
 * commons-io-2.5.jar
 * lucene-analyzers-common-7.3.0.jar
 * lucene-core-7.3.0.jar
 * lucene-queryparser-7.3.0.jar
 * 
 * @author mazaiting
 */
public class IndexTest {
    
    /**
     * 查看标准分词器的分词效果
     * @throws IOException 
     */
    @Test
    public void analyzerTest() throws IOException {
        // 创建一个标准分词器对象
        Analyzer analyzer = new StandardAnalyzer();
        // 获得TokenStream对象
        // 参数1： 字段名，可以随便给；参数2: 要分析的文本内容
        TokenStream tokenStream = analyzer.tokenStream("test", 
                "The Spring Framework provides a comprehensive programming and configuration model.");
        // 添加引用，可以获得每个关键字
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        // 添加一个偏移量的引用，记录了关键词的开始位置及结束位置
        OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
        // 将指针调整到列表的头部
        tokenStream.reset();
        // 遍历关键词列表，通过incrementToken方法判断列表是否结束
        while (tokenStream.incrementToken()) {
            // 关键词其实位置
            System.out.println("start->" + offsetAttribute.startOffset());
            // 取关键词
            System.out.println(charTermAttribute);
            // 结束位置
            System.out.println("end->" + offsetAttribute.endOffset());          
        }
        // 关闭
        tokenStream.close();
        analyzer.close();
    }
}

II. 执行测试


图10.png
7). 索引库维护工具类
/**
 * 索引库维护工具类
 * @author mazaiting
 */
public class LuceneManager {
    /**
     * 获取IndexWriter对象
     * @return
     */
    public IndexWriter getIndexWriter() {
        try {
            // 获取索引库路径
            Path path = FileSystems.getDefault().getPath("D:\\distribution\\lucene");
            // 创建索引库字典
            Directory directory = FSDirectory.open(path);
            // 创建分析器
            Analyzer analyzer = new StandardAnalyzer();
            // 创建IndexWriter配置
            IndexWriterConfig config = new IndexWriterConfig(analyzer);
            return new IndexWriter(directory, config);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 全部删除 
     * @throws IOException
     */
    @Test
    public void delAllTest() throws IOException {
        IndexWriter writer = getIndexWriter();
        writer.deleteAll();
        writer.close();
    }
    
    /**
     * 根据条件删除
     * @throws IOException 
     */
    @Test
    public void delTest() throws IOException {
        IndexWriter writer = getIndexWriter();
        Query query = new TermQuery(new Term("fileName", "java"));
        writer.deleteDocuments(query);
        writer.close();
    }
    
    /**
     * 更新
     * @throws IOException 
     */
    @Test
    public void update() throws IOException {
        IndexWriter writer = getIndexWriter();
        Document document = new Document();
        document.add(new TextField("fileName", "测试文件名", Store.YES));
        document.add(new TextField("fileContent", "测试文件内容", Store.YES));
        
        // 将lucene删除， 然后添加
        writer.updateDocument(new Term("fileName", "lucene"), document);
        writer.close();
    }
    
}
8). 索引库查询

对要搜索的信息创建 Query 查询对象,Lucene会根据 Query 查询对象生成最终的查询语法;
可通过两种方法创建查询对象:

/**
 * 索引库维护工具类
 * 
 * @author mazaiting
 */
public class LuceneManager {
    /**
     * 获取IndexSearcher
     * 
     * @return
     */
    public IndexSearcher getIndexSearcher() {
        try {
            // 获取索引库路径
            Path path = FileSystems.getDefault().getPath("D:\\distribution\\lucene");
            // 创建索引库字典
            Directory directory = FSDirectory.open(path);
            // 创建索引读取者
            IndexReader indexReader = DirectoryReader.open(directory);
            return new IndexSearcher(indexReader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取执行结果
     * 
     * @throws IOException
     */
    public void printResult(IndexSearcher indexSearcher, Query query) throws IOException {
        // 执行查询
        TopDocs topDocs = indexSearcher.search(new TermQuery(new Term("fileName")), 10);
        // 获取数组
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        System.out.println(scoreDocs.length);
        // 遍历结果文档
        for (ScoreDoc scoreDoc : scoreDocs) {
            // 获取文档id
            int docId = scoreDoc.doc;
            // 通过id从索引中获取对应的文档
            Document document = indexSearcher.doc(docId);
            // 获取文件名称
            String fileName = document.get("fileName");
            // 获取文件路径
            String filePath = document.get("filePath");
            // 获取文件大小
            String fileSize = document.get("fileSize");
            // 获取文件内容
            String fileContent = document.get("fileContent");
            System.out.println("==========================================");
            System.out.println("文件名：" + fileName + "\n" + "文件大小： " + fileSize + "\n" + "文件路径：" + filePath + "\n"
                    + "文件内容：" + fileContent);

        }
    }
    
    /**
     * 查询所有
     * @throws IOException 
     */
    @Test
    public void matchAllDocsQueryTest() throws IOException {
        // 获取查询索引对象
        IndexSearcher indexSearcher = getIndexSearcher();
        // 查询所有
        Query query = new MatchAllDocsQuery();
        // 打印结果
        printResult(indexSearcher, query);
        // 关闭资源
        indexSearcher.getIndexReader().close();
    }
    
    /**
     * 组合查询
     * @throws IOException 
     */
    @Test
    public void boolQueryTest() throws IOException {
        // 创建搜索
        IndexSearcher indexSearcher = getIndexSearcher();
        // 创建查询
        Query query1 = new TermQuery(new Term("fileName", "java.txt"));
        Query query2 = new TermQuery(new Term("fileName", "c.txt"));
        // 构建表达式 
        // Occur.MUST: 必须满足此条件, 相当于 and
        // Occur.SHOULD: 应该满足此条件, 但是不满足也可以, 相当于 or
        // Occur.MUST_NOT: 必须不满足, 相当于 not
        BooleanClause clause1 = new BooleanClause(query1, Occur.SHOULD);
        // Build模式创建
        BooleanQuery.Builder builder = new BooleanQuery.Builder();
        // 添加表达式
        builder.add(clause1);
        // 添加查询
        builder.add(query2, Occur.SHOULD);
        // 打印
        printResult(indexSearcher, builder.build());
        // 关闭资源
        indexSearcher.getIndexReader().close();
    }
    
    /**
     * 使用QueryParser解析查询表达式
     * @throws ParseException 
     * @throws IOException 
     */
    @Test
    public void queryParserTest() throws ParseException, IOException {
        IndexSearcher indexSearcher = getIndexSearcher();
        // 创建QueryParser对象，其中参数一：字段名，参数而分词器
        QueryParser queryParser = new QueryParser("fileName", new StandardAnalyzer());
        // 此时：表示使用默认域：fileName
        // 查询fileContent域
        Query query = queryParser.parse("fileContent:apache");
        // 打印
        printResult(indexSearcher, query);
        // 关闭资源
        indexSearcher.getIndexReader().close();
    }
    
    /**
     * 指定多个默认搜索域
     * @throws ParseException 
     * @throws IOException 
     */
    @Test
    public void multiFieldQueryParser() throws ParseException, IOException {
        IndexSearcher indexSearcher = getIndexSearcher();
        // 指定多个默认搜索域
        String[] fields = {"fileName", "fileContent"};
        // 创建MultiFieldQueryParser对象
        MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields, new StandardAnalyzer());
        // 创建查询
        Query query = queryParser.parse("apache");
        // 输出查询条件
        System.out.println(query);
        // 执行查询
        printResult(indexSearcher, query);
        // 关闭资源
        indexSearcher.getIndexReader().close();
    }
}

代码下载

上一篇下一篇

猜你喜欢

热点阅读