devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringCloud微服务（三）RabbitMQ、SpringAMQP、elasticsearch、DSL、MQ、ES详细介绍_es和mq

作者：繁依Fanyi0 | 2024-05-15 03:35:44

赞

踩

es和mq

目录

一、初始MQ

同步调用

异步调用

什么是MQ

执行下面的命令来运行MQ容器：

如果冲突了，可以先查询

RabbitMQ概述 

常见消息模型

HelloWorld案例

二、SpringAMQP

引入依赖

Work Queue 

消费预取限制

​编辑 发布、订阅

发布订阅Fanout Exchange

发布DirectExchange

发布订阅TopicExchange 

消息转化器

MQ代码

三、什么是elasticsearch

 正向索引

倒排索引

文档

索引

概念对比

架构 

 ​编辑

部署单点es

1.2.加载镜像

1.3.运行

命令解释：

2.1.部署

 分词器

2.2.DevTools

kibana中提供了一个DevTools界面：

3.安装IK分词器

3.1.在线安装ik插件（较慢）

3.2.离线安装ik插件（推荐）

1）查看数据卷目录

2）解压缩分词器安装包

3）上传到es容器的插件数据卷中

4）重启容器

5）测试：

3.3 扩展词词典

四、索引库操作 

创建索引库

查看、删除索引库​编辑

修改索引库

 新增文档​编辑

 查看、删除文档​编辑

修改文档

RestClient操作索引库

索引库代码

RestClient操作文档

操作文档代码

DSL 查询文档

 DSL  Query的分类​编辑

DSL Query基本语法

 全文检索查询​编辑

 精确查询​编辑

 地理查询​编辑

相关性算分

 Function Score Query​编辑

复合查询 Boolean Query

 搜索结果处理​编辑

分页

深度分页问题

​编辑高亮 

RestClient查询文档

全文检索查询

精确查询 ​编辑

符合查询

排序和分页

 高亮​编辑

初始MQ

同步调用

异步调用

什么是MQ

执行下面的命令来运行MQ容器：

  1. docker run \
  2.  -e RABBITMQ_DEFAULT_USER=itcast \
  3.  -e RABBITMQ_DEFAULT_PASS=123321 \
  4.  --name mq \
  5.  --hostname mq1 \
  6.  -p 15672:15672 \
  7.  -p 5672:5672 \
  8.  -d \
  9.  rabbitmq:3-management

如果冲突了，可以先查询

RabbitMQ概述 

常见消息模型

HelloWorld案例

 

SpringAMQP

 

引入依赖

 

Work Queue 

 

 

消费预取限制

 发布、订阅

发布订阅Fanout Exchange

发布DirectExchange

发布订阅TopicExchange 

 

 

消息转化器

