什么是 ElasticSearch ?

数据库查询存在的问题：
性能低：使用模糊查询，左边有通配符，不会走索引，会全表扫描，性能低
关键字模糊查询比较麻烦

ElasticSearch概念

• ElasticSearch是一个基于Lucene的搜索服务器
• 是一个分布式、高扩展、高实时的搜索与数据分析引擎
• 基于RESTful web接口
• Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎
• 官网：https://www.elastic.co/

应用场景
• 搜索：海量数据的查询
• 日志数据分析
• 实时数据分析

ElasticSearch与MySql分工

• MySQL有事务性,而ElasticSearch没有事务性,所以你删了的数据是无法恢复的。
• ElasticSearch没有物理外键这个特性，,如果你的数据强一致性要求比较高,还是建议慎用

ElasticSearch和MySql分工不同，MySQL负责存储数据，ElasticSearch负责搜索数据。

ElasticSearch 核心概念

⚫ 索引（index）
ElasticSearch存储数据的地方，可以理解成关系型数据库中的数据库概念。
⚫ 映射（mapping）
mapping定义了每个字段的类型、字段所使用的分词器等。相当于关系型数据库中的表结构。
⚫ 文档（document）
Elasticsearch中的最小数据单元，常以json格式显示。一个document相当于关系型数据库中的一行数据。
⚫ 倒排索引
一个倒排索引由文档中所有不重复词的列表构成，对于其中每个词，对应一个包含它的文档id列表。
⚫ 类型（type）
一种type就像一类表。如用户表、角色表等。在Elasticsearch7.X默认type为_doc

• ES 5.x中一个index可以有多种type。
• ES 6.x中一个index只能有一种type。
• ES 7.x以后，将逐步移除type这个概念，现在的操作已经不再使用，默认_doc

RESTful风格

• REST（Representational State Transfer），表述性状态转移，是一组架构约束条件和原则。满足这些约束条件和
原则的应用程序或设计就是RESTful。就是一种定义接口的规范。
• 基于HTTP。
• 可以使用XML格式定义或JSON格式定义。
• 每一个URI代表1种资源。
• 客户端使用GET、POST、PUT、DELETE 4个表示操作方式的动词对服务端资源进行操作：
• GET：用来获取资源
• POST：用来新建资源（也可以用于更新资源）
• PUT：用来更新资源
• DELETE：用来删除资源

docker安装ElasticSearch

# 拉取elasticsearch镜像
docker pull elasticsearch:7.6.2
# 启动容器
docker run -d -e ES_JAVA_POTS="-Xms512m -Xmx512m" --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2# 然后docker ps -a 查看启动成功没有,logs查看日志  等待一会 去浏览器访问一下9200 启动时间有点久,多等一会儿# 拉取kibana镜像
docker pull kibana:7.6.2
# 启动容器
docker run -d -p 5601:5601 --name=kibana --link elasticsearch -e "ELASTICSEARCH_URL=http://es安装的ip:9200" kibana:7.6.2# 然后查看容器,等待一会儿刷新一下  5601去看看 多等一会 ps -a 看容器启动成功没有  多刷新#Kibana在6.7以后的版本，支持了多种语言。并且自带在安装包里。修改方式如下：# 修改中文
docker exec -it kibana /bin/bash
cd config
vi kibana.yml　　#在kibana.yml配置文件中新增一行：i18n.locale: "zh-CN"　　# 安装ik	
docker exec -it elasticsearch /bin/bash# 之后从github上抓取ik分词器的压缩包： 也可以复制在浏览器中下载后 docker cp 到容器指定的目录中https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.6.2/elasticsearch-analysis-ik-7.6.2.zip# 之后再plugins下建立ik文件夹将压缩包解压进入此文件夹：cd plugins/
mv ../elasticsearch-analysis-ik-7.6.2.zip ./ik/
unzip elasticsearch-analysis-ik-7.6.2.zip之后编辑plugin-descriptor.properties文件vi plugin-descriptor.properties# 在文件最后一行添加这行(打开发现有这一行,就不用添加)
elasticsearch.version=6.7.0

