SpringBoot ElasticSearch 实现订单的分页查询【SpringBoot系列17】

忘是亡心i 2023-10-08 20:44 8阅读 0赞

> SpringCloud 大型系列课程正在制作中，欢迎大家关注与提意见。  
> 程序员每天的CV 与 板砖，也要知其所以然，本系列课程可以帮助初学者学习 SpringBooot 项目开发 与 SpringCloud 微服务系列项目开发

elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容。  
本项目数据库使用的是 MySql ,查询数据使用的是 ElasticSearch

![在这里插入图片描述][f72901b5d93d403990a6a9525a982302.png]  
本文章接 [SpringBoot ElasticSearch 【SpringBoot系列16】][SpringBoot ElasticSearch _SpringBoot_16]

ES 中的数据查询基本步骤：

*  第一步，创建`SearchRequest`对象，指定索引库名
 *  第二步，利用`request.source()`构建DSL，DSL中可以包含查询、分页、排序、高亮等
 *  第三步，利用client.search()发送请求，得到响应
 *  第四步 解析数据

@SpringBootTest
    @RunWith(SpringRunner.class)
    @Slf4j
    public class ESDocumentTests {
        
    
        @Resource
        RestHighLevelClient restHighLevelClient;
        @Test
        void testMatchAll() throws IOException {
        
            // 1.准备Request
            SearchRequest request = new SearchRequest("order");
            // 2.准备DSL
            request.source()
                    .query(QueryBuilders.matchAllQuery());
            // 3.发送请求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    
            // 4.解析响应
            handleResponse(response);
        }
    
        private void handleResponse(SearchResponse response) {
        
            // 4.解析响应
            SearchHits searchHits = response.getHits();
            // 4.1.获取总条数
            long total = searchHits.getTotalHits().value;
            log.info("共搜索到" + total + "条数据");
            // 4.2.文档数组
            SearchHit[] hits = searchHits.getHits();
            // 4.3.遍历
            for (SearchHit hit : hits) {
        
                // 获取文档source
                String json = hit.getSourceAsString();
                // 反序列化
                Order order = JSON.parseObject(json, Order.class);
                log.info("查询到数据 {}",order);
            }
        }
    }

##### 1 精确查询 #####

上述查询中，QueryBuilders.matchAllQuery() 就是查询条件，在这里没有设置任何筛选条件，所以默认返回前10条数据。

request.source()
                 .query(QueryBuilders.matchAllQuery());

如果要实现精确查询，需要构建查询条件：

@Test
     public void testBool() throws IOException {
        
         // 1.准备Request
         SearchRequest request = new SearchRequest("order");
         // 2.准备DSL
         // 2.1.准备BooleanQuery
         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
         // 2.2.添加term
         boolQuery.must(QueryBuilders.termQuery("goodsName", "手机"));
         // 2.3.添加range
         boolQuery.filter(QueryBuilders.rangeQuery("goodsPrice").lte(250));
         //排序 
         request.source().query(boolQuery);
         // 3.发送请求
         SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
         // 4.解析响应
         handleResponse(response);
    
     }

核心就是这里的条件

*  term：词条精确匹配
 *  range：范围查询

// 2.2.添加term
         boolQuery.must(QueryBuilders.termQuery("goodsName", "手机"));
         // 2.3.添加range
         boolQuery.filter(QueryBuilders.rangeQuery("goodsPrice").lte(250));

##### 2 查询结果排序与分页 #####

![在这里插入图片描述][fdc416c547db4a47ac0d3c2a8d146402.png]  
elasticsearch 在集群模式下，查询TOP1000的数据，例如我集群有5个节点，就必须先查询出每个节点的TOP1000，汇总结果后，重新排名，重新截取TOP1000。  
![在这里插入图片描述][e5a11e65fbd0424b98aab0ace0c2379d.png]  
当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力，因此elasticsearch会禁止from+ size 超过10000的请求。

@Test
        public void testPageAndSort() throws IOException {
        
            // 页码，每页大小
            int page = 1, size = 5;
    
            // 1.准备Request
            SearchRequest request = new SearchRequest("order");
            // 2.准备DSL
            // 2.1.query
            request.source().query(QueryBuilders.matchAllQuery());
            // 2.2.排序 sort
            request.source().sort("price", SortOrder.ASC);
            // 2.3.分页 from、size
            request.source().from((page - 1) * size).size(5);
            // 3.发送请求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 4.解析响应
            handleResponse(response);
    
        }

核心代码就是

*  sort 排序
 *  from 分页

// 2.2.排序 sort
      request.source().sort("price", SortOrder.ASC);
      // 2.3.分页 from、size
      request.source().from((page - 1) * size).size(5);

##### 3 本项目实现的 订单分页查询 #####

@Api(tags = "订单模块")
    @RestController()
    @RequestMapping("/orders")
    @Slf4j
    public class OrderController {
        
        @Autowired
        private OrderService orderService;
      
        /**
         * 查询用户所有的订单
         */
        @PostMapping("/list")
        public PageResult listFromList(@RequestHeader Long userId,
                                       @RequestBody RequestParams params) {
        
            PageResult pageResult = orderService.listFromList(userId,params);
            return pageResult;
        }
    
    }

