标签：doc Lucene 索引 文档 new println 搜索 out

1、倒排索引

举个例子：使用新华字典查找汉字，先找到汉字的偏旁部首，再根据偏旁部首对应的目录（索引）找到目标汉字。

样例：

• 文档0(编号0)： we like java java java

• 文档1(编号1)： we like lucene lucene lucene

（Term 词条）	(Doc 文档，Freq 频率)	（Pos 位置）
we	(0,1) (1,1)	(0)(0)
like	(0,1) (1,1)	(1)(1)
java	(0,3)	(2,3,4)
lucene	(1,3)	(2,3,4)

 存储格式：词条/词语在哪个文档出现（文档编号）、出现的频率（次数）、出现的位置（下标）

2、Lucene介绍

2.1 全文检索是什么?

• 索引流程：通过索引程序切分数据的内容成一个个词语，建立词语与每一条数据的对应关系

• 检索流程：通过检索程序，根据搜索关键词，在索引库查找目标内容

2.2 Lucene是什么?

• Lucene是apache软件基金会下的一个子项目。是一个成熟、免费、开放源代码的全文检索引擎工具包。提供了一套简单易用的API，方便在目标系统中实现全文检索功能。

• Lucene能够为文本类型的数据建立索引，只需要把数据转换成文本格式即可，但是像word文档、html文档、pdf文档，就需要将文档内容转换成文本格式，才能使用lucene的API建立索引数据。

2.3 Lucene&搜索引擎区别

• Lucene是一个全文检索引擎工具包，相当于汽车发动机，搜索引擎基于全文检索实现，是一个可以独立运行的软件产品，相当于汽车。

3、全文检索流程介绍

3.1 索引和检索流程图

3.2 索引流程详细介绍

• 采集数据

  • 通过JDBC操作获取到关系数据库中的业务数据

  • 通过IO流获取文件上的数据

  • 通过爬虫（蜘蛛）程序获取网络上的网页数据

• 创建文档对象【重点】

  • 说明：文档对象（Document），一个文档对象包含有多个域（Field）。一个文档对象就相当于关系数据库表中的一条记录，一个域就相当于一个字段。

• 分析文档对象

  • 把原始数据，转换成文档对象后，使用分词器把文档中域的内容切分成一个个词语，为后续建立索引做准备。

• 建立倒排索引

  • 建立词语和文档的对应关系，词语在什么文档出现，出现了几次，在什么位置出现（倒排索引），并且保存到索引库。

3.3 检索流程详细介绍

• 建立查询对象【重点】

  • 根据用户输入的搜索关键词，使用分析器分词以后，建立查询对象（Query），Query对象会生成具体的查询语法。

• 执行搜索

  • 根据查询对象（Query），和Query生成的语法，在索引库中查询目标内容。

• 返回查询结果

  • 提供一个搜索结果页面，把搜索结果友好的展示给用户（搜索关键词是高亮显示，搜索结果有排序）

3.4 数据库&索引库结构对比

数据库	表	行	列
Databases实例	Tables	Rows	column
索引库的存储目录	无	Document文档	Field域

4、Lucene环境搭建

4.1配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.it</groupId>
    <artifactId>lucene-test</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <mysql.version>5.1.47</mysql.version>
        <lucene.version>4.10.3</lucene.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.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-queryparser</artifactId>
            <version>${lucene.version}</version>
        </dependency>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

4.2原始数据采集

图书实体类

package cn.it.pojo;

import lombok.Data;

/**
 * 图书实体类
 *
 * @Author LK
 * @Date 2020/12/11
 */
@Data
public class Book {

    // 图书id
    private int id;

    // 图书名称
    private String bookName;

    // 图书价格
    private float bookPrice;

    // 图书图片
    private String bookPic;

    // 图书描述
    private String bookDesc;
}

图书dao接口

package cn.it.dao;

import cn.it.pojo.Book;

import java.util.List;

/**
 * 图书数据访问层接口
 *
 * @Author LK
 * @Date 2020/12/11
 */