操作 ElasticSearch

操作索引

在Kibana中操作

# 添加索引
PUT xiaofu_index# 查询多个索引
GET goods_index,xiaofu_index# 查询所有索引
GET _all# 删除索引
DELETE xiaofu

操作映射

操作文档

分词器

• 分词器（Analyzer）：将一段文本，按照一定逻辑，分析成多个词语的一种工具
如：华为手机 — > 华为、手、手机
• ElasticSearch 内置分词器
• Standard Analyzer - 默认分词器，按词切分，小写处理
• Simple Analyzer - 按照非字母切分(符号被过滤), 小写处理
• Stop Analyzer - 小写处理，停用词过滤(the,a,is)
• Whitespace Analyzer - 按照空格切分，不转小写
• Keyword Analyzer - 不分词，直接将输入当作输出
• Patter Analyzer - 正则表达式，默认\W+(非字符分割)
• Language - 提供了30多种常见语言的分词器
• ElasticSearch 内置分词器对中文很不友好，处理方式为：一个字一个词

IK分词器

• IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包
• 是一个基于Maven构建的项目
• 具有60万字/秒的高速处理能力
• 支持用户词典扩展定义
• 下载地址：https://github.com/medcl/elasticsearch-analysis-ik/archive/v7.6.2.zip

查询文档

• 词条查询：term
• 词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索
• 全文查询：match
• 全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

kibana 测试

# 添加映射
PUT user/_mapping
{"properties":{"name":{"type":"text"},"age":{"type":"integer"}}
}# 创建索引
PUT person# 添加映射
PUT person/_mapping
{"properties":{"name":{"type":"keyword"}}
}# 查询映射
GET user/_mapping
GET person/_mapping# 添加文档#1.添加文档,指定ID
PUT user/_doc/1
{"name":"小付","age":18,"address":"重庆"
}#2.添加文档,不指定ID ,会默认给ID
POST user/_doc
{"name":"小花","age":18,"address":"四川"
}# 查询文档根据id
GET user/_doc/1# 查询文档使用默认生成的ID
GET user/_doc/Ch9dWHQB3VMI6Uwz9joI# 修改文档,id有就修改,没有就添加
PUT user/_doc/1
{"name":"小付","age":18,"address":"重庆"
}# 查询所有文档
GET user/_search# 删除文档 根据ID
DELETE user/_doc/2# 安装ik后测试中文分词器 细粒度
GET _analyze
{"analyzer": "ik_max_word","text": "我爱北京天安门"
}# 粗粒度
GET _analyze
{"analyzer": "ik_smart","text": "我爱北京天安门"
}# 使用脚本
# 查询文档# 查询所有
GET user/_search# 添加一条
PUT user/_doc/3
{"name":"小甜","age":18,"address":"华为5G手机"
}# term 词条查询,查询的条件字符串和词条完全匹配
# es默认使用的分词器是standard 分词效果是一个字一个词
# 所以我们下面这个查询不到
GET user/_search
{"query": {"term": {"address": {"value": "重庆"}}}
}# 从新创建索引添加映射 指定ik分词器 
# analyzer 指定分词器
# search_analyzer 指定搜索时的分词器
PUT phone
{"mappings": {"properties": {"name":{"type": "keyword"},"address":{"type": "text","analyzer": "ik_max_word"}}}
}

Springboot 使用 ElasticSearch JavaAPI(注释为详细解释)

springboot 导入 ElasticSearch JavaAPI 包

<!--        导入了elasticsearch--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency>

ElasticSearch 整合其余的项目

        <!--引入es的坐标--><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-high-level-client</artifactId><version>7.6.2</version></dependency><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-client</artifactId><version>7.6.2</version></dependency><dependency><groupId>org.elasticsearch</groupId><artifactId>elasticsearch</artifactId><version>7.6.2</version></dependency>

ESConfig

将 RestHighLevelClient 连接对象注入到IOC中

