搜索学习--Lucene中搜索的排序、范围区间搜索、分页搜索、多条件搜索

最新推荐文章于 2023-02-12 16:01:02 发布
最新推荐文章于 2023-02-12 16:01:02 发布
阅读量1k 收藏 1
点赞数
分类专栏： 搜索引擎入门 搜索引擎入门 文章标签： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18860653/article/details/78652216
版权

依赖

     <!-- Lucene核心 -->
            <dependency>
                <groupId>org.apache.lucene</groupId>
                <artifactId>lucene-core</artifactId>
                <version>4.7.2</version>
            </dependency>

        <!-- Lucene搜索查询相关 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
            <version>4.7.2</version>
        </dependency>

        <!-- Lucene分词器相关 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-analyzers-common</artifactId>
            <version>4.7.2</version>
        </dependency>

        <!--高亮-->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-highlighter</artifactId>
            <version>4.7.2</version>
        </dependency>

建立索引

本次增加了Float、Int类型的域

package top.yuyufeng.learn.lucene.demo2;

/**
 * @author yuyufeng
 * @date 2017/11/21
 */

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Version;

import java.io.File;
import java.io.IOException;

/**
 * @author yuyufeng
 * @date 2017/11/21
 */
public class LuceneIndexDemo {
    public static void main(String[] args) {
        // 建立5条索引
        String content = "10月11日杭州云栖大会上，马云表达了对新建成的阿里巴巴全球研究院—阿里巴巴达摩院的愿景，希望达摩院二十年内成为世界第一大经济体，服务世界二十亿人，创造一亿个工作岗位。";
        Long createTime = System.currentTimeMillis();
        String id = createTime + "";
        int readCount =10;
        float score =9.5f;
        index(content, createTime, id, readCount, score);


        content = "中国互联网界，阿里巴巴被认为是技术实力最弱的公司。我确实不懂技术，承认不懂技术不丢人，不懂装懂才丢人。";
        createTime = System.currentTimeMillis();
        id = createTime + "";
        readCount =3;
        score =9.7f;
        index(content, createTime, id, readCount, score);

        content = "阿里巴巴未来二十年的目标是打造世界第五大经济体，不是我们狂妄，而是世界需要这么一个经济体，也一定会有这么一个经济体。";
        createTime = System.currentTimeMillis();
        id = createTime + "";
        readCount =69;
        score =5.6f;
        index(content, createTime, id, readCount, score);

        content = "达摩院一定也必须要超越英特尔，必须超越微软，必须超越IBM，因为我们生于二十一世纪，我们是有机会后发优势的。";
        createTime = System.currentTimeMillis();
        id = createTime + "";
        readCount =38;
        score =4.7f;
        index(content, createTime, id, readCount, score);

        content = "阿里巴巴有很多争议，似乎无处不在，我还真想不出有什么东西是我们不做的。互联网是一种思想，是一种技术革命，不应该有界限。跨界乐趣无穷。我觉得阿里巴巴的跨界还不错";
        createTime = System.currentTimeMillis();
        id = createTime + "";
        readCount =73;
        score =1.7f;
        index(content, createTime, id, readCount, score);

    }

    private static void index(String content, Long createTime, String id, int readCount, float score) {
        // 实例化IKAnalyzer分词器
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);

        Directory directory = null;
        IndexWriter iwriter;
        try {
            // 索引目录
            directory = new SimpleFSDirectory(new File("D://test/lucene_index_blog"));

            // 配置IndexWriterConfig
            IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_47, analyzer);
            iwConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
            iwriter = new IndexWriter(directory, iwConfig);
            // 写入索引
            Document doc = new Document();