public interface BookDao {

    /**
     * 查询所有图书
     * @return
     */
    public List<Book> findAll();
}

dao实现类

package cn.it.dao.impl;

import cn.it.dao.BookDao;
import cn.it.pojo.Book;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 图书数据访问层实现类
 *
 * @Author LK
 * @Date 2020/12/11
 */
public class BookDaoImpl implements BookDao {

    @Override
    public List<Book> findAll() {

        List<Book> bookList = new ArrayList<>();

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.获取数据库连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lucenedb", "root", "123456");
            // 3.编写sql语句（实际项目中不要写*）
            String searchSql = "select * from book";
            // 4.获取statement对象
            preparedStatement = connection.prepareStatement(searchSql);
            // 5.执行搜索，返回ResultSet结果集
            resultSet = preparedStatement.executeQuery();
            // 6.处理结果集
            while (resultSet.next()) {
                Book book = new Book();
                book.setId(resultSet.getInt("id"));
                book.setBookName(resultSet.getString("bookname"));
                book.setBookPrice(resultSet.getFloat("price"));
                book.setBookPic(resultSet.getString("pic"));
                book.setBookDesc(resultSet.getString("bookdesc"));

                bookList.add(book);
            }

        } catch (Exception e) {
            // 里面是使用全局的输出流，往控制台输出
            // e.printStackTrace();
            // 一般在项目中使用log打印，或往外层继续抛出异常
            throw new RuntimeException(e);
        } finally {
            // 7.关闭资源
            try {
                if(connection!=null){
                    connection.close();;
                }
                if(preparedStatement!=null){
                    preparedStatement.close();;
                }
                if(resultSet!=null){
                    resultSet.close();;
                }
            } catch (Exception e) {
                // 里面是使用全局的输出流，往控制台输出
                // e.printStackTrace();
                // 一般在项目中使用log打印，或往外层继续抛出异常
            }
        }

        return bookList;
    }
}

4.3索引流程实现

实现步骤

• 创建文档对象（Document）

• 创建分词器（Analyzer），用于分词

• 创建索引配置对象（IndexWriterConfig），指定索引库配置信息

• 创建索引目录对象（Directory），指定索引库的位置

• 创建索引写入对象（IndexWriter），把文档对象写入索引库

• 提交事务

• 释放资源

代码

package cn.it;

import cn.it.dao.BookDao;
import cn.it.dao.impl.BookDaoImpl;
import cn.it.pojo.Book;
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.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
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.util.ArrayList;
import java.util.List;

/**
 * 索引相关单元测试类
 *
 * @Author LK
 * @Date 2020/12/11
 */
public class IndexTest {

    /**
     * 索引流程
     *
     * @throws Exception
     */
    @Test
    public void createIndex() throws Exception {
        BookDao bookDao = new BookDaoImpl();
        List<Book> bookList = bookDao.findAll();
        System.out.println("bookList = " + bookList);

        // 1.创建文档对象（Document）
        List<Document> documentList = new ArrayList<>();
        for (Book book : bookList) {
            Document document = new Document();
            /**
             * 给文档对象添加域
             * 方法：add（）
             * 参数：TextField
             * TextField参数：
             *   参数一：域的名称
             *   参数二：域的值
             *   参数三：指定是否把域值存储到文档对象中，最终保存在磁盘上
             */
            document.add(new TextField("id", book.getId() + "", Field.Store.YES));
            document.add(new TextField("bookName", book.getBookName(), Field.Store.YES));
            document.add(new TextField("bookPrice", book.getBookPrice() + "", Field.Store.YES));
            document.add(new TextField("bookPic", book.getBookPic(), Field.Store.YES));
            document.add(new TextField("bookDesc", book.getBookDesc(), Field.Store.YES));
            documentList.add(document);
        }

        // 2 创建分词器（Analyzer），用于分词
        Analyzer analyzer = new StandardAnalyzer();
        // 3.创建索引配置对象（IndexWriterConfig），配置索引库
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
        // 3.1 设置一个打开模式
        // CREATE-每次都覆盖之前的索引库，创建新的索引库
        // APPEND-追加，如果存在索引库，直接追加数据，否则报错
        // CREATE_OR_APPEND-创建或追加，如果存在就追加，没有就创建
        indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE);