MQ代码

  1.  
  2. @Component
  3. public class SpringRabbitListener {
  4.  
  5. //    @RabbitListener(queues = "simple.queue")
  6. //    public void listenSimpleQueue(String msg){
  7. //        System.out.println("消费者接收到simple.queue的消息:["+msg+"]");
  8. //
  9. //    }
  10.  
  11.     @RabbitListener(queues = "simple.queue")
  12.     public void listenWorkQueue1(String msg) throws InterruptedException {
  13.         System.out.println("消费者1接收到simple.queue的消息:["+msg+"]"+ LocalTime.now());
  14.         Thread.sleep(20);
  15.     }
  16.  
  17.     @RabbitListener(queues = "simple.queue")
  18.     public void listenWorkQueue2(String msg) throws InterruptedException {
  19.         System.err.println("消费者2接收到simple.queue的消息:["+msg+"]"+LocalTime.now());
  20.         Thread.sleep(200);
  21.     }
  22.  
  23.         @RabbitListener(queues = "fanout.queue1")
  24.     public void listenFanoutQueue1(String msg){
  25.         System.out.println("消费者接收到fanout.queue1的消息:["+msg+"]");
  26.  
  27.     }
  28.  
  29.     @RabbitListener(queues = "fanout.queue2")
  30.     public void listenFanoutQueue2(String msg){
  31.         System.out.println("消费者接收到fanout.queue2的消息:["+msg+"]");
  32.  
  33.     }
  34.  
  35.     @RabbitListener(bindings = @QueueBinding(
  36.             value = @Queue(name = "direct.queue1"),
  37.             exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
  38.             key = {"red","blue"}
  39.     ))
  40.     public void listenDirectQueue1(String msg){
  41.         System.out.println("消费者接收到direct.queue1的消息:["+msg+"]");
  42.     }
  43.  
  44.     @RabbitListener(bindings = @QueueBinding(
  45.             value = @Queue(name = "direct.queue2"),
  46.             exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
  47.             key = {"red","yellow"}
  48.     ))
  49.     public void listenDirectQueue2(String msg){
  50.         System.out.println("消费者接收到direct.queue2的消息:["+msg+"]");
  51.     }
  52.  
  53.     @RabbitListener(bindings = @QueueBinding(
  54.             value = @Queue(name = "topic.queue1"),
  55.             exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
  56.             key = "china.#"
  57.     ))
  58.     public void listenTopicQueue1(String msg){
  59.         System.out.println("消费者接收到topic.queue1的消息:["+msg+"]");
  60.     }
  61.  
  62.     @RabbitListener(bindings = @QueueBinding(
  63.             value = @Queue(name = "topic.queue2"),
  64.             exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
  65.             key = "#.news"
  66.     ))
  67.     public void listenTopicQueue2(String msg){
  68.         System.out.println("消费者接收到topic.queue2的消息:["+msg+"]");
  69.     }
  70.  
  71.     @RabbitListener(queues = "object.queue")
  72.     public void listObjectQueue(Map<String,Object> msg){
  73.  
  74.         System.out.println("接收object.queue的消息："+msg);
  75.     }
  76. }
  1.  
  2. @Configuration
  3. public class FanoutConfig {
  4.     //声明FanoutExchange 交换机
  5.     //itcast.fanout
  6.     @Bean
  7.     public FanoutExchange fanoutExchange(){
  8.         return new FanoutExchange("itcast.fanout");
  9.     }
  10.     //声明一个队列fanout.queue1
  11.     @Bean
  12.     public Queue fanoutQueue1(){
  13.         return new Queue("fanout.queue1");
  14.     }
  15.     //绑定队列1和交换机
  16.     @Bean
  17.      public Binding fanoutBinding1(Queue fanoutQueue1,FanoutExchange fanoutExchange){
  18.         return BindingBuilder
  19.                 .bind(fanoutQueue1)
  20.                 .to(fanoutExchange);
  21.  
  22.      }
  23.     //fanout.queue2
  24.     //声明一个队列fanout.queue1
  25.     @Bean
  26.     public Queue fanoutQueue2(){
  27.         return new Queue("fanout.queue2");
  28.     }
  29.     //绑定队列1和交换机
  30.     @Bean
  31.     public Binding fanoutBinding2(Queue fanoutQueue2,FanoutExchange fanoutExchange){
  32.         return BindingBuilder
  33.                 .bind(fanoutQueue2)
  34.                 .to(fanoutExchange);
  35.  
  36.     }
  37.  
  38.     @Bean
  39.     public Queue objectQueue(){
  40.         return new Queue("object.queue");
  41.     }
  42.  
  43. }
  1.  
  2.  
  3. @SpringBootApplication
  4. public class ConsumerApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(ConsumerApplication.class, args);
  7.     }
  8.     @Bean
  9.     public MessageConverter messageConverter(){
  10.         return new Jackson2JsonMessageConverter();
  11.     }
  12. }
  1.  
  2. public class PublisherTest {
  3.     @Test
  4.     public void testSendMessage() throws IOException, TimeoutException {
  5.         // 1.建立连接
  6.         ConnectionFactory factory = new ConnectionFactory();
  7.         // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
  8.         factory.setHost("虚拟机地址");
  9.         factory.setPort(5672);
  10.         factory.setVirtualHost("/");
  11.         factory.setUsername("itcast");
  12.         factory.setPassword("123321");
  13.         // 1.2.建立连接
  14.         Connection connection = factory.newConnection();
  15.  
  16.         // 2.创建通道Channel
  17.         Channel channel = connection.createChannel();
  18.  
  19.         // 3.创建队列
  20.         String queueName = "simple.queue";
  21.         channel.queueDeclare(queueName, false, false, false, null);
  22.  
  23.         // 4.发送消息
  24.         String message = "hello, rabbitmq!";
  25.         channel.basicPublish("", queueName, null, message.getBytes());
  26.         System.out.println("发送消息成功：【" + message + "】");
  27.  
  28.         // 5.关闭通道和连接
  29.         channel.close();
  30.         connection.close();
  31.  
  32.     }
  33. }
  1.  
  2. @RunWith(SpringRunner.class)
  3. @SpringBootTest
  4. public class SpringAmqpTest {
  5.     @Autowired
  6.     private RabbitTemplate rabbitTemplate;
  7.  
  8.     @Test
  9.     public void testSendMessage2SimpleWueue(){
  10.         String queueName = "simple.queue";
  11.         String message = "hello,spring amqp!!!";
  12.         rabbitTemplate.convertAndSend(queueName,message);
  13.     }
  14.  
  15.     @Test
  16.     public void testSendMessage2WorkQueue() throws InterruptedException {
  17.         String queueName = "simple.queue";
  18.         String message = "hello,message__";
  19.         for ( int i = 1; i <= 50; i++ ) {
  20.             rabbitTemplate.convertAndSend(queueName,message+i);
  21.             Thread.sleep(20);
  22.         }
  23.     }
  24.  
  25.     @Test
  26.     public void testSendFanoutExchange(){
  27.         //交换机名称
  28.         String exchangeName = "itcast.fanout";
  29.         //消息
  30.         String message = "hello,every one !";
  31.         //发送消息
  32.         rabbitTemplate.convertAndSend(exchangeName,"",message);
  33.     }
  34.  
  35.     @Test
  36.     public void testSendDirectExchange(){
  37.         //交换机名称
  38.         String exchangeName = "itcast.direct";
  39.         //消息
  40.         String message = "hello,blue !";
  41.         //发送消息
  42.         rabbitTemplate.convertAndSend(exchangeName,"red",message);
  43.     }
  44.  
  45.     @Test
  46.     public void testSendTopicExchange(){
  47.         //交换机名称
  48.         String exchangeName = "itcast.topic";
  49.         //消息
  50.         String message = "中国NO.1";
  51.         //发送消息
  52.         rabbitTemplate.convertAndSend(exchangeName,"chi.weather",message);
  53.     }
  54.  
  55.     @Test
  56.     public void testSendObjectExchange(){
  57.         HashMap<String, Object> msg = new HashMap<>();
  58.         msg.put("name","留言2");
  59.         msg.put("age",21);
  60.         //发送消息
  61.         rabbitTemplate.convertAndSend("object.queue",msg);
  62.     }
  63.  
  64.  
  65.  
  66.  
  67.  
  68. }

