搜索之Lucene

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 索引和检索流程图

搜索之Lucene

3.2 索引流程详细介绍

  • 采集数据

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

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

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

  • 创建文档对象【重点】

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

搜索之Lucene

  • 分析文档对象

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

  • 建立倒排索引

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

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();
    }

}

运行结果:

搜索之Lucene

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();
}

 

上一篇:浅谈Elasticsearch集群的工作方式


下一篇:Lucene&ElasticSeach