Elastisearch关于API的操作(索引,文档,查询)

Love The Way You Lie 2023-02-27 12:28 5阅读 0赞

### 目录 ###

*  索引库及映射
 *  固定模板(创建客户端，关闭客户端)
 *  索引
 *   *   *  索引的创建
         *  获取索引
         *  删除索引
 *  文档
 *   *   *  测试添加文档
         *  获取文档，判断是否存在
         *  删除文档记录
         *  批量插入数据
 *  查询
 *   *   *  match查询
         *  match all 查询
         *  source过滤
         *  排序
         *  分页
         *  高亮

# 索引库及映射 #

以这样一个商品数据为例来创建索引库：

import lombok.Data;
    
    @Data
    public class Product { 
     private Long id;
    
        /** * 标题 */
        private String title;
    
        /** * 分类 */
        private String category;
    
        /** * 品牌 */
        private String brand;
    
        /** * 价格 */
        private Double price;
    
        /** * 图片地址 */
        private String images;
    
        public Product() { 
        }
    
        public Product(Long id, String title, String category, String brand, Double price, String images) { 
            this.id = id;
            this.title = title;
            this.category = category;
            this.brand = brand;
            this.price = price;
            this.images = images;
        }
    }

# 固定模板(创建客户端，关闭客户端) #

private RestHighLevelClient client;
    
        /** * 在@Before方法初始化restHighLevelClient对象 */
        @Before
        public void initClient() { 
            client = new RestHighLevelClient(
                    RestClient.builder(
                            new HttpHost("192.168.121.140", 9200, "http")));
        }
    
        /** * 在@After方法中关闭restHighLevelClient对象 */
        @After
        public void closeClient() { 
            if (null != client) { 
                try { 
                    client.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }

# 索引 #

### 索引的创建 ###

@Test
        public void testCreateIndex() throws IOException { 
            //创建索引的请求
            CreateIndexRequest request = new CreateIndexRequest("donglin_index");
            //客户端请求
            CreateIndexResponse createIndexResponse =
                    client.indices().create(request, RequestOptions.DEFAULT);
            System.out.println(createIndexResponse);
        }

### 获取索引 ###

@Test
        public void testExistIndex() throws IOException { 
            GetIndexRequest request = new GetIndexRequest("donglin_index");
            boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
            System.out.println(exists);
        }

### 删除索引 ###

@Test
        public void testDeleteIndex() throws IOException { 
            DeleteIndexRequest request = new DeleteIndexRequest("donglin_index");
            AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
            System.out.println(delete.isAcknowledged());
        }

# 文档 #

### 测试添加文档 ###

@Test
        public void testAddDocument() throws IOException { 
            //创建对象
            Product product = new Product(1l, "小米手机", "手机", "小米",
                    2899.00, "http://www.baidu.com");
            //创建请求
            IndexRequest request = new IndexRequest("donglin_index");
            //规则 put /kuang_index/doc/1
            request.id("1");
            request.timeout(TimeValue.timeValueSeconds(1));
            request.timeout("1s");
    
            //将我们的数据放入请求 json
            request.source(JSON.toJSONString(product), XContentType.JSON);
    
            //客户端发送请求,获取相应的结果
            IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
    
            System.out.println(indexResponse.toString());
            System.out.println(indexResponse.status());
        }

### 获取文档，判断是否存在 ###

@Test
        public void testIsExists() throws IOException { 
            GetRequest getRequest = new GetRequest("donglin_index", "1");
            //不获取返回的_source的上下文
            getRequest.fetchSourceContext(new FetchSourceContext(false));
            getRequest.storedFields("_none_");
    
            boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
            System.out.println(exists);
    
        }

### 删除文档记录 ###

@Test
        public void testDeleteRequest() throws IOException { 
            DeleteRequest request = new DeleteRequest("donglin_index", "1");
            request.timeout("1s");
    
            DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
            System.out.println(deleteResponse.status());
        }

### 批量插入数据 ###

@Test
        public void testBulkRequest() throws IOException { 
            BulkRequest bulkRequest = new BulkRequest();
            bulkRequest.timeout("10s");
            ArrayList<Product> pdList = new ArrayList<>();
            pdList.add(new Product(1l, "小米电视", "手机", "小米",
                    2899.00, "http://www.baidu.com"));
            pdList.add(new Product(2L, "小米手机4a", "手机", "小米",
                    2899.00, "http://www.baidu.com"));
            pdList.add(new Product(3L, "大米手机", "手机", "小米",
                    2899.00, "http://www.baidu.com"));
            pdList.add(new Product(4L, "华为手机", "手机", "小米",
                    2899.00, "http://www.baidu.com"));
    
            //批处理的请求
            for (int i = 0; i < pdList.size(); i++) { 
                //批量更新和批量删除，就在这里修改对应的请求
                bulkRequest.add(new IndexRequest("donglin_index")
                        .id("" +(i+1))
                        .source(JSON.toJSONString(pdList.get(i)),XContentType.JSON));
            }
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            System.out.println(bulkResponse.hasFailures());
    
        }

# 查询 #

**`搜索类型的变化，仅仅是利用QueryBuilders构建的查询对象不同而已，其他代码基本一致。因此，我们可以把这段代码封装，然后把查询条件作为参数传递：`**

### match查询 ###

@Test
        public void matchDoc() throws IOException { 
            //3.构建QueryBuilder对象指定查询方式和查询条件
            QueryBuilder queryBuilder = QueryBuilders.matchQuery("title","小米");
            commonSearch(queryBuilder);
    
        }

### match all 查询 ###

//match all 查询
        @Test
        public void matchAllDoc() throws IOException{ 
            //1.构建QueryBuilder对象指定查询方式
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            commonSearch(queryBuilder);
        }

### source过滤 ###

private void commonSearch(QueryBuilder queryBuilder) throws IOException { 
            //1.构建SearchRequest请求对象,指定索引库
            SearchRequest searchRequest = new SearchRequest("donglin_index");
            //2.构建SearchSourceBuilder查询对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //使用fetchSource实现过滤
             searchSourceBuilder.fetchSource(new String[]{ "id","title","price"},null);
    
            //4.将QueryBuilder对象设置到SearchSourceBuilder中
            searchSourceBuilder.query(queryBuilder);
            //5.将SearchSourceBuilder查询对象封装到请求对象SearchRequest中
            searchRequest.source(searchSourceBuilder);
            //6.调用方法进行数据通信解析输出结果
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            //7.解析输出结果 hits要两次
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) { 
                String sourceAsString = hit.getSourceAsString();
                System.out.println("查询结果:"+sourceAsString);
            }
        }

@Test
        public void matchAllDoc() throws IOException{ 
            //1.构建QueryBuilder对象指定查询方式
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            commonSearch(queryBuilder);
        }

### 排序 ###

private void commonSearch(QueryBuilder queryBuilder) throws IOException { 
            //1.构建SearchRequest请求对象,指定索引库
            SearchRequest searchRequest = new SearchRequest("donglin_index");
            //2.构建SearchSourceBuilder查询对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
             /* * 通过sort方法指定排序规则 * 第一个参数：排序字段 * 第二个参数：升序还是降序(可以不填写，默认升序) */
             searchSourceBuilder.sort("id", SortOrder.DESC);
             searchSourceBuilder.sort("price",SortOrder.DESC);
    
            //4.将QueryBuilder对象设置到SearchSourceBuilder中
            searchSourceBuilder.query(queryBuilder);
            //5.将SearchSourceBuilder查询对象封装到请求对象SearchRequest中
            searchRequest.source(searchSourceBuilder);
            //6.调用方法进行数据通信解析输出结果
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            //7.解析输出结果 hits要两次
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) { 
                String sourceAsString = hit.getSourceAsString();
                System.out.println("查询结果:"+sourceAsString);
            }
        }

