【SpringBoot学习】17、SpringBoot 整合 Elasticsearch、IK分词器实现全文检索

我不是女神ヾ 2022-02-14 19:29 390阅读 0赞

支持作者就star一下 ??

源码地址：https://github.com/Tellsea/springboot-learn/tree/master/springboot-elasticsearch

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。

Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。

**安装相关软件**

<table> 
 <thead> 
  <tr> 
   <th align="left">软件名称</th> 
   <th align="left">软件版本</th> 
   <th align="left">下载地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Elasticsearch</td> 
   <td align="left">6.2.4</td> 
   <td align="left"><a href="https://www.elastic.co/cn/downloads/past-releases" rel="nofollow">elasticsearch官网下载</a></td> 
  </tr> 
  <tr> 
   <td align="left">IK中文分词器</td> 
   <td align="left">6.2.4</td> 
   <td align="left"><a href="https://github.com/medcl/elasticsearch-analysis-ik/releases" rel="nofollow">ik分词器官网下载</a></td> 
  </tr> 
  <tr> 
   <td align="left">kibana</td> 
   <td align="left">6.2.4</td> 
   <td align="left"><a href="https://www.elastic.co/cn/downloads/past-releases" rel="nofollow">kibana官网下载</a></td> 
  </tr> 
 </tbody> 
</table>

> [CSDN 下载：ElasticSearch + IK中文分词器 + kibana.zip（6.2.4版本）][CSDN _ElasticSearch _ IK_ _ kibana.zip_6.2.4]

安装分词插件，分别解压下载好的三个文件，然后解压IK，复制到`elasticsearch`安装目录下的plugins文件夹中。

运行`elasticsearch/bin/elasticsearch.bat`文件，浏览器访问： http://localhost:9200/ 会得到相应的版本信息，如：

{ 
    	"name": "Bb-td48",
    	"cluster_name": "elasticsearch",
    	"cluster_uuid": "_IM0iQAeToWALU0tq7rsZQ",
    	"version": { 
    	"number": "6.2.4",
    	"build_hash": "ccec39f",
    	"build_date": "2018-04-12T20:37:28.497551Z",
    	"build_snapshot": false,
    	"lucene_version": "7.2.1",
    	"minimum_wire_compatibility_version": "5.6.0",
    	"minimum_index_compatibility_version": "5.0.0"
    	},
    	"tagline": "You Know, for Search"
    }

然后再运行`kibana/bin/kibana.bat`文件，浏览器访问：http://localhost:5601 ，可以看到kibana的控制台页面。

到此相关软件安装完成，下面开始springboot整合elasticsearch。

# 开始整合 #

依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>
            还有lombok，自己加一下

application.yml

spring:
      data:
        elasticsearch:
          cluster-name: elasticsearch
          cluster-nodes: 127.0.0.1:9300

实体类

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Document(indexName = "item", type = "docs", shards = 1, replicas = 0)
    public class Item { 
        @Id
        private Long id;
    
        @Field(type = FieldType.Text, analyzer = "ik_max_word")
        private String title; //标题
    
        @Field(type = FieldType.Keyword)
        private String category;// 分类
    
        @Field(type = FieldType.Keyword)
        private String brand; // 品牌
    
        @Field(type = FieldType.Double)
        private Double price; // 价格
    
        @Field(index = false, type = FieldType.Keyword)
        private String images; // 图片地址
    }

Spring Data通过注解来声明字段的映射属性，有下面的三个注解：

*  `@Document` 作用在类，标记实体类为文档对象，一般有两个属性
    
     *  indexName：对应索引库名称
     *  type：对应在索引库中的类型
     *  shards：分片数量，默认5
     *  replicas：副本数量，默认1
 *  `@Id` 作用在成员变量，标记一个字段作为id主键
 *  `@Field` 作用在成员变量，标记为文档的字段，并指定字段映射属性：
    
     *  type：字段类型，是是枚举：FieldType
     *  index：是否索引，布尔类型，默认是true
     *  store：是否存储，布尔类型，默认是false
     *  analyzer：分词器名称

repository

public interface ItemRepository extends ElasticsearchRepository<Item, Long> { 
    
        /** * 根据价格区间查询 * * @param price1 * @param price2 * @return */
        List<Item> findByPriceBetween(double price1, double price2);
    }

