SpringBoot 整合 Elasticsearch、IK分词器实现全文检索

Myth丶恋晨 2021-12-10 16:09 490阅读 0赞

源码地址：[https://github.com/Tellsea/springboot-learn/tree/master/springboot-elasticsearch][https_github.com_Tellsea_springboot-learn_tree_master_springboot-elasticsearch]  
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。

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

##### 安装相关软件 #####

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

安装分词插件，分别解压下载好的三个文件，然后解压IK，复制到elasticsearch安装目录下的plugins文件夹中。  
运行/home/lijianhui/elasticsearch-6.4.3/bin/elasticsearch文件，浏览器访问： [http://localhost:9200/][http_localhost_9200] 会得到相应的版本信息，如：

{ 
      "name" : "node-1",
      "cluster_name" : "my-application",
      "cluster_uuid" : "pdzw3v-vQ4SGLBwiYRrBnw",
      "version" : { 
        "number" : "6.4.3",
        "build_flavor" : "default",
        "build_type" : "tar",
        "build_hash" : "fe40335",
        "build_date" : "2018-10-30T23:17:19.084789Z",
        "build_snapshot" : false,
        "lucene_version" : "7.4.0",
        "minimum_wire_compatibility_version" : "5.6.0",
        "minimum_index_compatibility_version" : "5.0.0"
      },
      "tagline" : "You Know, for Search"
    }

然后再运行/home/lijianhui/kibana-6.4.3-linux-x86\_64/bin/kibana文件，浏览器访问：[http://localhost:5601][http_localhost_5601] ，可以看到kibana的控制台页面。

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

##### 开始整合 #####

pom.xml

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>

application.yml

spring:
      ## Elasticsearch配置文件（必须）
      ## 该配置和Elasticsearch本地文件config下的elasticsearch.yml中的配置信息有关
      data:
        elasticsearch:
          cluster-name: my-application
          cluster-nodes: 10.237.147.26: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());
            }
        }
    }

[https_github.com_Tellsea_springboot-learn_tree_master_springboot-elasticsearch]: https://github.com/Tellsea/springboot-learn/tree/master/springboot-elasticsearch
[http_localhost_9200]: http://localhost:9200/
[http_localhost_5601]: http://localhost:5601