什么是elasticsearch

 

 

 正向索引

倒排索引

 

文档

索引

概念对比

架构 

 

 

部署单点es

因为我们还需要部署kibana容器，因此需要让es和kibana容器互联。这里先创建一个网络：

docker network create es-net

1.2.加载镜像

这里我们采用elasticsearch的7.12.1版本的镜像，这个镜像体积非常大，接近1G。不建议大家自己pull。

课前资料提供了镜像的tar包：

 大家将其上传到虚拟机中，然后运行命令加载即可：

  1. # 导入数据
  2. docker load -i es.tar

同理还有kibana的tar包也需要这样做。

1.3.运行

运行docker命令，部署单点es：

  1. docker run -d \
  2. 	--name es \
  3.     -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  4.     -e "discovery.type=single-node" \
  5.     -v es-data:/usr/share/elasticsearch/data \
  6.     -v es-plugins:/usr/share/elasticsearch/plugins \
  7.     --privileged \
  8.     --network es-net \
  9.     -p 9200:9200 \
  10.     -p 9300:9300 \
  11. elasticsearch:7.12.1

命令解释：

  • -e "cluster.name=es-docker-cluster"：设置集群名称

  • -e "http.host=0.0.0.0"：监听的地址，可以外网访问

  • -e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小

  • -e "discovery.type=single-node"：非集群模式

  • -v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录

  • -v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录

  • -v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录

  • --privileged：授予逻辑卷访问权

  • --network es-net ：加入一个名为es-net的网络中

  • -p 9200:9200：端口映射配置

在浏览器中输入：http://192.168.150.101:9200 即可看到elasticsearch的响应结果：

 kibana可以给我们提供一个elasticsearch的可视化界面，便于我们学习。

2.1.部署