PageResult 是分页信息类

@Data
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public class PageResult {
        
        /**
         * 当前页码
         */
        private int pageNum;
        /**
         * 每页数量
         */
        private int pageSize;
        /**
         * 记录总数
         */
        private long totalSize;
        /**
         * 页码总数
         */
        private int totalPages;
        /**
         * 数据模型
         */
        private List<?> content;
    
        public PageResult(long total, List<Order> orderList) {
        
            this.content = orderList;
            this.totalSize = total;
        }
    }

RequestParams 是查询条件 ，包括了分页信息以及订单的状态

@Data
    @AllArgsConstructor
    public class RequestParams implements Serializable {
        
        Integer page;
        Integer pageSize;
        Integer statues;
    }

最后就是实现订单的分页查询

@Resource
       RestHighLevelClient restHighLevelClient;
       /**
        * 分页查询用户的订单
        *
        * @param userId
        * @param params
        * @return
        */
       @Override
       public PageResult listFromList(Long userId, RequestParams params) {
        
           try {
        
               // 1.准备Request
               SearchRequest request = new SearchRequest("order");
               // 2.准备DSL
               // 1.构建BooleanQuery
               BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    
               //查询对应用户的
               boolQuery.must(QueryBuilders.matchQuery("userId", userId));
               //订单状态
               if (params.getStatues() != null && params.getStatues()>=0) {
        
                   boolQuery.filter(QueryBuilders.termQuery("status", params.getStatues()));
               }
    
               // 分页
               int page = params.getPage();
               int size = params.getPageSize();
               request.source().from((page - 1) * size).size(size);
    
               // 3.发送请求
               SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
               // 4.解析响应
               return handleResponse(response);
           } catch (IOException e) {
        
               throw new RuntimeException(e);
           }
    
       }
    
       // 结果解析
       private PageResult handleResponse(SearchResponse response) {
        
           // 4.解析响应
           SearchHits searchHits = response.getHits();
           // 4.1.获取总条数
           long total = searchHits.getTotalHits().value;
           // 4.2.文档数组
           SearchHit[] hits = searchHits.getHits();
           // 4.3.遍历
           List<Order> hotels = new ArrayList<>();
           for (SearchHit hit : hits) {
        
               // 获取文档source
               String json = hit.getSourceAsString();
               // 反序列化
               Order hotelDoc = JSON.parseObject(json, Order.class);
               // 放入集合
               hotels.add(hotelDoc);
           }
           // 4.4.封装返回
           return new PageResult(total, hotels);
       }

![在这里插入图片描述][bc918a41265d48acbcf13aa320bd0375.png]

##### 4 订单的其他操作 #####

ES 中查询订单详情