        // 4.创建索引目录对象（Directory），指定索引库的位置
        Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));
        // 5.创建索引写入对象（IndexWriter），把文档对象写入索引库
        IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

        for (Document document : documentList) {
            // 5.1 写入文档
            indexWriter.addDocument(document);
            // 6.提交事务
            indexWriter.commit();
        }
        // 7.释放资源
        indexWriter.close();
    }

}

运行结果：

5、检索流程实现

实现步骤

• 创建分词器对象（Analyzer），用于对关键字分词

• 创建查询对象（Query），相当于sql语句

• 创建索引目录对象（Directory），指定索引库的位置

• 创建索引读取对象（IndexReader），把索引数据读取到内存中

• 创建索引查询对象（IndexSearcher），执行搜索

• 执行搜索，返回结果集（TopDocs）

• 处理结果集

• 释放资源

核心代码

/**
 * 检索流程
 */
@Test
public void searchIndex() throws Exception{

    // 1.创建分词器对象（Analyzer），用于对关键字分词
    Analyzer analyzer = new StandardAnalyzer();
    // 2.创建查询对象（Query）
    // 2.1 创建查询解析器
    QueryParser queryParser = new QueryParser("", analyzer);
    Query query = queryParser.parse("bookName:java");
    // 3.创建索引目录对象（Directory），指定索引库的位置
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));
    // 4.创建索引读取对象（IndexReader），把索引数据读取到内存中
    IndexReader indexReader = DirectoryReader.open(directory);
    // 5.创建索引查询对象（IndexSearcher），执行搜索
    IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    // 6.执行搜索，返回结果集（TopDocs）
    TopDocs topDocs = indexSearcher.search(query, 10);
    System.out.println("总命中数 = " + topDocs.totalHits);
    // 7.处理结果集
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;

    for (ScoreDoc scoreDoc : scoreDocs) {
        System.out.println("--------------------------------");
        System.out.println("文档分数 = " + scoreDoc.score + ",文档id = " + scoreDoc.doc);
        // 根据主键id获取文档对象
        Document doc = indexSearcher.doc(scoreDoc.doc);
        System.out.println("图书id = " + doc.get("id"));
        System.out.println("图书名称 = " + doc.get("bookName"));
        System.out.println("图书价格 = " + doc.get("bookPrice"));
        System.out.println("图书图片 = " + doc.get("bookPic"));
        System.out.println("图书描述 = " + doc.get("bookDesc"));
    }
    // 8.释放资源
    indexReader.close();
}

6、分词器：介绍与作用

分词器介绍

在对文档（Document）中的内容进行存储之前，需要使用分词器对域（Field）中的内容进行分词，目的是为了建立倒排索引，过程是先分词，再过滤。

• 分词：将Document中Field域的值根据分词器内部的词典切分成一个一个的单词，具体的切分方式根据使用的分词器而不同。

• 过滤：分词完毕后，通过过滤器排除一些标点符号以及一些停用词，也会将词条的大写转换小写。

• 停用词说明：停用词是指为了节省存储空间和提高搜索效率，在对field内容或搜索关键字分词时会自动排除的字或词，这些字或词被称为“stop words”。如语气助词、副词、介词、连接词等等（的、在、是、啊）

分词器作用

• 【索引流程】: 把原始数据转换成文档对象后，使用分词器把文档域中的内容切分成一个一个的词语，目的是方便后续建立索引。

• 【检索流程】: 根据用户输入的搜索关键词，将关键字进行分词，建立成查询对象（Query），在索引库中查找目标内容。

注意事项：索引流程和检索流程使用分词器要一致。

7、Field：特性与种类

Field的特性