package com.fs.config;import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;//elasticsearch配置
@Configuration
public class ESConfig {@Value("${es.host}")private String host;@Value("${es.port}")private Integer port;//创建RestHighLevelClient交给springIOC容器@Beanpublic RestHighLevelClient getRestHighLevelClient(){RestHighLevelClient restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost(host,port,"http")));return restHighLevelClient;}
}

StudyEsApiApplicationTests 测试类

/*
es 7.6.2 高级客户端测试*/
@SpringBootTest
class StudyEsApiApplicationTests {//注入es客户端@Autowired@Qualifier("getRestHighLevelClient")private RestHighLevelClient restHighLevelClient;//注入goods@Autowiredprivate GoodsMapper goodsMapper;
//.... 测试方法在后面
}

测试操作索引

• 添加索引
• 查询索引
• 删除索引
• 判断索引是否存

    //测试索引创建 所以的都是request@Testvoid testIndex() throws IOException {//创建索引的请求 使用CreateIndexRequest 构造方法传递一个字符串 索引名CreateIndexRequest createIndexRequest = new CreateIndexRequest("xiaofu_index");//执行请求,使用es客户端来执行IndicesClient indices = restHighLevelClient.indices();//客户端执行请求,请求后获得响应,第二个参数使用默认的RequestOptions.DEFAULTCreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);//成功返回trueSystem.out.println(createIndexResponse.isAcknowledged());}//测试索引创建 所以的都是request,设置,mapping映射@Testvoid testIndexAndMapping() throws IOException {//创建索引的请求 使用CreateIndexRequest 构造方法传递一个字符串 索引名CreateIndexRequest createIndexRequest = new CreateIndexRequest("xiaofu_index");//设置映射信息(使用json工具写好了后粘贴过来)String mapping = "{\n" +"      \"properties\" : {\n" +"        \"address\" : {\n" +"          \"type\" : \"text\",\n" +"          \"analyzer\" : \"ik_max_word\"\n" +"        },\n" +"        \"age\" : {\n" +"          \"type\" : \"long\"\n" +"        },\n" +"        \"name\" : {\n" +"          \"type\" : \"keyword\"\n" +"        }\n" +"      }\n" +"    }";//设置映射,指定为jsoncreateIndexRequest.mapping(mapping, XContentType.JSON);//执行请求,使用es客户端来执行IndicesClient indices = restHighLevelClient.indices();//客户端执行请求,请求后获得响应,第二个参数使用默认的RequestOptions.DEFAULTCreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);//成功返回trueSystem.out.println(createIndexResponse.isAcknowledged());}//测试获取索引@Testvoid testGetIndex() throws IOException {//创建获得索引请求,构造方法传递字符串的索引名称GetIndexRequest getIndexRequest = new GetIndexRequest("xiaofu_index");//使用客户端获取索引目录IndicesClient indices = restHighLevelClient.indices();//返回的布尔值就说明存不存在这个索引boolean exists = indices.exists(getIndexRequest, RequestOptions.DEFAULT);//获取映射信息GetIndexResponse getIndexResponse = indices.get(getIndexRequest, RequestOptions.DEFAULT);Map<String, MappingMetaData> mappings = getIndexResponse.getMappings();for (String s : mappings.keySet()) {MappingMetaData mappingMetaData = mappings.get(s);String type = mappingMetaData.type();System.out.println(s + "..." + type);}if (exists) {System.out.println(exists);} else {System.out.println("您的搜索有误");}}//测试删除索引@Testvoid testDeleteIndex() throws IOException {//获取删除请求,传递删除的索引名称DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("xiaofu_index");//使用客户端获取索引目录IndicesClient indices = restHighLevelClient.indices();//执行请求AcknowledgedResponse delete = indices.delete(deleteIndexRequest, RequestOptions.DEFAULT);//获取删除状态boolean acknowledged = delete.isAcknowledged();if (acknowledged) {System.out.println("删除成功");} else {System.out.println("删除失败,不存在");}}

测试操作文档