运行docker命令，部署kibana(版本一定要一样）

  1. docker run -d \
  2. --name kibana \
  3. -e ELASTICSEARCH_HOSTS=http://es:9200 \
  4. --network=es-net \
  5. -p 5601:5601  \
  6. kibana:7.12.1

  • --network es-net ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中

  • -e ELASTICSEARCH_HOSTS=http://es:9200"：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch

  • -p 5601:5601：端口映射配置

kibana启动一般比较慢，需要多等待一会，可以通过命令：

docker logs -f kibana

查看运行日志，当查看到下面的日志，说明成功：

 分词器

2.2.DevTools

kibana中提供了一个DevTools界面：

 这个界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。

3.安装IK分词器

3.1.在线安装ik插件（较慢）

  1. # 进入容器内部
  2. docker exec -it elasticsearch /bin/bash
  3.  
  4. # 在线下载并安装
  5. ./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
  6.  
  7. #退出
  8. exit
  9. #重启容器
  10. docker restart elasticsearch

3.2.离线安装ik插件（推荐）

1）查看数据卷目录

安装插件需要知道elasticsearch的plugins目录位置，而我们用了数据卷挂载，因此需要查看elasticsearch的数据卷目录，通过下面命令查看:

docker volume inspect es-plugins

显示结果：

  1. [
  2.     {
  3.         "CreatedAt": "2022-05-06T10:06:34+08:00",
  4.         "Driver": "local",
  5.         "Labels": null,
  6.         "Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
  7.         "Name": "es-plugins",
  8.         "Options": null,
  9.         "Scope": "local"
  10.     }
  11. ]

说明plugins目录被挂载到了：/var/lib/docker/volumes/es-plugins/_data这个目录中。

2）解压缩分词器安装包

下面我们需要把课前资料中的ik分词器解压缩，重命名为ik

3）上传到es容器的插件数据卷中

4）重启容器

  1. # 4、重启容器
  2. docker restart es
  3. # 查看es日志
  4. docker logs -f es

5）测试：

IK分词器包含两种模式：

  • ik_smart：最少切分

  • ik_max_word：最细切分

  1. GET /_analyze
  2. {
  3.   "analyzer": "ik_max_word",
  4.   "text": "我爱学习java太棒了"
  5. }

结果：

  1. {
  2.   "tokens" : [
  3.     {
  4.       "token" : "我",
  5.       "start_offset" : 0,
  6.       "end_offset" : 1,
  7.       "type" : "CN_CHAR",
  8.       "position" : 0
  9.     },
  10.     {
  11.       "token" : "爱学习",
  12.       "start_offset" : 1,
  13.       "end_offset" : 4,
  14.       "type" : "CN_WORD",
  15.       "position" : 1
  16.     },
  17.     {
  18.       "token" : "学习",
  19.       "start_offset" : 2,
  20.       "end_offset" : 4,
  21.       "type" : "CN_WORD",
  22.       "position" : 2
  23.     },
  24.     {
  25.       "token" : "java",
  26.       "start_offset" : 4,
  27.       "end_offset" : 8,
  28.       "type" : "ENGLISH",
  29.       "position" : 3
  30.     },
  31.     {
  32.       "token" : "太棒了",
  33.       "start_offset" : 8,
  34.       "end_offset" : 11,
  35.       "type" : "CN_WORD",
  36.       "position" : 4
  37.     },
  38.     {
  39.       "token" : "太棒",
  40.       "start_offset" : 8,
  41.       "end_offset" : 10,
  42.       "type" : "CN_WORD",
  43.       "position" : 5
  44.     },
  45.     {
  46.       "token" : "了",
  47.       "start_offset" : 10,
  48.       "end_offset" : 11,
  49.       "type" : "CN_CHAR",
  50.       "position" : 6
  51.     }
  52.   ]
  53. }

3.3 扩展词词典

随着互联网的发展，“造词运动”也越发的频繁。出现了很多新的词语，在原有的词汇列表中并不存在。比如：“奥力给”，“传智播客” 等。

所以我们的词汇也需要不断的更新，IK分词器提供了扩展词汇的功能。

1）打开IK分词器config目录：

 2）在IKAnalyzer.cfg.xml配置文件内容添加：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
  3. <properties>
  4.         <comment>IK Analyzer 扩展配置</comment>
  5.         <!--用户可以在这里配置自己的扩展字典 *** 添加扩展词典-->
  6.         <entry key="ext_dict">ext.dic</entry>
  7. </properties>

索引库操作 

创建索引库

  1. #创建索引库
  2. PUT /heihei
  3. {
  4.   "mappings": {
  5.     "properties": {
  6.       "info": {
  7.         "type": "text",
  8.         "analyzer": "ik_smart"
  9.       },
  10.       "email": {
  11.         "type": "keyword",
  12.         "index": false
  13.       },
  14.       "name": {
  15.         "type": "object",
  16.         "properties": {
  17.           "firstName": {
  18.             "type": "keyword"
  19.           },
  20.            "lastName": {
  21.             "type": "keyword"
  22.           }
  23.         }
  24.       }
  25.     }
  26.   }
  27. }

查看、删除索引库

 

修改索引库

 

 

 

 新增文档

 查看、删除文档

修改文档

 

RestClient操作索引库

 

 

  1. #酒店的mapping
  2. PUT /hotel
  3. {
  4.   "mappings": {
  5.     "properties": {
  6.       "id":{
  7.         "type": "keyword"
  8.       },
  9.       "name":{
  10.         "type": "text",
  11.         "analyzer": "ik_max_word"
  12.       },
  13.       "adress":{
  14.         "type": "keyword",
  15.         "index": false
  16.       },
  17.       "price":{
  18.         "type": "integer"
  19.       },
  20.       "score":{
  21.         "type": "integer"
  22.       },
  23.       "brand":{
  24.         "type": "keyword"
  25.       },
  26.       "city":{
  27.         "type": "keyword"
  28.       },
  29.       "starName":{
  30.         "type": "keyword"
  31.       },
  32.       "business":{
  33.         "type": "keyword"
  34.       },
  35.       "location":{
  36.         "type": "geo_point"
  37.       },
  38.       "pic":{
  39.         "type": "keyword",
  40.         "index": false
  41.       }
  42.     }
  43.   }
  44. }

索引库代码

  1.  
  2. public class HotelIndexTest {
  3.     private RestHighLevelClient client;
  4.  
  5.     @Test
  6.     void testInit(){
  7.         System.out.println(client);
  8.     }
  9.     @Test
  10.     void createHotelIndex() throws IOException {
  11.         //1.创建Request对象
  12.         CreateIndexRequest request = new CreateIndexRequest("hotel");
  13.         //2.准备请求的参数，DSL语句
  14.         request.source(MAPPTING_TEMPLATE, XContentType.JSON);
  15.         //3.发送请求
  16.         client.indices().create(request, RequestOptions.DEFAULT);
  17.     }
  18.  
  19.  
  20.     @Test
  21.     void deleteHotelIndex() throws IOException {
  22.         //1.创建Request对象
  23.         DeleteIndexRequest request = new DeleteIndexRequest("hotel");
  24.  
  25.         //3.发送请求
  26.         client.indices().delete(request, RequestOptions.DEFAULT);
  27.     }
  28.  
  29.     @Test
  30.     void testExistHotelIndex() throws IOException {
  31.         //1.创建Request对象
  32.         GetIndexRequest request = new GetIndexRequest("hotel");
  33.  
  34.         boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
  35.         //3.发送请求
  36.         System.err.println(exists ? "索引库已经存在" : "索引库不存在！");
  37.     }
  38.  
  39.     @BeforeEach
  40.     void setUp(){
  41.         this.client = new RestHighLevelClient(
  42.                 RestClient.builder(HttpHost.create("http://虚拟机地址:es端口号")
  43.                 ));
  44.     }
  45.  
  46.     @AfterEach
  47.     void tearDown()throws IOException{
  48.         this.client.close();
  49.     }
  50. }

RestClient操作文档

 

 

 

操作文档代码

  1.  
  2. @SpringBootTest
  3. public class HotelDocumentTest {
  4.  
  5.     @Autowired
  6.     private IHotelService hotelService;
  7.  
  8.     private RestHighLevelClient client;
  9.  
  10.     @Test
  11.     void testAddDcoument() throws IOException {
  12.         //根据id查询酒店数据
  13.         Hotel hotel = hotelService.getById(36934L);
  14.         //转化为文档类型
  15.         HotelDoc hotelDoc = new HotelDoc(hotel);
  16.  
  17.         //1.准备Request对象
  18.         IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
  19.         //2.准备Json文件
  20.         request.source(JSON.toJSONString(hotelDoc),XContentType.JSON);
  21.         client.index(request,RequestOptions.DEFAULT);
  22.         //3.发送请求
  23.     }
  24.  
  25.     @Test
  26.     void testGetDocumentById() throws IOException {
  27.         //1.准备Request
  28.         GetRequest request = new GetRequest("hotel", "36934");
  29.         //2.发送请求，得到响应
  30.         GetResponse response = client.get(request, RequestOptions.DEFAULT);
  31.         //3.解析响应结果
  32.         String json = response.getSourceAsString();
  33.  
  34.         HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
  35.         System.out.println(hotelDoc);
  36.  
  37.     }
  38.  
  39.     @Test
  40.     void testRulkRequest() throws IOException {
  41.         //批量查询酒店数据
  42.         List<Hotel> hotels = hotelService.list();
  43.  
  44.  
  45.         //1.创建Request
  46.         BulkRequest request = new BulkRequest();
  47.         //2.准备参数，添加多个新增的Request
  48.         for ( Hotel hotel : hotels ) {
  49.             //转换为文档类型HotelDoc
  50.             HotelDoc hotelDoc = new HotelDoc(hotel);
  51.             //2.准备参数，添加多个新增的Request
  52.             request.add(new IndexRequest("hotel")
  53.                     .id(hotel.getId().toString())
  54.                     .source(JSON.toJSONString(hotelDoc),XContentType.JSON));
  55.  
  56.         }
  57.         //3.发送请求
  58.         client.bulk(request,RequestOptions.DEFAULT);
  59.     }
  60.  
  61.  
  62.  
  63.     @Test
  64.     void testUpdateDocumentById() throws IOException {
  65.         //1.准备Request
  66.         UpdateRequest request = new UpdateRequest("hotel", "36934");
  67.         //2.准备请求参数
  68.         request.doc(
  69.                 "price","952",
  70.                 "starName","五钻"
  71.         );
  72.         //2.发送请求，得到响应
  73.         client.update(request, RequestOptions.DEFAULT);
  74.         //3.解析响应结果
  75.     }
  76.  
  77.     @Test
  78.     void testDeleteDocumentById() throws IOException {
  79.  
  80.         List<Hotel> list = hotelService.list();
  81.         //循环删除
  82.         for ( Hotel hotel : list ) {
  83.             //1.准备Request
  84.             DeleteRequest request = new DeleteRequest("hotel", hotel.getId().toString());
  85.  
  86.             //2.发送请求，得到响应
  87.             client.delete(request, RequestOptions.DEFAULT);
  88.         }
  89.  
  90.         //1.准备Request
  91.         DeleteRequest request = new DeleteRequest("hotel", "36934");
  92.  
  93.         //2.发送请求，得到响应
  94.         client.delete(request, RequestOptions.DEFAULT);
  95.  
  96.     }
  97.  
  98.  
  99.  
  100.  
  101.  
  102.     @BeforeEach
  103.     void setUp(){
  104.         this.client = new RestHighLevelClient(
  105.                 RestClient.builder(HttpHost.create("http://虚机机地址:es端口")
  106.                 ));
  107.     }
  108.  
  109.     @AfterEach
  110.     void tearDown()throws IOException{
  111.         this.client.close();
  112.     }
  113. }

DSL 查询文档

 

 DSL  Query的分类

DSL Query基本语法

 全文检索查询

  1.  
  2. GET /hotel/_doc/36934
  3.  
  4. #查询所有
  5. GET /hotel/_search
  6. {
  7.   "query": {
  8.     "match_all": {}
  9.   }
  10. }
  11.  
  12. #math查询
  13. GET /hotel/_search
  14. {
  15.   "query": {
  16.     "match": {
  17.       "all": "外滩如家"
  18.     }
  19.   }
  20. }
  21.  
  22. #multi_math查询
  23. GET /hotel/_search
  24. {
  25.   "query": {
  26.     "multi_match": {
  27.       "query": "外滩如家",
  28.       "fields": ["brand","name","business"]
  29.     }
  30.   }
  31. }

 精确查询

 

  1. #term查询
  2. GET /hotel/_search
  3. {
  4.   "query": {
  5.     "term": {
  6.       "city": {
  7.         "value": "上海"
  8.       }
  9.     }
  10.   }
  11. }
  12.  
  13. #range查询 几个e代表等于
  14. GET /hotel/_search
  15. {
  16.   "query": {
  17.     "range": {
  18.       "price": {
  19.         "gte": 1000,
  20.         "lte": 3000
  21.       }
  22.     }
  23.   }
  24. }

 地理查询

 

 

  1. #distance查询
  2. GET /hotel/_search
  3. {
  4.   "query": {
  5.     "geo_distance": {
  6.       "distance":"3km",
  7.       "location":"31.219306, 121.445427"
  8.     }
  9.   }
  10. }

相关性算分

 

 Function Score Query

  1. #function score 查询
  2. GET /hotel/_search
  3. {
  4.   "query": {
  5.     "function_score": {
  6.       "query": {
  7.         "match": {
  8.           "all": "外滩"
  9.         }
  10.       },
  11.       "functions": [
  12.         {
  13.           
  14.           "filter":{
  15.             "term":{
  16.               "brand":"7天酒店"
  17.             }
  18.           },
  19.           "weight":10
  20.         }
  21.        ],
  22.        "boost_mode":"sum"
  23.       }
  24.     }
  25.   }
  26.  }
  27. }

 

