第5章 商品搜索

学习目标

  • Elasticsearch安装
    1. docker安装Elasticsearch
    2. 系统参数问题
    3. 跨域操作

  • IK分词器配置

  • Kibana的使用->DSL语句

    1. Kibana->DSL语句操作->Elasticsearch
  • ES导入商品搜索数据
    1. Sku数据导入到Elasticsearch
    2. Map数据类型->Object

  • 关键词搜索->能够实现搜索流程代码的编写

  • 分类统计搜索

1. Elasticsearch 安装

我们之前已经使用过elasticsearch了，这里不再对它进行介绍了，直接下载安装，本章节将采用Docker安装，不过在市面上还有很多采用linxu安装，关于linux安装，已经提供了安装手册，这里就不讲了。

(1)docker镜像下载

  1. docker pull elasticsearch:5.6.8

注意：由于镜像有570MB，所以提供的虚拟机里已经下载好了该镜像，如下图：

第5天-索引搜索 - 图1

(2)安装es容器

  1. docker run -di --name=changgou_elasticsearch -p 9200:9200 -p 9300:9300 elasticsearch:5.6.8

9200端口(Web管理平台端口) 9300(服务默认端口)

浏览器输入地址访问：http://192.168.211.132:9200/

第5天-索引搜索 - 图2

(3)开启远程连接