**`备注：默认不能使用text类型的字段进行排序。不然那会报错`**

### 分页 ###

private void commonSearch(QueryBuilder queryBuilder) throws IOException { 
            //1.构建SearchRequest请求对象,指定索引库
            SearchRequest searchRequest = new SearchRequest("donglin_index");
            //2.构建SearchSourceBuilder查询对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
             /* * 通过sort方法指定排序规则 * 第一个参数：排序字段 * 第二个参数：升序还是降序(可以不填写，默认升序) */
             searchSourceBuilder.sort("id", SortOrder.DESC);
             searchSourceBuilder.sort("price",SortOrder.DESC);
             
             /* - from：当前页起始索引, int from= (pageNum - 1) * size; - size：每页显示多少条 */
             searchSourceBuilder.from(0);
             searchSourceBuilder.size(4);
    
            //4.将QueryBuilder对象设置到SearchSourceBuilder中
            searchSourceBuilder.query(queryBuilder);
            //5.将SearchSourceBuilder查询对象封装到请求对象SearchRequest中
            searchRequest.source(searchSourceBuilder);
            //6.调用方法进行数据通信解析输出结果
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            //7.解析输出结果 hits要两次
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) { 
                String sourceAsString = hit.getSourceAsString();
                System.out.println("查询结果:"+sourceAsString);
            }
        }

### 高亮 ###

@Test
        public void higthSearch() throws IOException { 
            MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
            //1.构建SearchRequest请求对象,指定索引库
            SearchRequest searchRequest = new SearchRequest("donglin_index");
            //2.构建SearchSourceBuilder查询对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //4.将QueryBuilder对象设置到SearchSourceBuilder中
            searchSourceBuilder.query(queryBuilder);
            /* 高亮查询 */
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<front color = 'read'>");
            highlightBuilder.postTags("</font>");
            highlightBuilder.field("title");
            searchSourceBuilder.highlighter(highlightBuilder);
            //5.将SearchSourceBuilder查询对象封装到请求对象SearchRequest中
            searchRequest.source(searchSourceBuilder);
            //6.调用方法进行数据通信解析输出结果
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            //7.解析输出结果 hits要两次
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) { 
                /* 查询结果 */
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                HighlightField title = highlightFields.get("title");
                Text[] fragments = title.getFragments();
                for (Text fragment : fragments) { 
                    System.out.println("高亮查询结果"+fragment.toString());
                }
    
            }
        }