            doc.add(new StringField("ID", id, Field.Store.YES));
            doc.add(new TextField("content", content, Field.Store.YES));
            doc.add(new LongField("createTime", createTime, Field.Store.YES));
            doc.add(new IntField("readCount", readCount, Field.Store.YES));
            doc.add(new FloatField("score", score, Field.Store.YES));
            iwriter.addDocument(doc);
            iwriter.close();
            System.out.println("建立索引成功:" + id);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (directory != null) {
                try {
                    directory.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

搜索排序

package top.yuyufeng.learn.lucene.demo2;

/**
 * @author yuyufeng
 * @date 2017/11/21
 */
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Version;

import java.io.File;
import java.io.IOException;

/**
 * created by yuyufeng on 2017/11/13.
 */
public class LuceneSearchDemo {
    public static void main(String[] args) {

        String content = "content";
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
        Directory directory = null;
        IndexReader ireader = null;
        IndexSearcher isearcher;

        try {
            //索引目录
            directory = new SimpleFSDirectory(new File("D://test/lucene_index_blog"));
            // 配置IndexWriterConfig
            IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_47, analyzer);
            iwConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

            // 实例化搜索器
            ireader = DirectoryReader.open(directory);
            isearcher = new IndexSearcher(ireader);

            //查询所有
            Query query = new MatchAllDocsQuery();
            System.out.println("Query = " + query);


            // 排序的关键地方
            SortField sortField = new SortField("score",SortField.Type.FLOAT,true);
            Sort sort = new Sort(sortField);
            TopDocs topDocs = isearcher.search(query, 5,sort);
            System.out.println("命中：" + topDocs.totalHits);
            // 遍历输出结果
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (int i = 0; i < topDocs.totalHits; i++) {
                Document targetDoc = isearcher.doc(scoreDocs[i].doc);
                System.out.println("内容：" + targetDoc.toString());
            }




        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ireader != null) {
                try {
                    ireader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (directory != null) {
                try {
                    directory.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

范围搜索

查询score范围在1~5之间的文档，对于上面的代码中的Query进行改造

Query query = NumericRangeQuery.newFloatRange("score",1f,5f,true,true);

对搜索结果的分页

package top.yuyufeng.learn.lucene.demo2;

/**
 * @author yuyufeng
 * @date 2017/11/21
 */

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.AtomicReaderContext;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Bits;
import org.apache.lucene.util.Version;

import java.io.File;
import java.io.IOException;

/**
 * created by yuyufeng on 2017/11/13.
 */
public class LuceneSearchDemo {
    public static void main(String[] args) {
        page(2, 3);

    }

    private static void page(int page, int size) {
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
        Directory directory = null;
        IndexReader ireader = null;
        IndexSearcher isearcher;

        try {
            //索引目录
            directory = new SimpleFSDirectory(new File("D://test/lucene_index_blog"));
            // 配置IndexWriterConfig
            IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_47, analyzer);
            iwConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

            // 实例化搜索器
            ireader = DirectoryReader.open(directory);
            isearcher = new IndexSearcher(ireader);

            //查询所有

            Query query = new MatchAllDocsQuery();

            TopDocs topDocs = isearcher.search(query, 100);
            int total = topDocs.totalHits;
            System.out.println("命中：" + topDocs.totalHits);
            // 遍历输出结果
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (int i = (page - 1) * size; i < ((page - 1) * size + size > total ? total : (page - 1) * size + size); i++) {
                Document targetDoc = isearcher.doc(scoreDocs[i].doc);
                System.out.println("内容：" + targetDoc.toString());
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ireader != null) {
                try {
                    ireader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (directory != null) {
                try {
                    directory.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

多条件查询

package top.yuyufeng.learn.lucene.demo2;

/**
 * @author yuyufeng
 * @date 2017/11/21
 */
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Version;

import java.io.File;
import java.io.IOException;

/**
 * created by yuyufeng on 2017/11/13.
 */
public class LuceneSearchDemo {
    public static void main(String[] args) {

        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
        Directory directory = null;
        IndexReader ireader = null;
        IndexSearcher isearcher;

        try {
            //索引目录
            directory = new SimpleFSDirectory(new File("D://test/lucene_index_blog"));
            // 配置IndexWriterConfig
            IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_47, analyzer);
            iwConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

            // 实例化搜索器
            ireader = DirectoryReader.open(directory);
            isearcher = new IndexSearcher(ireader);


            BooleanQuery booleanQuery = new BooleanQuery();
            String keyword = "达摩院";
            // 条件一
            QueryParser qp = new QueryParser(Version.LUCENE_47, "content", analyzer);
            Query query = qp.parse(keyword);
            booleanQuery.add(query,BooleanClause.Occur.MUST);

            //条件二
            query = NumericRangeQuery.newFloatRange("score",1f,5f,true,true);
            booleanQuery.add(query,BooleanClause.Occur.MUST);



            TopDocs topDocs = isearcher.search(booleanQuery,100);
            System.out.println("命中：" + topDocs.totalHits);
            // 遍历输出结果
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (int i = 0; i < topDocs.totalHits; i++) {
                Document targetDoc = isearcher.doc(scoreDocs[i].doc);
                System.out.println("内容：" + targetDoc.toString());
            }


        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } finally {
            if (ireader != null) {
                try {
                    ireader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (directory != null) {
                try {
                    directory.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BooleanClause.Occur

组合方式结果
MUST和MUST取得连个查询子句的交集。
MUST和MUST_NOT表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。
SHOULD与MUST_NOT连用时，功能同MUST和MUST_NOT。
SHOULD与MUST结果为MUST子句的检索结果,但是SHOULD可影响排序
SHOULD与SHOULD表示“或”关系，最终检索结果为所有检索子句的并集
MUST_NOT和MUST_NOT无意义，检索无结果
爆裂码手
关注
专栏目录
探秘Elasticsearch：高性能搜索引擎的原理与应用场景（二）
凛鼕将至的博客
03-11 793
Elasticsearch是一个开源的分布式搜索和分析引擎，用于处理实时的大数据集。它基于Apache Lucene搜索引擎构建而成，并提供了简单易用的API，可以进行全文搜索、结构化搜索、分析和可视化等操作。 Elasticsearch使用倒排索引的方式来存储和搜索数据，通过将每个文档中的所有词条进行索引，从而可以快速地检索到相关的文档。它支持水平扩展，可以轻松地处理大规模的数据集，并提供了自动分片和复制机制，确保数据的高可用性和容错性。
Elasticsearch多字段搜索与价格范围过滤的Go语言实现
最新发布
程序员光剑
07-27 37
在当今数字化时代，快速而精准的信息检索已成为各行各业的刚需。无论是电子商务平台、新闻门户网站，还是企业内部的文档管理系统，都需要一个强大的搜索引擎来支撑。Elasticsearch作为一个分布式、RESTful风格的搜索和分析引擎，凭借其高性能、可扩展性和灵活性，在全文检索领域占据了重要地位。本文将深入探讨如何使用Go语言实现Elasticsearch的多字段搜索和价格范围过滤功能。这两个功能在实际应用中极为常见，尤其是在电子商务领域。例如，用户可能想要搜索特定品牌、型号的商品，同时限定价格区间。
Lucene时间区间搜索
08-05
c#下实现Lucene时间区间查询匹配。主要还是对Lucene查循对像Query的实现
Lucene.net搜索结果排序（单条件和多条件）
LightSun----让成功成为可能!
06-08 2621
Lucene支持对搜索条件的排序，一个条件或者多个条件，以及是升序还是降序，部分代码如下：        string INDEX_STORE_PATH = Server.MapPath("index");  //INDEX_STORE_PATH 为索引存储目录         string keyword = TextBox
lucene-对搜索结果进行排序
深未来技术
12-24 530
1、   在IndexSearcher类中包含了几个可重载的search方法，有一个对结果进行排序的search方法声明为search(Query,Sort)   public classSortingExample{     private Directory directory;          public SortingExample(Directory direco
Lucene-2.2.0 源代码阅读学习(40)
pavel0的专栏
02-06 168
关于Lucene检索结果的排序问题。 已经知道，Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。 下面研究几种设置/改变检索结果排序的方法。 ■ 改变Document的boost(激励因子) 改变boost的值实现改变检索结果集的排序，是最简单的方法，只需要在建立索引的过程中，设置指...
lucene常用搜索排序摘录
Clay's Coding Life
09-16 177
一，查询   一个关键字，对一个字段进行查询   QueryParser qp = new QueryParser("content",analyzer); query = qp.parse(keyword); Hits hits = searcher.search(query); 模糊查询   Term term = new Term("content",keyword); FuzzyQue...
solr实现京东搜索
09-01
Solr是Apache Lucene项目的一个子项目，是一个高性能、基于Java的企业级全文搜索引擎。在电商领域，Solr常被用于构建商品搜索系统，提供高效、精准的搜索体验。本篇文章将详细阐述如何利用Solr实现京东搜索的功能。 ...
lucene facet bobo-browse实现
12-24
Lucene Facet是Lucene的一个扩展，它允许用户通过多维度的分类来过滤和浏览搜索结果，这种分类方式有助于用户快速定位所需信息。Facets可以理解为一种元数据，用于描述文档的不同属性，如作者、出版年份、价格等，...
Lucene分词与查询详解
11-25
**Lucene分词与查询详解** Lucene是一个高性能、全文本搜索库，广泛应用于各种搜索引擎的开发中。它提供了一套强大的API，用于索引文本...对于学习和开发基于Lucene的搜索引擎，理解并熟练运用上述知识点至关重要。
lucene查询结果集分页代码
12-14
在lucene搜索分页过程中,可以有两种方式 一种是将搜索结果集直接放到session中,但是假如结果集非常大,同时又存在大并发访问的时候,很可能造成服务器的内存不足,而使服务器宕机 还有一种是每次都重新进行搜索,这样虽然避免了内存溢出的可能,但是,每次搜索都要进行一次IO操作,如果大并发访问的时候,你要保证你的硬盘的转速足够的快,还要保证你的cpu有足够高的频率 而我们可以将这两种方式结合下,每次查询都多缓存一部分的结果集,翻页的时候看看所查询的内容是不是在已经存在在缓存当中,如果已经存在了就直接拿出来,如果不存在,就进行查询后,从缓存中读出来. 比如:现在我们有一个搜索结果集 一个有100条数据,每页显示10条,就有10页数据. 安装第一种的思路就是,我直接把这100条数据缓存起来,每次翻页时从缓存种读取 而第二种思路就是,我直接从搜索到的结果集种显示前十条给第一页显示,第二页的时候,我在查询一次,给出10-20条数据给第二页显示,我每次翻页都要重新查询 第三种思路就变成了 我第一页仅需要10条数据,但是我一次读出来50条数据,把这50条数据放入到缓存当中,当我需要10--20之间的数据的时候,我的发现我的这些数据已经在我的缓存种存在了,我就直接存缓存中把数据读出来,少了一次查询,速度自然也提高了很多. 如果我访问第六页的数据,我就把我的缓存更新一次.这样连续翻页10次才进行两次IO操作 同时又保证了内存不容易被溢出.而具体缓存设置多少,要看你的服务器的能力和访问的人数来决定
Lucene的数字范围搜索 (Numeric Range Query)原理
jimmee的专栏
04-05 734
0. 全文索引的核心就是倒排索引.     1. 若数字不支持范围查询, 直接变成字符串查找即可     2. 如果要支持范围查询, 直接的字符串存储支持么?      目前lucene要求term按照字典序(lexicographic sortable)排列,然后它的范围查询根据tii找到范围的起始Term，然后把这中间的所有的Term展开成一个BooleanQuery。 ...
Lucene价格区间（范围）搜索两种方法分析
路卫杰的专栏
08-04 6783
<br /><br />Lucene API可以有两种方法进行价格区间搜索。（我们采用第二种方法）<br />1.       采用RangeFilter过滤器进行价格区间搜索。<br />从名称上可以很容易地看出来，RangeFilter是用于过滤在一定范围内出现的文档<br />在JavaDoc中，对它是这样解释的。<br />A Filter that restricts search results to a range of values in a given field.<br />中文翻译
Lucene教程--维护索引、查询对象和相关度排序
好好学java
04-23 2769
1索引维护 1.1添加索引 步骤： 1）创建存放索引的目录Directory 2）创建索引器配置管理类IndexWriterConfig 3）使用索引目录和配置管理类创建索引器 4）使用索引器将Document写到索引文件中 代码： // 定义索引存储目录 Directory directory = FSDirectory.open(new File(indexF
lucene排序---相关度与其他组合排序
JackieLiuLixi的专栏
10-16 3763
原先一直有这个概念，就是在lucene中相关度排序和其他排序是不能组合使用；但是一直怀疑这个观念，我记得是书上看到的（网上也有人这么说），但是有不能确定。 理论上来说，lucene是可以做到这样组合排序的；所以我就试一下了； [java] view plaincopy package com.search5173.lucene.demo
Lucene经典搜索引擎知识总结
宋小黑的博客
02-12 832
高性能、可扩展的信息检索工具类库简单强大的核心APIES的底层工具扩展性体现在多种扩展包，常见如spellchecker拼写检查模块，highlighter 搜索结果高亮模块。只要数据源可以转换为文本形式，lucene 即可创建索引。（如pdf，xml，txt等）
lucene 4.10实现多域检索和区间范围检索
zhangt85的专栏
12-05 4256
多域检索和区间范围检索使用频率非常高 下面的代码展示了两个的使用方法，同时顺便介绍了布尔查询类BooleanQuery，关系有三种:Occur.MUST，Occur.MUST_NOT,Occur.SHOULD //实现逻辑检索需要使用BooleanQuery，具体可以查询相关的逻辑关系表达式Occur BooleanQuery booleanQuery = new Boolea
Lucene+ik的分页和多条件模糊交集搜索
IsResultXaL的博客
09-23 1896
jar包支持http://download.csdn.net/detail/isresultxal/9133977package com.sgfm.datacenter.sys;import java.io.File; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.ut
关于lucene搜索时排序的问题
weixin_34224941的博客
12-02 141
为什么80%的码农都做不了架构师？>>> ...
PageRank优化的Lucene排序算法在手机信息搜索中的应用
在搜索引擎技术中，网页排序是决定用户搜索体验的关键因素之一。随着Web技术的快速发展，个性化服务的搜索引擎越来越受到用户的青睐。Lucene作为一款流行的开源全文搜索引擎库，其默认的排序机制主要依赖于文档的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值