@Override
        public Order getOrderDetailFromEs(Long orderId) {
        
            // 创建获取请求对象
            GetRequest getRequest = new GetRequest("order", "83");
            try {
        
                GetResponse response = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
                if(response.isExists()){
        
                    log.info("查询到详情 {}",response.getSourceAsString());
                    Order hotelDoc = JSON.parseObject(response.getSourceAsString(), Order.class);
                    return hotelDoc;
                }else{
        
                    log.error("未消查询到详情");
                }
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
            return null;
        }

ES 中修改订单状态

/**
         * 更新ES中订单的状态
         * @param statues
         */
        public void updateOrderStatues(Long orderId,Integer statues) {
        
    
            // 设置商品更新信息
            Order goods = new Order();
            goods.setStatus(statues);
    
    
            // 将对象转为json
            String data = JSON.toJSONString(goods);
            // 创建索引请求对象
            UpdateRequest updateRequest = new UpdateRequest("order", orderId.toString());
            // 设置更新文档内容
            updateRequest.doc(data, XContentType.JSON);
            // 执行更新文档
            UpdateResponse response = null;
            try {
        
                response = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
            log.info("更新状态：{}", response.status());
        }

ES 中新增一条订单数据

/**
         * 下单成功的时候 把数据保存到ES中
         * @param order
         */
        private void saveOrderToEs(Order order){
        
            // 将对象转为json
            String data = JSON.toJSONString(order);
            // 创建索引请求对象
            // 参数一 索引库名  参数二文档名称
            IndexRequest indexRequest = new IndexRequest("order").id(order.getId() + "");
            // 准备JSON文档
            indexRequest.source(data, XContentType.JSON);
            // 执行增加文档
            IndexResponse response = null;
            try {
        
                response = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
                log.info("创建状态：{}", response.status());
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
        }

项目源码在这里 ：[https://gitee.com/android.long/spring-boot-study/tree/master/biglead-api-12-es][https_gitee.com_android.long_spring-boot-study_tree_master_biglead-api-12-es]  
有兴趣可以关注一下公众号：biglead

--------------------

1.  [ 创建SpringBoot基础项目][_SpringBoot]
2.  [SpringBoot项目集成mybatis][SpringBoot_mybatis]
3.  [SpringBoot 集成 Druid 数据源【SpringBoot系列3】][SpringBoot _ Druid _SpringBoot_3]
4.  [SpringBoot MyBatis 实现分页查询数据【SpringBoot系列4】][SpringBoot MyBatis _SpringBoot_4]
5.  [SpringBoot MyBatis-Plus 集成 【SpringBoot系列5】][SpringBoot MyBatis-Plus _ _SpringBoot_5]
6.  [SpringBoot mybatis-plus-generator 代码生成器 【SpringBoot系列6】][SpringBoot mybatis-plus-generator _ _SpringBoot_6]
7.  [SpringBoot MyBatis-Plus 分页查询 【SpringBoot系列7】][SpringBoot MyBatis-Plus _ _SpringBoot_7]
8.  [SpringBoot 集成Redis缓存 以及实现基本的数据缓存【SpringBoot系列8】][SpringBoot _Redis_ _SpringBoot_8]
9.  [SpringBoot 整合 Spring Security 实现安全认证【SpringBoot系列9】][SpringBoot _ Spring Security _SpringBoot_9]
10. [SpringBoot Security认证 Redis缓存用户信息【SpringBoot系列10】][SpringBoot Security_ Redis_SpringBoot_10]
11. [SpringBoot 整合 RabbitMQ 消息队列【SpringBoot系列11】][SpringBoot _ RabbitMQ _SpringBoot_11]
12. [SpringBoot 结合RabbitMQ与Redis实现商品的并发下单【SpringBoot系列12】][SpringBoot _RabbitMQ_Redis_SpringBoot_12]
13. [SpringBoot 雪花算法生成商品订单号【SpringBoot系列13】][SpringBoot _SpringBoot_13]
14. [SpringBoot RabbitMQ 延时队列取消订单【SpringBoot系列14】 ][SpringBoot RabbitMQ _SpringBoot_14_]
15. [SpringBoot RabbitMQ 商品秒杀【SpringBoot系列15】][SpringBoot RabbitMQ _SpringBoot_15]
16. [SpringBoot ElasticSearch 【SpringBoot系列16】][SpringBoot ElasticSearch _SpringBoot_16]

[f72901b5d93d403990a6a9525a982302.png]: https://img-blog.csdnimg.cn/f72901b5d93d403990a6a9525a982302.png
[SpringBoot ElasticSearch _SpringBoot_16]: https://blog.csdn.net/zl18603543572/article/details/129626954
[fdc416c547db4a47ac0d3c2a8d146402.png]: https://img-blog.csdnimg.cn/fdc416c547db4a47ac0d3c2a8d146402.png
[e5a11e65fbd0424b98aab0ace0c2379d.png]: https://img-blog.csdnimg.cn/e5a11e65fbd0424b98aab0ace0c2379d.png
[bc918a41265d48acbcf13aa320bd0375.png]: https://img-blog.csdnimg.cn/bc918a41265d48acbcf13aa320bd0375.png
[https_gitee.com_android.long_spring-boot-study_tree_master_biglead-api-12-es]: https://gitee.com/android.long/spring-boot-study/tree/master/biglead-api-07-security
[_SpringBoot]: https://biglead.blog.csdn.net/article/details/129510825
[SpringBoot_mybatis]: https://biglead.blog.csdn.net/article/details/129394530
[SpringBoot _ Druid _SpringBoot_3]: https://biglead.blog.csdn.net/article/details/129535296
[SpringBoot MyBatis _SpringBoot_4]: https://biglead.blog.csdn.net/article/details/129536510
[SpringBoot MyBatis-Plus _ _SpringBoot_5]: https://biglead.blog.csdn.net/article/details/129538116
[SpringBoot mybatis-plus-generator _ _SpringBoot_6]: https://biglead.blog.csdn.net/article/details/129538743
[SpringBoot MyBatis-Plus _ _SpringBoot_7]: https://biglead.blog.csdn.net/article/details/129541845
[SpringBoot _Redis_ _SpringBoot_8]: https://biglead.blog.csdn.net/article/details/129544029
[SpringBoot _ Spring Security _SpringBoot_9]: https://biglead.blog.csdn.net/article/details/129551021
[SpringBoot Security_ Redis_SpringBoot_10]: https://biglead.blog.csdn.net/article/details/129570925
[SpringBoot _ RabbitMQ _SpringBoot_11]: https://biglead.blog.csdn.net/article/details/129578909
[SpringBoot _RabbitMQ_Redis_SpringBoot_12]: https://biglead.blog.csdn.net/article/details/129601572
[SpringBoot _SpringBoot_13]: https://biglead.blog.csdn.net/article/details/129613629
[SpringBoot RabbitMQ _SpringBoot_14_]: https://biglead.blog.csdn.net/article/details/129618758
[SpringBoot RabbitMQ _SpringBoot_15]: https://biglead.blog.csdn.net/article/details/129624311