上面完成安装后，es并不能正常使用，elasticsearch从5版本以后默认不开启远程连接，程序直接连接会报如下错误：

  1. failed to load elasticsearch nodes : org.elasticsearch.client.transport.NoNodeAvailableException: None of the configured nodes are available: [{#transport#-1}{5ttLpMhkRjKLkvoY7ltUWg}{192.168.211.132}{192.168.211.132:9300}]

我们需要修改es配置开启远程连接，代码如下：

登录容器

  1. docker exec -it changgou_elasticsearch /bin/bash

查看目录结构 输入: dir

  1. root@07f22eb41bb5:/usr/share/elasticsearch# dir
  2. NOTICE.txt  README.textile  bin  config  data  lib  logs  modules  plugins

进入config目录

  1. cd config

查看文件

  1. root@07f22eb41bb5:/usr/share/elasticsearch/config# ls
  2. elasticsearch.yml  log4j2.properties  scripts

修改elasticsearch.yml文件

  1. root@07f22eb41bb5:/usr/share/elasticsearch/config# vi elasticsearch.yml
  2. bash: vi: command not found

vi命令无法识别，因为docker容器里面没有该命令，我们可以安装该编辑器。

安装vim编辑器

  1. apt-get update
  2. apt-get install vim

安装好了后，修改elasticsearch.yml配置，如下图：

  1. vi elasticsearch.yml

修改如下图：

第5天-索引搜索 - 图3

同时添加下面一行代码：

  1. cluster.name: my-application

重启docker

  1. docker restart changgou_elasticsearch

(4)系统参数配置

重启后发现重启启动失败了，这时什么原因呢？这与我们刚才修改的配置有关，因为elasticsearch在启动的时候会进行一些检查，比如最多打开的文件的个数以及虚拟内存区域数量等等，如果你放开了此配置，意味着需要打开更多的文件以及虚拟内存，所以我们还需要系统调优

修改vi /etc/security/limits.conf ，追加内容 (nofile是单个进程允许打开的最大文件个数 soft nofile 是软限制 hard nofile是硬限制 )

  1. * soft nofile 65536
  2. * hard nofile 65536

修改vi /etc/sysctl.conf，追加内容 (限制一个进程可以拥有的VMA(虚拟内存区域)的数量 )

  1. vm.max_map_count=655360

执行下面命令 修改内核参数马上生效

  1. sysctl -p

重新启动虚拟机，再次启动容器，发现已经可以启动并远程访问

  1. reboot

创建es-head插件：

  1. docker pull docker.io/mobz/elasticsearch-head:5
  3. docker run -di --name=es-head -p 9100:9100 docker.io/mobz/elasticsearch-head:5

(5)跨域配置

修改elasticsearch/config下的配置文件：elasticsearch.yml，增加以下三句命令，并重启:

  1. http.cors.enabled: true
  2. http.cors.allow-origin: "*"
  3. network.host: 192.168.211.132

其中：
http.cors.enabled: true：此步为允许elasticsearch跨域访问，默认是false。
http.cors.allow-origin: ““：表示跨域访问允许的域名地址（表示任意）。

重启

  1.  docker restart changgou_elasticsearch

小提示：如果想让容器开启重启，可以执行下面命令

  1. docker update --restart=always 容器名称或者容器id

第5天-索引搜索 - 图4

2. IK分词器安装

(1)安装ik分词器

IK分词器下载地址https://github.com/medcl/elasticsearch-analysis-ik/releases

将ik分词器上传到服务器上，然后解压，并改名字为ik

  1. unzip elasticsearch-analysis-ik-5.6.8.zip
  2. mv elasticsearch ik

将ik目录拷贝到docker容器的plugins目录下

  1. docker cp ./ik changgou_elasticsearch:/usr/share/elasticsearch/plugins

(2)IK分词器测试

访问：http://192.168.211.132:9200/_analyze?analyzer=ik_smart&pretty=true&text=我是程序员

第5天-索引搜索 - 图5

访问：http://192.168.211.132:9200/_analyze?analyzer=ik_max_word&pretty=true&text=我是程序员

第5天-索引搜索 - 图6

3. Kibana使用-掌握DSL语句

我们上面使用的是elasticsearch-head插件实现数据查找的，但是elasticsearch-head的功能比较单一，我们这里需要一个更专业的工具实现对日志的实时分析，也就是我们接下来要讲的kibana。

Kibana 是一款开源的数据分析和可视化平台，它是 Elastic Stack 成员之一，设计用于和 Elasticsearch 协作。您可以使用 Kibana 对 Elasticsearch 索引中的数据进行搜索、查看、交互操作。您可以很方便的利用图表、表格及地图对数据进行多元化的分析和呈现。

Kibana 可以使大数据通俗易懂。它很简单，基于浏览器的界面便于您快速创建和分享动态数据仪表板来追踪 Elasticsearch 的实时数据变化。

搭建 Kibana 非常简单。您可以分分钟完成 Kibana 的安装并开始探索 Elasticsearch 的索引数据 — 没有代码、不需要额外的基础设施。

3.1 Kibana下载安装

我们项目中不再使用linux，直接使用Docker，所有这里就不演示在windows的下载安装了。

(1)镜像下载

  1. docker pull docker.io/kibana:5.6.8

为了节省时间，虚拟机中已经存在该版本的镜像了.

(2)安装kibana容器

执行如下命令，开始安装kibana容器

  1. docker run -it -d -e ELASTICSEARCH_URL=http://192.168.211.132:9200 --name kibana --restart=always -p 5601:5601 kibana:5.6.8

ELASTICSEARCH_URL=http://192.168.211.132:9200：是指链接的ES地址

restart=always:每次服务都会重启，也就是开启启动

5601:5601:端口号

(3)访问测试

访问http://192.168.211.132:5601如下：

第5天-索引搜索 - 图7

3.2 Kibana使用

3.2.1 配置索引

要使用Kibana，您必须至少配置一个索引。索引用于标识Elasticsearch索引以运行搜索和分析。它们还用于配置字段。

第5天-索引搜索 - 图8

我们修改索引名称的匹配方式即可，下面2个选项不用勾选。点击create，会展示出当前配置的索引的域信息，如下图：

第5天-索引搜索 - 图9

域的每个标题选项分别代表如下意思：

第5天-索引搜索 - 图10

3.2.2 数据搜索

Discover为数据搜索部分，可以对日志信息进行搜索操作。

第5天-索引搜索 - 图11

可以使用Discover实现数据搜索过滤和搜索条件显示以及关键词搜索，如下图：

第5天-索引搜索 - 图12

3.2.3 DSL语句使用

3.2.3.1 Query DSL结构化查询介绍

Query DSL是一个Java开源框架用于构建类型安全的SQL查询语句。采用API代替传统的拼接字符串来构造查询语句。目前Querydsl支持的平台包括JPA,JDO，SQL，Java Collections，RDF，Lucene，Hibernate Search。elasticsearch提供了一整套基于JSON的查询DSL语言来定义查询。
Query DSL当作是一系列的抽象的查询表达式树(AST)特定查询能够包含其它的查询，(如 bool ), 有些查询能够包含过滤器(如 constant_score), 还有的可以同时包含查询和过滤器 (如 filtered). 都能够从ES支持查询集合里面选择任意一个查询或者是从过滤器集合里面挑选出任意一个过滤器, 这样的话，我们就可以构造出任意复杂（maybe 非常有趣）的查询了。

3.2.3.2 索引操作

(1)查询所有索引

  1. GET /_cat/indices?v

结果如下：

第5天-索引搜索 - 图13

(2)删除某个索引

  1. DELETE /skuinfo

效果如下：

第5天-索引搜索 - 图14

(3)新增索引

  1. PUT /user

效果如下：

第5天-索引搜索 - 图15

(4)创建映射

  1. PUT /user/userinfo/_mapping
  2. {
  3.   "properties": {
  4.     "name":{
  5.       "type": "text",
  6.       "analyzer": "ik_smart",
  7.       "search_analyzer": "ik_smart",
  8.       "store": false
  9.     },
  10.     "city":{
  11.       "type": "text",
  12.       "analyzer": "ik_smart",
  13.       "search_analyzer": "ik_smart",
  14.       "store": false
  15.     },
  16.     "age":{
  17.       "type": "long",
  18.       "store": false
  19.     },
  20.     "description":{
  21.       "type": "text",
  22.       "analyzer": "ik_smart",
  23.       "search_analyzer": "ik_smart",
  24.       "store": false
  25.     }
  26.   }
  27. }

效果如下：

第5天-索引搜索 - 图16

(5)新增文档数据

  1. PUT /user/userinfo/1
  2. {
  3.   "name":"李四",
  4.   "age":22,
  5.   "city":"深圳",
  6.   "description":"李四来自湖北武汉！"
  7. }

效果如下：

第5天-索引搜索 - 图17

我们再增加3条记录：

  1. #新增文档数据 id=2
  2. PUT /user/userinfo/2
  3. {
  4.   "name":"王五",
  5.   "age":35,
  6.   "city":"深圳",
  7.   "description":"王五家住在深圳！"
  8. }
  10. #新增文档数据 id=3
  11. PUT /user/userinfo/3
  12. {
  13.   "name":"张三",
  14.   "age":19,
  15.   "city":"深圳",
  16.   "description":"在深圳打工，来自湖北武汉"
  17. }
  19. #新增文档数据 id=4
  20. PUT /user/userinfo/4
  21. {
  22.   "name":"张三丰",
  23.   "age":66,
  24.   "city":"武汉",
  25.   "description":"在武汉读书，家在武汉！"
  26. }
  28. #新增文档数据 id=5
  29. PUT /user/userinfo/5
  30. {
  31.   "name":"赵子龙",
  32.   "age":77,
  33.   "city":"广州",
  34.   "description":"赵子龙来自深圳宝安，但是在广州工作！",
  35.   "address":"广东省茂名市"
  36. }
  38. #新增文档数据 id=6
  39. PUT /user/userinfo/6
  40. {
  41.   "name":"赵毅",
  42.   "age":55,
  43.   "city":"广州",
  44.   "description":"赵毅来自广州白云区，从事电子商务8年！"
  45. }
  47. #新增文档数据 id=7
  48. PUT /user/userinfo/7
  49. {
  50.   "name":"赵哈哈",
  51.   "age":57,
  52.   "city":"武汉",
  53.   "description":"武汉赵哈哈，在深圳打工已有半年了，月薪7500！"
  54. }

(6)修改数据

a.替换操作

更新数据可以使用之前的增加操作,这种操作会将整个数据替换掉，代码如下：

  1. #更新数据,id=4
  2. PUT /user/userinfo/4
  3. {
  4.   "name":"张三丰",
  5.   "description":"在武汉读书，家在武汉！在深圳工作！"
  6. }

效果如下：

第5天-索引搜索 - 图18

使用GET命令查看：

  1. #根据ID查询
  2. GET /user/userinfo/4

效果如下：

第5天-索引搜索 - 图19

b.更新操作

我们先使用下面命令恢复数据：

  1. #恢复文档数据 id=4
  2. PUT /user/userinfo/4
  3. {
  4.   "name":"张三丰",
  5.   "age":66,
  6.   "city":"武汉",
  7.   "description":"在武汉读书，家在武汉！"
  8. }

使用POST更新某个列的数据

  1. #使用POST更新某个域的数据
  2. POST /user/userinfo/4/_update
  3. {
  4.   "doc":{
  5.     "name":"张三丰",
  6.     "description":"在武汉读书，家在武汉！在深圳工作！"
  7.   }
  8. }

效果如下：

第5天-索引搜索 - 图20

使用GET命令查看：

  1. #根据ID查询
  2. GET /user/userinfo/4

效果如下：

第5天-索引搜索 - 图21

(7)删除Document

  1. #删除数据
  2. DELETE user/userinfo/7

3.2.3.3 数据查询

(1)查询所有数据

  1. #查询所有
  2. GET /user/_search

效果如下：

第5天-索引搜索 - 图22

(2)根据ID查询

  1. #根据ID查询
  2. GET /user/userinfo/2

效果如下：

第5天-索引搜索 - 图23

(3)Sort排序

  1. #搜索排序
  2. GET /user/_search
  3. {
  4.   "query":{
  5.     "match_all": {}
  6.   },
  7.   "sort":{
  8.     "age":{
  9.       "order":"desc"
  10.     }
  11.   }
  12. }

效果如下：

第5天-索引搜索 - 图24

(4)分页

  1. #分页实现
  2. GET /user/_search
  3. {
  4.   "query":{
  5.     "match_all": {}
  6.   },
  7.   "sort":{
  8.     "age":{
  9.       "order":"desc"
  10.     }
  11.   },
  12.   "from": 0,
  13.   "size": 2
  14. }

解释：

from:从下N的记录开始查询

size:每页显示条数

效果如下：

第5天-索引搜索 - 图25

3.2.3.4 过滤查询

(1)term过滤

term主要用于分词精确匹配，如字符串、数值、日期等（不适合情况：1.列中除英文字符外有其它值 2.字符串值中有冒号或中文 3.系统自带属性如_version）

如下案例：

  1. #过滤查询-term
  2. GET _search
  3. {
  4.   "query":{
  5.     "term":{
  6.       "city":"武汉"
  7.     }
  8.   }
  9. }

效果如下：

第5天-索引搜索 - 图26

(2)terms 过滤

terms 跟 term 有点类似，但 terms 允许指定多个匹配条件。 如果某个字段指定了多个值，那么文档需要一起去做匹配 。

案例如下：

  1. #过滤查询-terms 允许多个Term
  2. GET _search
  3. {
  4.   "query":{
  5.     "terms":{
  6.       "city":
  7.         [
  8.           "武汉",
  9.           "广州"
  10.         ]
  11.     }
  12.   }
  13. }

果如下：

第5天-索引搜索 - 图27

(3) range 过滤

range过滤允许我们按照指定范围查找一批数据。例如我们查询年龄范围

案例如下：

  1. #过滤-range 范围过滤
  2. #gt表示> gte表示=>
  3. #lt表示< lte表示<=
  4. GET _search
  5. {
  6.   "query":{
  7.     "range": {
  8.       "age": {
  9.         "gte": 30,
  10.         "lte": 57
  11.       }
  12.     }
  13.   }
  14. }

上图效果如下：

第5天-索引搜索 - 图28

(4)exists过滤

exists 过滤可以用于查找拥有某个域的数据

案例如下：

  1. #过滤搜索 exists：是指包含某个域的数据检索
  2. GET _search
  3. {
  4.   "query": {
  5.     "exists":{
  6.       "field":"address"
  7.     }
  8.   }
  9. }

效果如下：

第5天-索引搜索 - 图29

(5) bool 过滤

bool 过滤可以用来合并多个过滤条件查询结果的布尔逻辑，它包含一下操作符：

  • must : 多个查询条件的完全匹配,相当于 and。
  • must_not : 多个查询条件的相反匹配，相当于 not。
  • should : 至少有一个查询条件匹配, 相当于 or。

这些参数可以分别继承一个过滤条件或者一个过滤条件的数组：

案例如下：

  1. #过滤搜索 bool 
  2. #must : 多个查询条件的完全匹配,相当于 and。
  3. #must_not : 多个查询条件的相反匹配，相当于 not。
  4. #should : 至少有一个查询条件匹配, 相当于 or。
  5. GET _search
  6. {
  7.   "query": {
  8.     "bool": {
  9.       "must": [
  10.         {
  11.           "term": {
  12.             "city": {
  13.               "value": "深圳"
  14.             }
  15.           }
  16.         },
  17.         {
  18.           "range":{
  19.             "age":{
  20.               "gte":20,
  21.               "lte":99
  22.             }
  23.           }
  24.         }
  25.       ]
  26.     }
  27.   }
  28. }

效果如下：

第5天-索引搜索 - 图30

(6) match_all 查询

可以查询到所有文档，是没有查询条件下的默认语句。

案例如下：

  1. #查询所有 match_all
  2. GET _search
  3. {
  4.   "query": {
  5.     "match_all": {}
  6.   }
  7. }

(7) match 查询

match查询是一个标准查询，不管你需要全文本查询还是精确查询基本上都要用到它。

如果你使用 match 查询一个全文本字段，它会在真正查询之前用分析器先分析match一下查询字符：

案例如下：

  1. #字符串匹配
  2. GET _search
  3. {
  4.   "query": {
  5.     "match": {
  6.       "description": "武汉"
  7.     }
  8.   }
  9. }

效果如下：

第5天-索引搜索 - 图31

(8)prefix 查询

以什么字符开头的，可以更简单地用 prefix ,例如查询所有以张开始的用户描述

案例如下：

  1. #前缀匹配 prefix
  2. GET _search
  3. {
  4.   "query": {
  5.     "prefix": {
  6.       "name": {
  7.         "value": "赵"
  8.       }
  9.     }
  10.   }
  11. }

效果如下：

第5天-索引搜索 - 图32

(9)multi_match 查询

multi_match查询允许你做match查询的基础上同时搜索多个字段，在多个字段中同时查一个

案例如下：

  1. #多个域匹配搜索
  2. GET _search
  3. {
  4.   "query": {
  5.     "multi_match": {
  6.       "query": "深圳",
  7.       "fields": [
  8.         "city",
  9.         "description"
  10.       ]
  11.     }
  12.   }
  13. }

效果如下：

第5天-索引搜索 - 图33

3.2.3.5 高亮查询

执行查询的DSL语句：

  1. GET user/_search
  2. {
  3.   "query": {
  4.     "match": {
  5.       "description": "武汉"
  6.     }
  7.   },
  8.   "highlight": {
  9.     "pre_tags": "<span style='color:red'>",
  10.     "post_tags": "</span>", 
  11.     "fields": {
  12.       "description": {}
  13.     }
  14.   }
  15. }

查询结果：

第5天-索引搜索 - 图34

3.2.3.6 完整DSL语句代码
  1. #查看所有索引
  2. GET /_cat/indices?v
  4. #删除某个索引
  5. DELETE /skuinfo
  7. #新增索引
  8. PUT /user
  10. #创建映射
  11. PUT /user/userinfo/_mapping
  12. {
  13.   "properties": {
  14.     "name":{
  15.       "type": "text",
  16.       "analyzer": "ik_smart",
  17.       "search_analyzer": "ik_smart",
  18.       "store": false
  19.     },
  20.     "city":{
  21.       "type": "text",
  22.       "analyzer": "ik_smart",
  23.       "search_analyzer": "ik_smart",
  24.       "store": false
  25.     },
  26.     "age":{
  27.       "type": "long",
  28.       "store": false
  29.     },
  30.     "description":{
  31.       "type": "text",
  32.       "analyzer": "ik_smart",
  33.       "search_analyzer": "ik_smart",
  34.       "store": false
  35.     }
  36.   }
  37. }
  39. #新增文档数据 id=1
  40. PUT /user/userinfo/1
  41. {
  42.   "name":"李四",
  43.   "age":22,
  44.   "city":"深圳",
  45.   "description":"李四来自湖北武汉！"
  46. }
  48. #新增文档数据 id=2
  49. PUT /user/userinfo/2
  50. {
  51.   "name":"王五",
  52.   "age":35,
  53.   "city":"深圳",
  54.   "description":"王五家住在深圳！"
  55. }
  57. #新增文档数据 id=3
  58. PUT /user/userinfo/3
  59. {
  60.   "name":"张三",
  61.   "age":19,
  62.   "city":"深圳",
  63.   "description":"在深圳打工，来自湖北武汉"
  64. }
  66. #新增文档数据 id=4
  67. PUT /user/userinfo/4
  68. {
  69.   "name":"张三丰",
  70.   "age":66,
  71.   "city":"武汉",
  72.   "description":"在武汉读书，家在武汉！"
  73. }
  75. #新增文档数据 id=5
  76. PUT /user/userinfo/5
  77. {
  78.   "name":"赵子龙",
  79.   "age":77,
  80.   "city":"广州",
  81.   "description":"赵子龙来自深圳宝安，但是在广州工作！",
  82.   "address":"广东省茂名市"
  83. }
  85. #新增文档数据 id=6
  86. PUT /user/userinfo/6
  87. {
  88.   "name":"赵毅",
  89.   "age":55,
  90.   "city":"广州",
  91.   "description":"赵毅来自广州白云区，从事电子商务8年！"
  92. }
  94. #新增文档数据 id=7
  95. PUT /user/userinfo/7
  96. {
  97.   "name":"赵哈哈",
  98.   "age":57,
  99.   "city":"武汉",
  100.   "description":"武汉赵哈哈，在深圳打工已有半年了，月薪7500！"
  101. }
  103. #更新数据,id=4
  104. PUT /user/userinfo/4
  105. {
  106.   "name":"张三丰",
  107.   "description":"在武汉读书，家在武汉！在深圳工作！"
  108. }
  111. #根据ID查询
  112. GET /user/userinfo/4
  114. #恢复文档数据 id=4
  115. PUT /user/userinfo/4
  116. {
  117.   "name":"张三丰",
  118.   "age":66,
  119.   "city":"武汉",
  120.   "description":"在武汉读书，家在武汉！"
  121. }
  123. #使用POST更新某个域的数据
  124. POST /user/userinfo/4/_update
  125. {
  126.   "doc":{
  127.     "name":"张三丰",
  128.     "description":"在武汉读书，家在武汉！在深圳工作！"
  129.   }
  130. }
  132. #根据ID查询
  133. GET /user/userinfo/4
  135. #删除数据
  136. DELETE user/userinfo/4
  138. #查询所有
  139. GET /user/_search
  141. #根据ID查询
  142. GET /user/userinfo/2
  144. #搜索排序
  145. GET /user/_search
  146. {
  147.   "query":{
  148.     "match_all": {}
  149.   },
  150.   "sort":{
  151.     "age":{
  152.       "order":"desc"
  153.     }
  154.   }
  155. }
  157. #分页实现
  158. GET /user/_search
  159. {
  160.   "query":{
  161.     "match_all": {}
  162.   },
  163.   "sort":{
  164.     "age":{
  165.       "order":"desc"
  166.     }
  167.   },
  168.   "from": 0,
  169.   "size": 2
  170. }
  172. #过滤查询-term
  173. GET _search
  174. {
  175.   "query":{
  176.     "term":{
  177.       "city":"武汉"
  178.     }
  179.   }
  180. }
  182. #过滤查询-terms 允许多个Term
  183. GET _search
  184. {
  185.   "query":{
  186.     "terms":{
  187.       "city":
  188.         [
  189.           "武汉",
  190.           "广州"
  191.         ]
  192.     }
  193.   }
  194. }
  196. #过滤-range 范围过滤
  197. #gt表示> gte表示=>
  198. #lt表示< lte表示<=
  199. GET _search
  200. {
  201.   "query":{
  202.     "range": {
  203.       "age": {
  204.         "gte": 30,
  205.         "lte": 57
  206.       }
  207.     }
  208.   }
  209. }
  212. #过滤搜索 exists：是指包含某个域的数据检索
  213. GET _search
  214. {
  215.   "query": {
  216.     "exists":{
  217.       "field":"address"
  218.     }
  219.   }
  220. }
  222. #过滤搜索 bool 
  223. #must : 多个查询条件的完全匹配,相当于 and。
  224. #must_not : 多个查询条件的相反匹配，相当于 not。
  225. #should : 至少有一个查询条件匹配, 相当于 or。
  226. GET _search
  227. {
  228.   "query": {
  229.     "bool": {
  230.       "must": [
  231.         {
  232.           "term": {
  233.             "city": {
  234.               "value": "深圳"
  235.             }
  236.           }
  237.         },
  238.         {
  239.           "range":{
  240.             "age":{
  241.               "gte":20,
  242.               "lte":99
  243.             }
  244.           }
  245.         }
  246.       ]
  247.     }
  248.   }
  249. }
  251. #查询所有 match_all
  252. GET _search
  253. {
  254.   "query": {
  255.     "match_all": {}
  256.   }
  257. }
  259. #字符串匹配
  260. GET _search
  261. {
  262.   "query": {
  263.     "match": {
  264.       "description": "武汉"
  265.     }
  266.   }
  267. }
  269. #前缀匹配 prefix
  270. GET _search
  271. {
  272.   "query": {
  273.     "prefix": {
  274.       "name": {
  275.         "value": "赵"
  276.       }
  277.     }
  278.   }
  279. }
  281. #多个域匹配搜索
  282. GET _search
  283. {
  284.   "query": {
  285.     "multi_match": {
  286.       "query": "深圳",
  287.       "fields": [
  288.         "city",
  289.         "description"
  290.       ]
  291.     }
  292.   }
  293. }

4. 数据导入ES

4.1 SpringData Elasticsearch介绍

4.1.1 SpringData介绍

Spring Data是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。 Spring Data可以极大的简化JPA的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。

Spring Data的官网：http://projects.spring.io/spring-data/

4.1.2 SpringData ES介绍

Spring Data ElasticSearch 基于 spring data API 简化 elasticSearch操作，将原始操作elasticSearch的客户端API 进行封装 。Spring Data为Elasticsearch项目提供集成搜索引擎。Spring Data Elasticsearch POJO的关键功能区域为中心的模型与Elastichsearch交互文档和轻松地编写一个存储库数据访问层。 官方网站：http://projects.spring.io/spring-data-elasticsearch/

4.2 搜索工程搭建

创建搜索微服务工程，changgou-service-search,该工程主要提供搜索服务以及索引数据的更新操作。

(1)API工程搭建

首先创建search的API工程,在changgou-service-api中创建changgou-service-search-api，如下图：

第5天-索引搜索 - 图35

pom.xml如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>changgou-service-api</artifactId>
  7.         <groupId>com.changgou</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.     <artifactId>changgou-service-search-api</artifactId>
  13.     <dependencies>
  14.         <!--goods API依赖-->
  15.         <dependency>
  16.             <groupId>com.changgou</groupId>
  17.             <artifactId>changgou-service-goods-api</artifactId>
  18.             <version>1.0-SNAPSHOT</version>
  19.         </dependency>
  20.         <!--SpringDataES依赖-->
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  24.         </dependency>
  25.     </dependencies>
  26. </project>

(2)搜索微服务搭建

在changgou-service中搭建changgou-service-search微服务，并进行相关配置。

pom.xml配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>changgou-service</artifactId>
  7.         <groupId>com.changgou</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.     <artifactId>changgou-service-search</artifactId>
  13.     <dependencies>
  14.         <!--依赖search api-->
  15.         <dependency>
  16.             <groupId>com.changgou</groupId>
  17.             <artifactId>changgou-service-search-api</artifactId>
  18.             <version>1.0-SNAPSHOT</version>
  19.         </dependency>
  20.     </dependencies>
  22. </project>

application.yml配置

  1. server:
  2.   port: 18085
  3. spring:
  4.   application:
  5.     name: search
  6.   data:
  7.     elasticsearch:
  8.       cluster-name: my-application
  9.       cluster-nodes: 192.168.211.132:9300
  10. eureka:
  11.   client:
  12.     service-url:
  13.       defaultZone: http://127.0.0.1:7001/eureka
  14.   instance:
  15.     prefer-ip-address: true
  16. feign:
  17.   hystrix:
  18.     enabled: true
  19. #超时配置
  20. ribbon:
  21.   ReadTimeout: 300000
  23. hystrix:
  24.   command:
  25.     default:
  26.       execution:
  27.         isolation:
  28.           thread:
  29.             timeoutInMilliseconds: 10000

配置说明：

  1. connection-timeout:服务连接超时时间
  2. socket-connect：HTTP请求超时时间
  3. ribbon.ReadTimeout: Feign请求读取数据超时时间
  4. timeoutInMilliseconds：feign连接超时时间
  5. cluster-name：Elasticsearch的集群节点名称，这里需要和Elasticsearch集群节点名称保持一致
  6. cluster-nodes：Elasticsearch节点通信地址

(3)启动类

创建SearchApplication作为搜索微服务工程的启动类，代码如下：

  1. @SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
  2. @EnableEurekaClient
  3. public class SearchApplication {
  5.     public static void main(String[] args) {
  6.         /**
  7.         * Springboot整合Elasticsearch 在项目启动前设置一下的属性，防止报错
  8.         * 解决netty冲突后初始化client时还会抛出异常
  9.         * availableProcessors is already set to [12], rejecting [12]
  10.         ***/
  11.         System.setProperty("es.set.netty.runtime.available.processors", "false");
  12.         SpringApplication.run(SearchApplication.class,args);
  13.     }
  14. }

分别创建对应的包，dao、service、controller，如下图：

第5天-索引搜索 - 图36

4.3 数据导入

现在需要将数据从数据库中查询出来，然后将数据导入到ES中。

第5天-索引搜索 - 图37

数据导入流程如下：

  1. 1.请求search服务,调用数据导入地址
  2. 2.根据注册中心中的注册的goods服务的地址，使用Feign方式查询所有已经审核的Sku
  3. 3.使用SpringData Es将查询到的Sku集合导入到ES中

4.3.1 文档映射Bean创建

搜索商品的时候，会根据如下属性搜索数据,并且不是所有的属性都需要分词搜索，我们创建JavaBean，将JavaBean数据存入到ES中要以搜索条件和搜索展示结果为依据，部分关键搜索条件分析如下：

  1. 1.可能会根据商品名称搜素，而且可以搜索商品名称中的任意一个词语，所以需要分词
  2. 2.可能会根据商品分类搜索，商品分类不需要分词
  3. 3.可能会根据商品品牌搜索，商品品牌不需要分词
  4. 4.可能会根据商品商家搜索，商品商家不需要分词
  5. 5.可能根据规格进行搜索，规格时一个键值对结构，用Map

根据上面的分析，我们可以在changgou-service-search-api工程中创建com.changgou.search.pojo.SkuInfo，如下

  1. @Document(indexName = "skuinfo",type = "docs")
  2. public class SkuInfo implements Serializable {
  3.     //商品id，同时也是商品编号
  4.     @Id
  5.     private Long id;
  7.     //SKU名称
  8.     @Field(type = FieldType.Text, analyzer = "ik_smart")
  9.     private String name;
  11.     //商品价格，单位为：元
  12.     @Field(type = FieldType.Double)
  13.     private Long price;
  15.     //库存数量
  16.     private Integer num;
  18.     //商品图片
  19.     private String image;
  21.     //商品状态，1-正常，2-下架，3-删除
  22.     private String status;
  24.     //创建时间
  25.     private Date createTime;
  27.     //更新时间
  28.     private Date updateTime;
  30.     //是否默认
  31.     private String isDefault;
  33.     //SPUID
  34.     private Long spuId;
  36.     //类目ID
  37.     private Long categoryId;
  39.     //类目名称
  40.     @Field(type = FieldType.Keyword)
  41.     private String categoryName;
  43.     //品牌名称
  44.     @Field(type = FieldType.Keyword)
  45.     private String brandName;
  47.     //规格
  48.     private String spec;
  50.     //规格参数
  51.     private Map<String,Object> specMap;
  53.     //...略
  54. }

解释：

  1. Field的数据类型
  2. Keyword  表示字符串 关键字类型 ，一定是不分词的    
  3. Text     表示字符串 文本类型 可以分词 也可以指定不分词

4.3.2 搜索审核通过Sku

修改changgou-service-goods微服务，添加搜索审核通过的Sku，供search微服务调用。下面都是针对goods微服务的操作。

修改SkuService接口，添加根据状态查询Sku方法，代码如下：

  1. /**
  2.  * 根据状态查询SKU列表
  3.  */
  4. List<Sku> findByStatus(String status);

修改SkuServiceImpl，添加根据状态查询Sku实现方法，代码如下：

  1. /***
  2.  * 根据状态查询SKU列表
  3.  * @return
  4.  */
  5. @Override
  6. public List<Sku> findByStatus(String status) {
  7.     Sku sku = new Sku();
  8.     sku.setStatus(status);
  9.     return skuMapper.select(sku);
  10. }

修改com.changgou.goods.controller.SkuController，添加根据审核状态查询Sku方法，代码如下：

  1. /***
  2.  * 根据审核状态查询Sku
  3.  * @param status
  4.  * @return
  5.  */
  6. @GetMapping("/status/{status}")
  7. public Result<List<Sku>> findByStatus(@PathVariable String status){
  8.     List<Sku> list = skuService.findByStatus(status);
  9.     return new Result<List<Sku>>(true,StatusCode.OK,"查询成功",list);
  10. }

4.3.3 Sku导入ES实现

(1) Feign配置

修改changgou-service-goods-api工程，在com.changgou.goods.feign.SkuFeign上添加findSkuList方法，代码

加入依赖：

  1. <dependency>
  2.     <groupId>com.changgou</groupId>
  3.     <artifactId>changgou-common</artifactId>
  4.     <version>1.0-SNAPSHOT</version>
  5. </dependency>

如下：

  1. @FeignClient(name="goods")
  2. @RequestMapping(value = "/sku")
  3. public interface SkuFeign {
  5.     /***
  6.      * 根据审核状态查询Sku
  7.      * @param status
  8.      * @return
  9.      */
  10.     @GetMapping("/status/{status}")
  11.     Result<List<Sku>> findByStatus(@PathVariable(name="status") String status);
  12. }
  1. @PathVariable(name="status") 一定要声明

(2) Dao创建

修改changgou-service-search工程，创建com.changgou.search.dao.SkuEsMapper,该接口主要用于索引数据操作，主要使用它来实现将数据导入到ES索引库中，代码如下：

  1. @Repository
  2. public interface SkuEsMapper extends ElasticsearchRepository<SkuInfo,Long> {
  3. }

(3) 服务层创建

修改changgou-service-search工程，创建com.changgou.search.service.SkuService,代码如下：

  1. public interface SkuService {
  3.     /***
  4.      * 导入SKU数据
  5.      */
  6.     void importSku();
  7. }

修改changgou-service-search工程，创建com.changgou.search.service.impl.SkuServiceImpl,实现Sku数据导入到ES中，代码如下：

  1. @Service
  2. public class SkuServiceImpl implements SkuService {
  4.     @Autowired
  5.     private SkuFeign skuFeign;
  7.     @Autowired
  8.     private SkuEsMapper skuEsMapper;
  10.     /**
  11.      * 导入sku数据到es
  12.      */
  13.     @Override
  14.     public void importSku(){
  15.         //调用changgou-service-goods微服务
  16.         Result<List<Sku>> skuListResult = skuFeign.findByStatus("1");
  17.         //将数据转成search.Sku
  18.         List<SkuInfo> skuInfos=  JSON.parseArray(JSON.toJSONString(skuListResult.getData()),SkuInfo.class);
  19.         for(SkuInfo skuInfo:skuInfos){
  20.             Map<String, Object> specMap= JSON.parseObject(skuInfo.getSpec()) ;
  21.             skuInfo.setSpecMap(specMap);
  22.         }
  23.         skuEsMapper.saveAll(skuInfos);
  24.     }
  25. }

(4)控制层配置

修改changgou-service-search工程，在com.changgou.search.controller.SkuController类中添加如下方法调用上述导入方法，代码如下：

  1. @RestController
  2. @RequestMapping(value = "/search")
  3. @CrossOrigin
  4. public class SkuController {
  6.     @Autowired
  7.     private SkuService skuService;
  9.     /**
  10.      * 导入数据
  11.      * @return
  12.      */
  13.     @GetMapping("/import")
  14.     public Result search(){
  15.         skuService.importSku();
  16.         return new Result(true, StatusCode.OK,"导入数据到索引库中成功！");
  17.     }
  18. }

(5)修改启动类

启动类中需要开启Feign客户端，并且需要添加ES包扫描，代码如下：

  1. @SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
  2. @EnableEurekaClient
  3. @EnableFeignClients(basePackages = "com.changgou.goods.feign")
  4. //@EnableElasticsearchRepositories(basePackages = "com.changgou.search.dao")
  5. public class SearchApplication {
  7.     public static void main(String[] args) {
  8.         /**
  9.         * Springboot整合Elasticsearch 在项目启动前设置一下的属性，防止报错
  10.         * 解决netty冲突后初始化client时还会抛出异常
  11.         * java.lang.IllegalStateException: availableProcessors is already set to [12], rejecting [12]
  12.         ***/
  13.         System.setProperty("es.set.netty.runtime.available.processors", "false");
  14.         SpringApplication.run(SearchApplication.class,args);
  15.     }
  16. }

(6)测试

调用http://localhost:18085/search/import进行测试

打开es-head可以看到如下数据：

第5天-索引搜索 - 图38

5. 关键字搜索

第5天-索引搜索 - 图39

我们先使用SpringDataElasticsearch实现一个简单的搜索功能，先实现根据关键字搜索，从上面搜索图片可以看得到，每次搜索的时候，除了关键字外，还有可能有品牌、分类、规格等，后台接收搜索条件使用Map接收比较合适。

5.1 服务层实现

修改search服务的com.changgou.search.service.SkuService,添加搜索方法，代码如下：

  1. /***
  2.  * 搜索
  3.  * @param searchMap
  4.  * @return
  5.  */
  6. Map search(Map<String, String> searchMap);

修改search服务的com.changgou.search.service.impl.SkuServiceImpl,添加搜索实现方法,代码如下：

  1. @Autowired
  2. private ElasticsearchTemplate esTemplate;
  4. public Map search(Map<String, String> searchMap) {
  6.     //1.获取关键字的值
  7.     String keywords = searchMap.get("keywords");
  9.     if (StringUtils.isEmpty(keywords)) {
  10.         keywords = "华为";//赋值给一个默认的值
  11.     }
  12.     //2.创建查询对象 的构建对象
  13.     NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  15.     //3.设置查询的条件
  17.     nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("name", keywords));
  19.     //4.构建查询对象
  20.     NativeSearchQuery query = nativeSearchQueryBuilder.build();
  22.     //5.执行查询
  23.     AggregatedPage<SkuInfo> skuPage = esTemplate.queryForPage(query, SkuInfo.class);
  26.     //6.返回结果
  27.     Map resultMap = new HashMap<>();    
  28.     resultMap.put("rows", skuPage.getContent());
  29.     resultMap.put("total", skuPage.getTotalElements());
  30.     resultMap.put("totalPages", skuPage.getTotalPages());
  32.     return resultMap;
  33. }

5.2 控制层实现

修改com.changgou.search.controller.SkuController，在控制层调用Service层即可，代码如下：

  1. /**
  2.  * 搜索
  3.  * @param searchMap
  4.  * @return
  5.  */
  6. @PostMapping
  7. public Map search(@RequestBody(required = false) Map searchMap){
  8.     return  skuService.search(searchMap);
  9. }

5.3 测试

使用Postman工具，输入http://localhost:18085/search

选中POST提交

第5天-索引搜索 - 图40

6. 分类统计

6.1 分类统计分析

看下面的SQL语句，我们在执行搜索的时候，第1条SQL语句是执行搜，第2条语句是根据分类名字分组查看有多少分类，大概执行了2个步骤就可以获取数据结果以及分类统计，我们可以发现他们的搜索条件完全一样。

  1. -- 查询所有
  2. SELECT * FROM tb_sku WHERE name LIKE '%手机%';
  3. -- 根据分类名字分组查询
  4. SELECT category_name FROM  tb_sku WHERE name LIKE '%手机%' GROUP BY category_name;

第5天-索引搜索 - 图41

我们每次执行搜索的时候，需要显示商品分类名称，这里要显示的分类名称其实就是符合搜素条件的所有商品的分类集合，我们可以按照上面的实现思路，使用ES根据分组名称做一次分组查询即可实现。

6.2 分类分组统计实现

修改search微服务的com.changgou.search.service.impl.SkuServiceImpl类，整体代码如下：

  1. public Map search(Map<String, String> searchMap) {
  3.     //1.获取关键字的值
  4.     String keywords = searchMap.get("keywords");
  6.     if (StringUtils.isEmpty(keywords)) {
  7.         keywords = "华为";//赋值给一个默认的值
  8.     }
  9.     //2.创建查询对象 的构建对象
  10.     NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  12.     //3.设置查询的条件
  14.     //设置分组条件  商品分类
  15.     nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms("skuCategorygroup").field("categoryName").size(50));
  16.     nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("name", keywords));
  18.     //4.构建查询对象
  19.     NativeSearchQuery query = nativeSearchQueryBuilder.build();
  21.     //5.执行查询
  22.     AggregatedPage<SkuInfo> skuPage = esTemplate.queryForPage(query, SkuInfo.class);
  24.     //获取分组结果
  25.     StringTerms stringTerms = (StringTerms) skuPage.getAggregation("skuCategorygroup");
  27.     List<String> categoryList = new ArrayList<>();
  29.     if (stringTerms != null) {
  30.         for (StringTerms.Bucket bucket : stringTerms.getBuckets()) {
  31.             String keyAsString = bucket.getKeyAsString();//分组的值
  32.             categoryList.add(keyAsString);
  33.         }
  34.     }
  35.     //6.返回结果
  36.     Map resultMap = new HashMap<>();
  37.     resultMap.put("categoryList", categoryList);
  38.     resultMap.put("rows", skuPage.getContent());
  39.     resultMap.put("total", skuPage.getTotalElements());
  40.     resultMap.put("totalPages", skuPage.getTotalPages());
  42.     return resultMap;
  43. }