复合查询 Boolean Query

 

  1. GET /hotel/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": [
  6.         {
  7.           "match": {
  8.             "name": "如家"
  9.           }
  10.         }
  11.       ],
  12.       "must_not": [
  13.         {
  14.           "range": {
  15.             "price": {
  16.               "gt": 400
  17.              
  18.             }
  19.           }
  20.         }
  21.       ],
  22.       "filter": [
  23.         {
  24.           "geo_distance": {
  25.             "distance": "10km",
  26.             "location": {
  27.               "lat": 31.21,
  28.               "lon": 121.5
  29.             }
  30.           }
  31.         }
  32.       ]
  33.     }
  34.   }
  35. }

 搜索结果处理

排序

  1.  
  2. #sort排序
  3. GET /hotel/_search
  4. {
  5.   "query": {
  6.     "match_all": {}
  7.   },
  8.   "sort": [
  9.     {
  10.         "score": "desc"
  11.       
  12.     },
  13.     {
  14.       "price": "asc" 
  15.     }
  16.     
  17.   ]
  18. }
  19.  
  20. #找到121.6122，31.034周围的酒店，距离升序排序
  21. GET /hotel/_search
  22. {
  23.   "query": {
  24.     "match_all": {}
  25.   },
  26.   "sort": [
  27.     {
  28.       "_geo_distance": {
  29.         "location": {
  30.           "lat": 31.034,
  31.           "lon": 121.6122
  32.         },
  33.         "order": "asc",
  34.         "unit": "km"
  35.       }
  36.     }
  37.   ]
  38. }