Document（文档）是Field（域）的承载体，一个Document是由多个Field组成。Field由名称和值两部分组成，Field的值是要索引的内容，也是要搜索的内容。

 

• 是否分词（tokenized）

是：将Field的值进行分词处理，分词的目的是为了建立倒排索引。
比如：商品名称，商品描述，这些内容用户需要输入关键词进行查询，由于内容格式大，内容多，需要进行分词处理建立索引。

否：不做分词处理
比如：订单编号，身份证号。是一个整体，分词以后没有意义，不需要分词。

• 是否索引（indexed）

是：将Field内容进行分词处理后得到的词或者整体Field内容作为一个词条去建立索引，存储到索引域。索引的目的是为了搜索。
比如：商品名称，商品描述需要分词建立索引。订单编号，身份证号作为整体建立倒排索引。只要将来要作为用户查询条件的词，都需要索引。

否：不索引。
比如：商品图片路径，不作为查询条件，不需要建立索引。

是否存储（stored）

是：将Field值保存到Document中，最终保存到磁盘上面。
比如：商品名称，商品价格。凡是将来在搜索结果页面展现给用户的内容，都需要存储。

否：不存储。
比如：商品描述。内容多格式大，不需要直接在搜索结果页面展现，不做存储。需要的时候可以从关系数据库取。

Field的种类

Field种类	数据类型	是否 分词	是否 索引	是否 存储	说明
StringField(FieldName, FieldValue,Store.YES)	字符串	N	Y	Y或N	字符串类型Field，不分词，作为一个整体进行索引（比如：身份证号，订单编号），是否需要存储根据Store.YES或Store.NO决定
LongField(FieldName, FieldValue,Store.YES)	数值型代表	Y	Y	Y或N	数值型Field代表，分词并且索引（比如：价格），是否需要存储根据Store.YES或Store.NO决定
StoredField(FieldName, FieldValue)	重载方法，支持多种类型	N	N	Y	不分词，不索引，默认存储（比如：商品图片路径）
TextField(FieldName, FieldValue,Store.NO)	文本类型	Y	Y	Y或N	文本类型Field，分词并且索引，是否需要存储根据Store.YES或Store.NO决定

8、索引维护

添加文档

/**
 * 添加文档
 */
@Test
public void addDoc() throws Exception{
    // 1.创建文档对象
    Document document = new Document();
    document.add(new StringField("id", "6", Field.Store.YES));
    document.add(new TextField("bookName", "金瓶梅", Field.Store.YES));
    document.add(new DoubleField("bookPrice", 80d, Field.Store.YES));
    document.add(new StoredField("bookPic", "11.jpg"));
    document.add(new TextField("bookDesc", "传闻还不错，但是我没看过", Field.Store.NO));

    // 2.创建分词器
    Analyzer analyzer = new IKAnalyzer();

    // 3.创建索引配置对象
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);

    // 3.1 设置打开模式
    indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

    // 4.创建索引目录对象
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));

    // 5.创建索引写入对象
    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

    // 6.写入文档，提交事务
    indexWriter.addDocument(document);
    indexWriter.commit();

    // 7.关闭资源
    indexWriter.close();
}

删除文档

/**
 * 删除文档
 */
@Test
public void deleteDoc() throws Exception{
    // 2.创建分词器
    Analyzer analyzer = new IKAnalyzer();

    // 3.创建索引配置对象
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);

    // 3.1 设置打开模式
    indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

    // 4.创建索引目录对象
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));

    // 5.创建索引写入对象
    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

    // 6.删除文档，提交事务
    // 6.1 根据条件删除，删除图书名称包含java的图书
    // 执行流程：1、先根据关键字进行匹配（不会对关键字进行分词）; 2、删除匹配到的数据
    indexWriter.deleteDocuments(new Term("bookName", "java"));
    // 6.2 删除全部
    // indexWriter.deleteAll();

    indexWriter.commit();

    // 7.关闭资源
    indexWriter.close();
}

修改文档