**下面的测试类是重点**

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootElasticsearchApplicationTests { 
    
        @Autowired
        private ElasticsearchTemplate elasticsearchTemplate;
    
        @Autowired
        private ItemRepository itemRepository;
    
        /** * 创建索引 */
        @Test
        public void createIndex() { 
            // 创建索引，会根据Item类的@Document注解信息来创建
            elasticsearchTemplate.createIndex(Item.class);
            // 配置映射，会根据Item类中的id、Field等字段来自动完成映射
            elasticsearchTemplate.putMapping(Item.class);
        }
    
        /** * 删除索引 */
        @Test
        public void deleteIndex() { 
            elasticsearchTemplate.deleteIndex("item");
        }
    
        /** * 新增 */
        @Test
        public void insert() { 
            Item item = new Item(1L, "小米手机7", "手机", "小米", 2999.00, "https://img12.360buyimg.com/n1/s450x450_jfs/t1/14081/40/4987/124705/5c371b20E53786645/c1f49cd69e6c7e6a.jpg");
            itemRepository.save(item);
        }
    
        /** * 批量新增 */
        @Test
        public void insertList() { 
            List<Item> list = new ArrayList<>();
            list.add(new Item(2L, "坚果手机R1", "手机", "锤子", 3999.00, "https://img12.360buyimg.com/n1/s450x450_jfs/t1/14081/40/4987/124705/5c371b20E53786645/c1f49cd69e6c7e6a.jpg"));
            list.add(new Item(3L, "华为META20", "手机", "华为", 4999.00, "https://img12.360buyimg.com/n1/s450x450_jfs/t1/14081/40/4987/124705/5c371b20E53786645/c1f49cd69e6c7e6a.jpg"));
            list.add(new Item(4L, "iPhone X", "手机", "iPhone", 5100.00, "https://img12.360buyimg.com/n1/s450x450_jfs/t1/14081/40/4987/124705/5c371b20E53786645/c1f49cd69e6c7e6a.jpg"));
            list.add(new Item(5L, "iPhone XS", "手机", "iPhone", 5999.00, "https://img12.360buyimg.com/n1/s450x450_jfs/t1/14081/40/4987/124705/5c371b20E53786645/c1f49cd69e6c7e6a.jpg"));
            // 接收对象集合，实现批量新增
            itemRepository.saveAll(list);
        }
    
        /** * 修改 * * ：修改和新增是同一个接口，区分的依据就是id，这一点跟我们在页面发起PUT请求是类似的。 */
    
        /** * 删除所有 */
        @Test
        public void delete() { 
            itemRepository.deleteAll();
        }
    
        /** * 基本查询 */
        @Test
        public void query() { 
            // 查询全部，并按照价格降序排序
            Iterable<Item> items = itemRepository.findAll(Sort.by("price").descending());
            items.forEach(item -> System.out.println("item = " + item));
        }
    
        /** * 自定义方法 */
        @Test
        public void queryByPriceBetween() { 
            // 根据价格区间查询
            List<Item> list = itemRepository.findByPriceBetween(5000.00, 6000.00);
            list.forEach(item -> System.out.println("item = " + item));
        }
    
        /** * 自定义查询 */
        @Test
        public void search() { 
            // 构建查询条件
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 添加基本分词查询
            queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
            // 搜索，获取结果
            Page<Item> items = itemRepository.search(queryBuilder.build());
            // 总条数
            long total = items.getTotalElements();
            System.out.println("total = " + total);
            items.forEach(item -> System.out.println("item = " + item));
        }
    
        /** * 分页查询 */
        @Test
        public void searchByPage() { 
            // 构建查询条件
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 添加基本分词查询
            queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
            // 分页：
            int page = 0;
            int size = 2;
            queryBuilder.withPageable(PageRequest.of(page, size));
            // 搜索，获取结果
            Page<Item> items = itemRepository.search(queryBuilder.build());
            long total = items.getTotalElements();
            System.out.println("总条数 = " + total);
            System.out.println("总页数 = " + items.getTotalPages());
            System.out.println("当前页：" + items.getNumber());
            System.out.println("每页大小：" + items.getSize());
            items.forEach(item -> System.out.println("item = " + item));
        }
    
        /** * 排序 */
        @Test
        public void searchAndSort() { 
            // 构建查询条件
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 添加基本分词查询
            queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
            // 排序
            queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
            // 搜索，获取结果
            Page<Item> items = this.itemRepository.search(queryBuilder.build());
            // 总条数
            long total = items.getTotalElements();
            System.out.println("总条数 = " + total);
            items.forEach(item -> System.out.println("item = " + item));
        }
    
        /** * 聚合为桶 */
        @Test
        public void testAgg() { 
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 不查询任何结果
            queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{ ""}, null));
            // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
            queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand"));
            // 2、查询,需要把结果强转为AggregatedPage类型
            AggregatedPage<Item> aggPage = (AggregatedPage<Item>) itemRepository.search(queryBuilder.build());
            // 3、解析
            // 3.1、从结果中取出名为brands的那个聚合，
            // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
            StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
            // 3.2、获取桶
            List<StringTerms.Bucket> buckets = agg.getBuckets();
            // 3.3、遍历
            for (StringTerms.Bucket bucket : buckets) { 
                // 3.4、获取桶中的key，即品牌名称
                System.out.println(bucket.getKeyAsString());
                // 3.5、获取桶中的文档数量
                System.out.println(bucket.getDocCount());
            }
        }
    
        /** * 嵌套聚合，求平均值 */
        @Test
        public void testSubAgg() { 
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 不查询任何结果
            queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{ ""}, null));
            // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
            queryBuilder.addAggregation(
                    AggregationBuilders.terms("brands").field("brand")
                            .subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶内进行嵌套聚合，求平均值
            );
            // 2、查询,需要把结果强转为AggregatedPage类型
            AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
            // 3、解析
            // 3.1、从结果中取出名为brands的那个聚合，
            // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
            StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
            // 3.2、获取桶
            List<StringTerms.Bucket> buckets = agg.getBuckets();
            // 3.3、遍历
            for (StringTerms.Bucket bucket : buckets) { 
                // 3.4、获取桶中的key，即品牌名称 3.5、获取桶中的文档数量
                System.out.println(bucket.getKeyAsString() + "，共" + bucket.getDocCount() + "台");
    
                // 3.6.获取子聚合结果：
                InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
                System.out.println("平均售价：" + avg.getValue());
            }
        }
    }

# 微信公众号 #

![每天Get一个小技巧][Get]

[CSDN _ElasticSearch _ IK_ _ kibana.zip_6.2.4]: https://download.csdn.net/download/qq_38762237/13071965
[Get]: /images/20220214/295d416bfb6041fdb8cbdf2c68fb93ac.png