• 添加文档
• 修改文档
• 根据id查询文档
• 删除文档

    //测试添加文档@Testvoid testAddDocument() throws IOException {//创建添加的对象User user = new User("小付", 18);//创建请求IndexRequest request = new IndexRequest("xiaofu_index");//规则 put/xiaofu_index/1request.id("1");request.timeout(TimeValue.timeValueSeconds(1));//将我们数据放入请求  使用jackson转换我们的User对象成jsonrequest.source(new ObjectMapper().writeValueAsString(user), XContentType.JSON);//客户端发送请求,获取响应的结果IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);System.out.println(index.toString());System.out.println(index.status());//对应的命令返回状态OK}//获取文档测试,判断文档是否存在@Testvoid testIsExists() throws IOException {//获取get请求GetRequest getRequest = new GetRequest("xiaofu_index", "1");//不获取返回的 _source 的上下文getRequest.fetchSourceContext(new FetchSourceContext(false));//getRequest.storedFields("_none_");//判断是否存在boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);//获取对象if (exists) {System.out.println(exists);}}//获取文档的信息@Testvoid testGetDocument() throws IOException {//获取get请求GetRequest getRequest = new GetRequest("xiaofu_index", "1");//getRequest.id("1");//获取响应GetResponse documentFields = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);//获取Json的文档信息String sourceAsString = documentFields.getSourceAsString();System.out.println(sourceAsString);//文档值System.out.println(documentFields);//文档的所有信息}//更新文档的信息,添加文档时,如果id存在修改,不存在就添加@Testvoid testGetUpdateDocument() throws IOException {//获取更新请求UpdateRequest updateRequest = new UpdateRequest("xiaofu_index", "1");User user = new User("小付", 25);//更新,传递jsonupdateRequest.doc(new ObjectMapper().writeValueAsString(user), XContentType.JSON);//发送更新请求UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);//输出执行响应结果System.out.println(updateResponse.status());//okSystem.out.println(updateResponse.getId());//1}//删除文档的信息@Testvoid testDeleteDocument() throws IOException {//获取更新请求DeleteRequest deleteRequest = new DeleteRequest("xiaofu_index", "1");//deleteRequest.id("1");//发送删除请求,获取删除后的响应DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);//输出执行结果System.out.println(deleteResponse.status());//okSystem.out.println(deleteResponse.getId());//1}

对应kibana的操作

# 添加文档
PUT phone/_doc/1
{"name":"小甜","age":18,"address":"小米5G手机"
}PUT phone/_doc/2
{"name":"小米","age":18,"address":"华为5G手机"
}PUT phone/_doc/3
{"name":"小付","age":18,"address":"小米4G手机"
}PUT phone/_doc/4
{"name":"小付","age":18,"address":"重庆"
}# 查询所有
GET phone/_search# term 词条查询 词条完全匹配
GET phone/_search
{"query": {"term": {"address": {"value": "重庆"}}}
}# match 先回对查询的字符串进行分词,在查询,求并集GET phone/_search
{"query": {"match": {"address": "华为手机"}}
}# 查询映射
GET xiaofu_index/_mapping# 查询所有
GET xiaofu_index/_search

批量操作-脚本

GET phone/_search# 批量操作-脚本
# 删除4号记录
# 添加8号记录
# 修改2号记录名称为红米
POST _bulk
{"delete":{"_index":"phone","_id":"4"}}
{"create":{"_index":"phone","_id":"8"}}
{"name":"呵呵","age":58,"address":"重庆"}
{"update":{"_index":"phone","_id":"2"}}
{"doc":{"name":"红米"}}