分页

深度分页问题

 

高亮 

 

  1.  
  2.  
  3. #分页查询
  4. GET /hotel/_search
  5. {
  6.   "query": {
  7.     "match_all": {}
  8.   },
  9.   "sort": [
  10.     {
  11.         "price": "asc" 
  12.       
  13.     }
  14.   ],
  15.    "from":10,
  16.     "size":10
  17. }
  18.  
  19. #高亮显示 默认情况，ES搜索字段必须与高亮字段一致
  20. GET /hotel/_search
  21. {
  22.   "query": {
  23.     "match": {
  24.       "all": "如家"
  25.     }
  26.   },
  27.   "highlight": {
  28.     "fields": {
  29.       "name":{
  30.         "require_field_match": "false"
  31.       }
  32.     }
  33.   }
  34. }
  35.

RestClient查询文档

 

 

 

 

全文检索查询

 

精确查询 

符合查询

排序和分页

 ​​​​​​​高亮

 ​​​​​​​

觉得好的小伙伴记得一键三连哦

  1.  
  2. public class HotelIsearchTest {
  3.     private RestHighLevelClient client;
  4.  
  5.  
  6.  
  7.     @Test
  8.     void testMatchAll() throws IOException {
  9.         //1 准备Request
  10.         SearchRequest request = new SearchRequest("hotel");
  11.         //2.准备DSL
  12.         request.source()
  13.                 .query(QueryBuilders.matchAllQuery());
  14.         //3.发送请求
  15.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  16.         //4解析响应
  17.         handleRequest(response);
  18.     }
  19.  
  20.     /**
  21.      * 全文检索查询
  22.      * @throws IOException
  23.      */
  24.     @Test
  25.     void testMatch() throws IOException {
  26.         //1 准备Request
  27.         SearchRequest request = new SearchRequest("hotel");
  28.         //2.准备DSL
  29.         request.source()
  30.                 .query(QueryBuilders.matchQuery("all","如家"));
  31.         //3.发送请求
  32.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  33.         handleRequest(response);
  34.     }
  35.  
  36.     /**
  37.      * 精确查询、复合查询
  38.      * @throws IOException
  39.      */
  40.     @Test
  41.     void testBool() throws IOException {
  42.         //1 准备Request
  43.         SearchRequest request = new SearchRequest("hotel");
  44.         //2.准备DSL
  45.         //2.1准备BooleanQuery
  46.         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  47.         //2.2添加term
  48.         boolQuery.must(QueryBuilders.termQuery("city","上海"));
  49.         //2.3添加range
  50.         boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
  51.         request.source()
  52.                 .query(boolQuery);
  53.         //3.发送请求
  54.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  55.         handleRequest(response);
  56.     }
  57.  
  58.     /**
  59.      * 排序和分页
  60.      * @throws IOException
  61.      */
  62.     @Test
  63.     void testPageAndSort() throws IOException {
  64.         //页码、每页大小
  65.         int page = 2,size = 5;
  66.         //1 准备Request
  67.         SearchRequest request = new SearchRequest("hotel");
  68.         //2.准备DSL
  69.         //2.1query
  70.         request.source()
  71.                 .query(QueryBuilders.matchAllQuery());
  72.         //2.2排序sort
  73.         request.source().sort("price", SortOrder.ASC);
  74.         //2.3分页from、size
  75.         request.source().from((page-1) * size).size(5);
  76.         //3.发送请求
  77.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  78.         handleRequest(response);
  79.     }
  80.  
  81.     /**
  82.      * 高亮
  83.      * @throws IOException
  84.      */
  85.     @Test
  86.     void testHighlight() throws IOException {
  87.  
  88.         //1 准备Request
  89.         SearchRequest request = new SearchRequest("hotel");
  90.         //2.准备DSL
  91.         //2.1query
  92.         request.source()
  93.                 .query(QueryBuilders.matchQuery("all","如家"));
  94.         //2.2高亮
  95.         request.source()
  96.                 .highlighter(
  97.                         new HighlightBuilder()
  98.                                 .field("name")
  99.                                 .requireFieldMatch(false)
  100.                 );
  101.  
  102.         //3.发送请求
  103.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  104.         handleHighlight(response);
  105.     }
  106.  
  107.  
  108.     private void handleRequest(SearchResponse response) {
  109.         //4解析响应
  110.         SearchHits searchHits = response.getHits();
  111.         //4.1 获取总条数
  112.         long total = searchHits.getTotalHits().value;
  113.         System.out.println("共搜索到" + total + "条数据");
  114.         //4.2文档数组
  115.         SearchHit[] hits = searchHits.getHits();
  116.         //4.3遍历
  117.         for ( SearchHit hit : hits ) {
  118.             //获取文档source
  119.             String json = hit.getSourceAsString();
  120.             //反序列化
  121.             HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
  122.             System.out.println("hotelDoc = " + hotelDoc);
  123.         }
  124.         System.out.println(response);
  125.     }
  126.  
  127.     /**
  128.      * 高亮结果分析
  129.      * @param response
  130.      */
  131.     private void handleHighlight(SearchResponse response) {
  132.         //4解析响应
  133.         SearchHits searchHits = response.getHits();
  134.         //4.1 获取总条数
  135.         long total = searchHits.getTotalHits().value;
  136.         System.out.println("共搜索到" + total + "条数据");
  137.         //4.2文档数组
  138.         SearchHit[] hits = searchHits.getHits();
  139.         //4.3遍历
  140.         for ( SearchHit hit : hits ) {
  141.             //获取文档source
  142.             String json = hit.getSourceAsString();
  143.             //反序列化
  144.             HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
  145.             //获取高亮结果
  146.             Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  147.             if ( !CollectionUtils.isEmpty(highlightFields) ) {
  148.                 //根据字段名获取如果
  149.                 HighlightField highlightField = highlightFields.get("name");
  150.                 if ( highlightField!=null ) {
  151.                     //获取高亮的值
  152.                     String name = highlightField.getFragments()[0].string();
  153.                     //覆盖非高亮结果
  154.                     hotelDoc.setName(name);
  155.                 }
  156.  
  157.             }
  158.  
  159.             System.out.println("hotelDoc = " + hotelDoc);
  160.         }
  161.         System.out.println(response);
  162.     }
  163.  
  164.     /**
  165.      *  高亮结果解析
  166.      */
  167.  
  168.     @BeforeEach
  169.     void setUp(){
  170.         this.client = new RestHighLevelClient(
  171.                 RestClient.builder(HttpHost.create("http://虚拟机地址:es端口号")
  172.                 ));
  173.     }
  174.  
  175.     @AfterEach
  176.     void tearDown()throws IOException{
  177.         this.client.close();
  178.     }
  179. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/571350
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号