/**
 * 修改文档
 */
@Test
public void updateDoc() throws Exception{
    // 1.创建文档对象（修改后的数据）
    Document document = new Document();
    document.add(new StringField("id", "7", Field.Store.YES));
    document.add(new TextField("bookName", "金瓶梅2020", Field.Store.YES));
    document.add(new DoubleField("bookPrice", 90d, Field.Store.YES));
    document.add(new StoredField("bookPic", "123.jpg"));
    document.add(new TextField("bookDesc", "传闻还不错，但是我没看过11", Field.Store.NO));

    // 2.创建分词器
    Analyzer analyzer = new IKAnalyzer();

    // 3.创建索引配置对象
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);

    // 3.1 设置打开模式
    indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

    // 4.创建索引目录对象
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));

    // 5.创建索引写入对象
    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

    // 6.修改文档，提交事务
    // 修改图书名称包含java的书籍
    // 执行流程：1、先根据关键字进行匹配（不会对关键字进行分词）; 2、删除匹配到的数据; 3-添加新的数据
    indexWriter.updateDocument(new Term("bookName", "java"), document);
    indexWriter.commit();

    // 7.关闭资源
    indexWriter.close();
}

词条搜索

public class QueryTest {

    /**
     * 词条匹配：查询图书名称域中包含有java的图书
     */
    @Test
    public void queryByTerm() throws Exception {

        // 1.创建查询对象
        Query query = new TermQuery(new Term("bookName", "java"));

        // 2.创建索引目录对象
        Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));

        // 3.创建索引读取对象
        IndexReader indexReader = DirectoryReader.open(directory);

        // 4.创建索引查询对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        // 5.执行搜索
        TopDocs topDocs = indexSearcher.search(query, 10);
        System.out.println("总命中数 = " + topDocs.totalHits);
        // 6.处理返回结果
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {
            System.out.println("----------------------------------");
            System.out.println("文档分数 = " + scoreDoc.score + ",文档id = " + scoreDoc.doc);
            Document doc = indexSearcher.doc(scoreDoc.doc);
            System.out.println("图书id = " + doc.get("id"));
            System.out.println("图书名称 = " + doc.get("bookName"));
            System.out.println("图书价格 = " + doc.get("bookPrice"));
            System.out.println("图书图片 = " + doc.get("bookPic"));
            System.out.println("图书描述 = " + doc.get("bookDesc"));
        }
        // 7.关闭资源	
        indexReader.close();
    }
}

范围查询

/**
 * 范围查询：搜索图书价格大于80，小于100的图书
 */
@Test
public void queryByRange() throws Exception{
    // 1.创建查询对象
    // 参数1-字段名称
    // 参数2-最小值
    // 参数3-最大值
    // 参数4-是否包含最小值
    // 参数5-是否包含最大值
    Query query = NumericRangeQuery.newDoubleRange("bookPrice", 80d, 100d, false, false);

    search(query);
}

/**
 * 搜索公共方法
 * @param query
 * @throws Exception
 */
private void search(Query query) throws Exception{
    // 2.创建索引目录对象
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));

    // 3.创建索引读取对象
    IndexReader indexReader = DirectoryReader.open(directory);

    // 4.创建索引查询对象
    IndexSearcher indexSearcher = new IndexSearcher(indexReader);

    // 5.执行搜索
    TopDocs topDocs = indexSearcher.search(query, 10);
    System.out.println("总命中数 = " + topDocs.totalHits);
    // 6.处理返回结果
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;
    for (ScoreDoc scoreDoc : scoreDocs) {
        System.out.println("----------------------------------");
        System.out.println("文档分数 = " + scoreDoc.score + ",文档id = " + scoreDoc.doc);
        Document doc = indexSearcher.doc(scoreDoc.doc);
        System.out.println("图书id = " + doc.get("id"));
        System.out.println("图书名称 = " + doc.get("bookName"));
        System.out.println("图书价格 = " + doc.get("bookPrice"));
        System.out.println("图书图片 = " + doc.get("bookPic"));
        System.out.println("图书描述 = " + doc.get("bookDesc"));
    }
    // 7.关闭资源
    indexReader.close();
}