批量操作-JavaAPI

    //大量插入数据@Testvoid testBulkRequest() throws IOException {//创建大批量请求,整合所有的请求操作的BulkRequest bulkRequest = new BulkRequest();User user = new User("小花", 8);User user2 = new User("小离", 8);User user3 = new User("小昂", 8);User user4 = new User("小✿", 9);ArrayList<User> users = new ArrayList<>();users.add(user4);users.add(user3);users.add(user2);users.add(user);//遍历集合,循环插入到bulkRequest中for (int i = 0; i < users.size(); i++) {//循环插入,使用链式编程bulkRequest.add(new IndexRequest("xiaofu_index").id("" + (i + 1)).source(new ObjectMapper().writeValueAsString(users.get(i)), XContentType.JSON));}//发送请求BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);System.out.println(bulk.status());//ok}//批量对文档进行增删改@Testvoid testBulkRequest02() throws IOException {/*# 批量操作-脚本# 删除3号记录# 添加8号记录# 修改2号记录名称为红米*///创建大批量请求,整合所有的请求操作的BulkRequest bulkRequest = new BulkRequest();//删除3号记录//添加6号记录//修改2号记录名称为小米HashMap<String, Object> map6 = new HashMap<>();map6.put("name","六号");HashMap<String, Object> map2 = new HashMap<>();map2.put("name","小米");//执行批量操作(传递json)  使用链式编程bulkRequest.add(new DeleteRequest("phone","3"))//删除3号记录.add(new IndexRequest("phone").id("6").source(new ObjectMapper().writeValueAsString(map6),XContentType.JSON))//添加8号记录.add(new UpdateRequest("phone","2").doc(new ObjectMapper().writeValueAsString(map2),XContentType.JSON));//修改2号记录名称为USer小米//执行批量操作(传递map)  使用链式编程
//        bulkRequest.add(new DeleteRequest("phone","3"))
//                .add(new IndexRequest("phone").id("6").source(map6))
//                .add(new UpdateRequest("phone","2").doc(map2));//发送请求BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);System.out.println(bulk.status());//ok}//批量从数据库中添加数据@Testvoid testBulkRequest03() throws IOException {//创建大批量请求,整合所有的请求操作的BulkRequest bulkRequest = new BulkRequest();//使用MyBatis-plus 查询的//查询数据库中的所有goods信息List<Goods> goods = goodsMapper.selectList(null);
//        //分页查询需要这个类,我们就new出来,传递当前页与每页条数
//        Page<Goods> goodsPage = new Page<>(1,10);
//
//        //Wrapper 没有就给null
//        Page<Goods> goodsPages = goodsMapper.selectPage(goodsPage, null);
//
//        List<Goods> goods = goodsPages.getRecords();//遍历for (Goods good : goods) {//将字符串转成map
//            Map map = new ObjectMapper().readValue(good.getSpec(), Map.class);
//            good.setSpecMap(map);bulkRequest.add(new IndexRequest("goods").id(good.getId()+"").source(new ObjectMapper().writeValueAsString(good),XContentType.JSON));}//发送请求BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);System.out.println(bulk.status());//ok}

matchAll查询-脚本

测试这个需要先准备大量数据

# 查询所有goodsGET goods/_searchGET goods# matchALL查询-脚本
GET goods/_search
{"query": {"match_all": {}},"from": 0,"size": 20
}