添加的代码如下:

第5天-索引搜索 - 图42

第5天-索引搜索 - 图43

6.3 测试

请求http://localhost:18086/search

第5天-索引搜索 - 图44

6.4 代码优化

如上,可以将获取分组的代码进行提取,如下代码所示:

  1. /**
  2.  * 获取分类列表数据
  3.  *
  4.  * @param stringTerms
  5.  * @return
  6.  */
  7. private List<String> getStringsCategoryList(StringTerms stringTerms) {
  8.     List<String> categoryList = new ArrayList<>();
  9.     if (stringTerms != null) {
  10.         for (StringTerms.Bucket bucket : stringTerms.getBuckets()) {
  11.             String keyAsString = bucket.getKeyAsString();//分组的值
  12.             categoryList.add(keyAsString);
  13.         }
  14.     }
  15.     return categoryList;
  16. }

在search方法中进行调用:

第5天-索引搜索 - 图45

  1. List<String> categoryList = getStringsCategoryList(stringTermsCategory);

整体代码如下:

  1. public Map search(Map<String, String> searchMap) {
  3.     //1.获取关键字的值
  4.     String keywords = searchMap.get("keywords");
  6.     if (StringUtils.isEmpty(keywords)) {
  7.         keywords = "华为";//赋值给一个默认的值
  8.     }
  9.     //2.创建查询对象 的构建对象
  10.     NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  12.     //3.设置查询的条件
  14.     //设置分组条件  商品分类
  15.     nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms("skuCategorygroup").field("categoryName").size(50));
  16.     nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("name", keywords));
  18.     //4.构建查询对象
  19.     NativeSearchQuery query = nativeSearchQueryBuilder.build();
  21.     //5.执行查询
  22.     AggregatedPage<SkuInfo> skuPage = esTemplate.queryForPage(query, SkuInfo.class);
  24.     //获取分组结果
  25.     StringTerms stringTermsCategory = (StringTerms) skuPage.getAggregation("skuCategorygroup");
  27.     List<String> categoryList =getStringsCategoryList(stringTermsCategory);
  28.     //6.返回结果
  29.     Map resultMap = new HashMap<>();
  30.     resultMap.put("categoryList", categoryList);
  31.     resultMap.put("rows", skuPage.getContent());
  32.     resultMap.put("total", skuPage.getTotalElements());
  33.     resultMap.put("totalPages", skuPage.getTotalPages());
  35.     return resultMap;
  36. }
  38. private List<String> getStringsCategoryList(StringTerms stringTerms) {
  39.     List<String> categoryList = new ArrayList<>();
  40.     if (stringTerms != null) {
  41.         for (StringTerms.Bucket bucket : stringTerms.getBuckets()) {
  42.             String keyAsString = bucket.getKeyAsString();//分组的值
  43.             categoryList.add(keyAsString);
  44.         }
  45.     }
  46.     return categoryList;
  47. }