组合查询

/**
 * 组合查询：查询图书名称中包含有lucene，并且80<=图书价格<=100之间的图书
 */
@Test
public void queryByBool() throws Exception{
    BooleanQuery booleanQuery = new BooleanQuery();

    // 条件1：图书名称中包含有lucene
    TermQuery termQuery = new TermQuery(new Term("bookName", "lucene"));

    // 条件2：80<=图书价格<=100
    NumericRangeQuery<Double> numberRangeQuery = NumericRangeQuery.newDoubleRange("bookPrice", 80d, 100d, true, true);

    // 添加条件，指定组合关系为 且
    booleanQuery.add(termQuery, BooleanClause.Occur.MUST);
    booleanQuery.add(numberRangeQuery, BooleanClause.Occur.MUST);

    search(booleanQuery);

}

条件表达式

/**
 * 条件表达式搜索：查询图书名称中包含有java，并且包含lucene的图书
 */
@Test
public void queryByExpress() throws Exception{

    Analyzer analyzer = new IKAnalyzer();

    // 参数1：查询的field
    QueryParser queryParser = new QueryParser("", analyzer);

    Query query = queryParser.parse("bookName:java AND bookName:lucene");

    search(query);
}

分页和排序

/**
 * 分页与排序:查询图书名称包含java或lucene的图书，根据价格升序排序，每页显示2条，查询第2页的数据
 */
@Test
public void pageAndSort() throws Exception {

    // 1.创建分词器对象（Analyzer），用于对关键字分词
    Analyzer analyzer = new IKAnalyzer();
    // 2.创建查询对象（Query）
    // 2.1 创建查询解析器
    QueryParser queryParser = new QueryParser("", analyzer);
    Query query = queryParser.parse("bookName:java OR bookName:lucene");

    // 3.创建索引目录对象（Directory），指定索引库的位置
    Directory directory = FSDirectory.open(new File("D:\\itcast\\ee145\\luceneIndex"));
    // 4.创建索引读取对象（IndexReader），把索引数据读取到内存中
    IndexReader indexReader = DirectoryReader.open(directory);
    // 5.创建索引查询对象（IndexSearcher），执行搜索
    IndexSearcher indexSearcher = new IndexSearcher(indexReader);

    // 6.执行搜索，返回结果集（TopDocs）
    // 6.1 创建排序对象，参数1-字段名，参数2-数据类型，参数3-升序或降序，false代表升序
    SortField sortField = new SortField("bookPrice", SortField.Type.DOUBLE, false);
    Sort sort = new Sort(sortField);

    // 6.2 定义分页参数
    int pageNo = 2; // 当前页
    int pageSize = 2; // 每页显示条数
    TopDocs topDocs = indexSearcher.search(query, pageNo * pageSize, sort);

    System.out.println("总命中数 = " + topDocs.totalHits);
    // 7.处理结果集
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;

    for (int i = (pageNo - 1) * pageSize; i < scoreDocs.length; i++) {

        ScoreDoc scoreDoc = scoreDocs[i];
        System.out.println("--------------------------------");
        System.out.println("文档分数 = " + scoreDoc.score + ",文档id = " + scoreDoc.doc);
        // 根据主键id获取文档对象
        Document doc = indexSearcher.doc(scoreDoc.doc);
        System.out.println("图书id = " + doc.get("id"));
        System.out.println("图书名称 = " + doc.get("bookName"));
        System.out.println("图书价格 = " + doc.get("bookPrice"));
        System.out.println("图书图片 = " + doc.get("bookPic"));
        System.out.println("图书描述 = " + doc.get("bookDesc"));
    }
    // 8.释放资源
    indexReader.close();
}

 

标签：doc,Lucene,索引,文档,new,println,搜索,out
来源： https://blog.csdn.net/qq_36116242/article/details/114410650

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。