matchAll查询-JavaAPI

 /*** 查询所有*  1. matchAll*  2. 将查询结果封装为Goods对象，装载到List中*  3. 分页。默认显示10条*/@Testpublic void testMatchAll() throws IOException {//创建查询请求对象,指定查询的索引名称SearchRequest searchRequest = new SearchRequest("goods");//创建查询条件构造器SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();//指定查询条件,查询条件是使用条件构造器制作的 QueryBuilders.matchAllQuery() 查询所有文档searchSourceBuilder.query(QueryBuilders.matchAllQuery());//设置查询的条件//添加分页信息,指定查询100条数据searchSourceBuilder.from(0);searchSourceBuilder.size(100);//添加查询条件构建器 SearchSourceBuildersearchRequest.source(searchSourceBuilder);//查询,获取查询结果SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);// 获取命中对象 SearchHitsSearchHits responseHits = searchResponse.getHits();//获取总条数long value = responseHits.getTotalHits().value;System.out.println("总记录数:"+value);//获取Hits数据  数组SearchHit[] hits = responseHits.getHits();//创建一个数组来存储我们查询出的json数据ArrayList<Goods> goodsArrayList = new ArrayList<>();for (SearchHit hit : hits) {//获取查询出的数据的json对象String sourceAsString = hit.getSourceAsString();//转成goods对象Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);//添加goodsArrayList.add(goods);}//遍历输出一下for (Goods goods : goodsArrayList) {System.out.println(goods);}}

term查询-脚本

# term查询 不会对查询条件进行分词,完全匹配才能查出来
GET goods/_search
{"query": {"term": {"title": {"value": "华为"}}}
}

term查询-JavaAPI

    //查询 term查询：不会对查询条件进行分词。@Testvoid testSearch() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");//构建搜索条件SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();//使用QueryBuilders工具类  term 精确匹配TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "小米");
//        QueryBuilders.matchQuery() 匹配所有SearchSourceBuilder query = searchSourceBuilder.query(termQueryBuilder);//指定查询条件,查询条件是使用条件构造器制作的searchRequest.source(query);//发送SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);//查询结果System.out.println(new ObjectMapper().writeValueAsString(search.getHits()));System.out.println("================");for (SearchHit hit : search.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}

match查询-脚本

# match查询
#• 会对查询条件进行分词。
#• 然后将分词后的查询条件和词条进行等值匹配
#• 默认取并集（OR）# 使用match查询出华为手机
GET goods/_search
{"query": {"match": {"title": "华为手机"}}
}# 默认取并集（OR）
GET goods/_search
{"query": {"match": {"title": {"query": "华为手机","operator": "and"}}}
}

match查询-JavaAPI

    /*** matchQuery:词条分词查询*/@Testpublic void testMatchQuery() throws IOException {//创建查询请求SearchRequest searchRequest = new SearchRequest("goods");//创建查询条件构造器SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//设置查询的参数  使用链式编程设置参数 operator(Operator.AND)//求并集sourceBulider.query(QueryBuilders.matchQuery("title","华为手机").operator(Operator.AND));//将查询条件构造交给查询请求对象searchRequest.source(sourceBulider);//设置返回的分页数sourceBulider.from(0);sourceBulider.size(20);//发送查询请求SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);//获取查询出的结果SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}

模糊查询-脚本

wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
regexp查询：正则查询
prefix查询：前缀查询

# 模糊匹配
#wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
# regexp查询：正则查询
# prefix查询：前缀查询
GET goods/_search
{"query": {"wildcard": {"title": {"value": "华?"}}}
}# 正则
GET goods/_search
{"query": {"regexp": {"title": "\\w+(.)*"}}
}# 前缀查询
GET goods/_search
{"query": {"prefix": {"brandName": {"value": "金"}}}
}

模糊查询-JavaAPI

       /*** 模糊查询:WildcardQuery*/@Testpublic void testWildcardQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//设置莫慌查询sourceBulider.query(QueryBuilders.wildcardQuery("title","华?"));searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}/*** 模糊查询:regexpQuery*/@Testpublic void testRegexpQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//设置莫慌查询sourceBulider.query(QueryBuilders.regexpQuery("title","\\w+(.)*"));searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}/*** 模糊查询:perfixQuery*/@Testpublic void testPrefixQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//        PrefixQueryBuilder query = QueryBuilders.prefixQuery("brandName", "三");sourceBulider.query(QueryBuilders.prefixQuery("brandName","金"));searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods =new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}

范围查询-脚本

range 范围查询：查找指定字段在指定范围内包含值

# 范围查询 
# gt 大于 lt 小于
# gte 大于等于  lte 小于等于
# sort 排序GET goods/_search
{"query": {"range": {"price": {"gte": 1000,"lte": 2000}}},"sort": [{"price": {"order": "desc"}}]
}

范围查询-JavaAPI

    /*** 1. 范围查询：rangeQuery* 2. 排序*/@Testpublic void testRangeQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//        //范围查询
//        RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
//
//        //指定下限
//        query.gte(2000);
//        //指定上限
//        query.lte(3000);//使用链式编程 设置范围查询sourceBulider.query(QueryBuilders.rangeQuery("price").gte(1000).lte(2000));//排序sourceBulider.sort("price", SortOrder.DESC);searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}

queryString查询-脚本

queryString：
• 会对查询条件进行分词。
• 然后将分词后的查询条件和词条进行等值匹配
• 默认取并集（OR）
• 可以指定多个查询字段

# queryString：
#• 会对查询条件进行分词。
#• 然后将分词后的查询条件和词条进行等值匹配
#• 默认取并集（OR）
#• 可以指定多个查询字段
GET goods/_search
{"query": {"query_string": {"fields": ["title","categoryName","brandName"],"query": "华为 AND 手机"}}
}

queryString查询-JavaAPI

    /*** queryString*/@Testpublic void testQueryStringQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//queryString
//        QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("华为手机")
//        .field("title").field("categoryName").field("brandName")
//        .defaultOperator(Operator.AND);//queryString 查询,默认使用OR并集  使用AND 查询分词交集sourceBulider.query(QueryBuilders.queryStringQuery("华为 AND 手机").field("title").field("categoryName").field("brandName"));searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}

布尔查询-脚本

boolQuery：对多个查询条件连接。连接方式：
• must（and）：条件必须成立
• must_not（not）：条件必须不成立
• should（or）：条件可以成立
• filter：条件必须成立，性能比must高。不会计算得分

# boolQuery：对多个查询条件连接。连接方式：
#• must（and）：条件必须成立
#• must_not（not）：条件必须不成立
#• should（or）：条件可以成立
#• filter：条件必须成立，性能比must高。不会计算得分#  must（and）：条件必须成立
# 查询bardName为华为的和title包含手机的
GET goods/_search
{"query": {"bool": {"must": [{"term": {"brandName": {"value": "华为"}}},{"match": {"title": "手机"}}]}}
}GET goods/_search
{"query": {"bool": {"must": [{"term": {"brandName": {"value": "小米"}}}],"filter": [{"term": {"title": "手机"}}]}}
}# filter：条件必须成立，性能比must高。不会计算得分
#      * 1. 查询品牌名称为:华为
#     * 2. 查询标题包含：手机
#     * 3. 查询价格在：2000-3000
GET goods/_search
{"query": {"bool": {"must": [{"term": {"brandName": {"value": "华为"}}},{"match": {"title": "手机"}}],"filter": [{"range": {"price": {"gte": 2000,"lte": 3000}}}]}}
}

布尔查询-JavaAPI

    /*** 布尔查询：boolQuery* 1. 查询品牌名称为:华为* 2. 查询标题包含：手机* 3. 查询价格在：2000-3000*/@Testpublic void testBoolQuery() throws IOException {SearchRequest searchRequest = new SearchRequest("goods");SearchSourceBuilder sourceBulider = new SearchSourceBuilder();//1.构建boolQuery
//        BoolQueryBuilder query = QueryBuilders.boolQuery();
//
//        //2.构建各个查询条件
//        //2.1 查询品牌名称为:华为
//        QueryBuilder termQuery = QueryBuilders.termQuery("brandName","华为");
//        query.must(termQuery);
//
//        //2.2. 查询标题包含：手机
//        QueryBuilder matchQuery = QueryBuilders.matchQuery("title","手机");
//        query.filter(matchQuery);
//
//        //2.3 查询价格在：2000-3000
//        QueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
//        ((RangeQueryBuilder) rangeQuery).gte(2000);
//        ((RangeQueryBuilder) rangeQuery).lte(3000);
//        query.filter(rangeQuery);//3.使用boolQuery连接 链式编程sourceBulider.query(QueryBuilders.boolQuery().must(QueryBuilders.termQuery("brandName","华为")).must(QueryBuilders.matchQuery("title","手机")).filter(QueryBuilders.rangeQuery("price").gte(2000).lte(3000)));searchRequest.source(sourceBulider);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);SearchHits searchHits = searchResponse.getHits();//获取记录数long value = searchHits.getTotalHits().value;System.out.println("总记录数："+value);List<Goods> goodsList = new ArrayList<>();SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();//转为javaGoods goods = new ObjectMapper().readValue(sourceAsString,Goods.class);goodsList.add(goods);}for (Goods goods : goodsList) {System.out.println(goods);}}

聚合查询-脚本

• 指标聚合：相当于MySQL的聚合函数。max、min、avg、sum等
• 桶聚合：相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。

# 聚合函数 # 指标聚合# 查询包含华为的 最贵的手机
GET goods/_search
{"query": {"match": {"title": "华为"}},"aggs": {"NAME": {"max": {"field": "price"}}}
}# 桶聚合 分组# 查出title包含手机的 然后根据brandName 分组显示品牌
GET goods/_search
{"query": {"match": {"title": "手机"}},"aggs": {"NAME": {"terms": {"field": "brandName","size": 100}}}
}

聚合查询-JavaAPI

    /*** 聚合查询：桶聚合，分组查询* 1. 查询title包含手机的数据* 2. 查询品牌列表*/@Testpublic void testAggQuery() throws IOException {//创建查询请求对象SearchRequest searchRequest = new SearchRequest("goods");//构建查询对象SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();//设置查询条件searchSourceBuilder.query(QueryBuilders.matchQuery("title","手机"));// 2. 查询品牌列表/*参数：1. 自定义的名称goods_brands，将来用于获取数据2. 分组的字段*/searchSourceBuilder.aggregation(AggregationBuilders.terms("goods_brands").field("brandName").size(100));//给查询请求传递构建对象searchRequest.source(searchSourceBuilder);//发送请求  得到响应对象SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);//获取命中结果SearchHits hits = searchResponse.getHits();//获取总命中数long value = hits.getTotalHits().value;System.out.println("总记录数:"+value);//获取命中结果集合SearchHit[] hitsHits = hits.getHits();//创建一个集合来存储命中结果的每个对象ArrayList<Goods> goodsArrayList = new ArrayList<>();//遍历命中结果for (SearchHit hitsHit : hitsHits) {//获取每条命中结果的json字符串String sourceAsString = hitsHit.getSourceAsString();//转成对象Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);//添加到集合goodsArrayList.add(goods);}//遍历集合输出for (Goods goods : goodsArrayList) {System.out.println(goods);}System.out.println("-------------获取聚合结果-----------------");Aggregations aggregations = searchResponse.getAggregations();//获取结果mapMap<String, Aggregation> asMap = aggregations.getAsMap();//获取聚合Terms goodsBrands = (Terms) asMap.get("goods_brands");//List<? extends Terms.Bucket> buckets = goodsBrands.getBuckets();//创建一个集合来存储分组后的数据ArrayList<Object> objects = new ArrayList<>();for (Terms.Bucket bucket : buckets) {Object key = bucket.getKey();objects.add(key);}//输出分组数据for (Object object : objects) {System.out.println(object);}}

高亮查询-脚本

高亮三要素：
• 高亮字段
• 前缀
• 后缀

# 高亮查询GET goods/_search
{"query": {"match": {"title": "手机"}},"highlight": {"fields": {"title": {"pre_tags": "<font color='red'>","post_tags": "</font>"}}}
}

高亮查询-JavaAPI

    /*** 高亮查询：*  1. 设置高亮*      * 高亮字段*      * 前缀*      * 后缀*  2. 将高亮了的字段数据，替换原有数据*/@Testpublic void testHighLightQuery() throws IOException {//创建查询请求SearchRequest searchRequest = new SearchRequest("goods");//创建查询条件构造器SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();//查询title包含手机的数据searchSourceBuilder.query(QueryBuilders.matchQuery("title","手机"));//创建高亮构造,设置高亮HighlightBuilder highlightBuilder = new HighlightBuilder();highlightBuilder.field("title").preTags("<font color='red'>").postTags("</font>");//设置高亮searchSourceBuilder.highlighter(highlightBuilder);//设置条件searchRequest.source(searchSourceBuilder);//发送请求SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);//获取命中结果SearchHits hits = search.getHits();//装GoodsArrayList<Goods> goodsArrayList = new ArrayList<>();//获取总记录数long value = hits.getTotalHits().value;System.out.println("总记录数:"+value);//遍历for (SearchHit hit : hits) {String sourceAsString = hit.getSourceAsString();Goods goods = new ObjectMapper().readValue(sourceAsString, Goods.class);goodsArrayList.add(goods);}//输出for (Goods goods : goodsArrayList) {System.out.println(goods);}}