# 1.什么是RestClient



![image.png](/static/img/5206119bbeb3ebafc66aaf0e7746879c.image.webp)
# 2.实现RestClient案例
导入数据库
![image.png](/static/img/e2c91591008c12c87dfbaab3dbd6338a.image.webp)
编写创建索引库的语句

![image.png](/static/img/5aecb6e3f93cb3793fe81f20c0d78487.image.webp)

![image.png](/static/img/d7e2c38cf9ffc977d58ebdad8cd4c33b.image.webp)

使用copy_to可以将当前的字段拷贝到其他之中实现同时根据多个字段搜索

```DSL
# 酒店的mappings
PUT /hotel
{
  "mappings": {
    "properties": {
      "id":{
        "type":"keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },"city":{
        "type": "keyword"
      },"starName":{
        "type": "keyword"
      },"business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
        
      }
      ,"all":{
         "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}
```
初始化项目中的RestClient

![image.png](/static/img/cb7317d4ca1c357f5d651cb440ec65dc.image.webp)

```pom

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.12.1</version>
        </dependency>
```
springboot管理了elasticsearch的版本需要添加覆盖版本
![image.png](/static/img/9671bd809c4b2c5de83aaec583dc8359.image.webp)
覆盖版本
![image.png](/static/img/f9b36a7dc0408003a2f29ec46ec0cd75.image.webp)
版本全部变为7.12.1（与搭建的elasticsearch一致）
![image.png](/static/img/26d02509d81ddd95f4ad251ed1e50a8b.image.webp)
在测试类中编写初始化和销毁代码

```java
ublic class HotelIndexTest {
    private RestHighLevelClient client;


    @BeforeEach
    void setUp(){
        this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.42.10:9200")))
    }
    

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}
```
编写创建索引库代码
![image.png](/static/img/a78eabbdaa4259acad5a6da88da6e27e.image.webp)

```java
    @Test
    void testCreateHotelIndex() throws IOException {
        // 创建request对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 请求参数
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 发起请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }
```
编写一个类存放创建索引库的语句

```java
package cn.itcast.hotel.constants;

public class HotelConstants {
    public final static String MAPPING_TEMPLATE = "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\":{\n" +
            "        \"type\":\"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"address\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"score\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"brand\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\"city\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\"starName\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\"business\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"location\":{\n" +
            "        \"type\": \"geo_point\"\n" +
            "      },\n" +
            "      \"pic\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "        \n" +
            "      }\n" +
            "      ,\"all\":{\n" +
            "         \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
}

```
运行代码查询平台创建成功

```java
{
  "hotel" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "address" : {
          "type" : "keyword",
          "index" : false
        },
        "brand" : {
          "type" : "keyword"
        },
        "business" : {
          "type" : "keyword"
        },
        "city" : {
          "type" : "keyword"
        },
        "id" : {
          "type" : "keyword"
        },
        "location" : {
          "type" : "geo_point"
        },
        "name" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "pic" : {
          "type" : "keyword",
          "index" : false
        },
        "price" : {
          "type" : "integer"
        },
        "score" : {
          "type" : "integer"
        },
        "starName" : {
          "type" : "keyword"
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "hotel",
        "creation_date" : "1759399676974",
        "number_of_replicas" : "1",
        "uuid" : "aRnUh_l1Thi3hABSvrbm_w",
        "version" : {
          "created" : "7120199"
        }
      }
    }
  }
}

```

删除索引库判断索引库是否存在

![image.png](/static/img/0f11147d0b915a9a8413b056d24a5b42.image.webp)

```java
    @Test
    void testGetHotelIndex() throws IOException {
        // 创建request对象
        GetIndexRequest request = new GetIndexRequest("hotel");
        // 发起判断索引库是否存在
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        // 输出结果
        System.out.println(exists);
    }
```

```java
    @Test
    void testDeleteHotelIndex() throws IOException {
        // 创建request对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        // 发起删除请求
        client.indices().delete(request, RequestOptions.DEFAULT);
    }
```
# 3.文档的增删改查
编写添加文档代码

```java
    @Test
    void testInsertIndex() throws IOException {
        // 根据id查询hotel数据
        Hotel hotel= hotelService.getById(36934L);
        //        将hotel转成hotelDoc
        HotelDoc hotelDoc = new HotelDoc(hotel);
//        创建request对象
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());

        request.source(JSON.toJSONString(hotelDoc),XContentType.JSON);

        client.index(request, RequestOptions.DEFAULT);

    }
```

添加成功在可视化平台上查询 添加成功

![image.png](/static/img/453aff83c5efc87b159af4c33c869485.image.webp)

根据id查询文档


![image.png](/static/img/42bc49d3f4c6409ba13d5a17711903d5.image.webp)

```java
    @Test
    void testGetDocument() throws IOException {
//        创建request对象
        GetRequest request = new GetRequest("hotel","36934");
//        获取response
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
//        解析返回数据
        String json = response.getSourceAsString();
//        打印结果
        HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
        System.out.println(hotelDoc.toString());
    }
```

修改文档

```java
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest request = new UpdateRequest("hotel","36934");
        request.doc("price","952","starName","四钻");
        client.update(request, RequestOptions.DEFAULT);
    }
```

删除文档

```java
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest request = new DeleteRequest("hotel","36934");
        client.delete(request, RequestOptions.DEFAULT);
    }
```

总结

![image.png](/static/img/2a6de8de9acb0aef1ee2b6964a3a7f81.image.webp)

# 4.文档的批量导入功能

![image.png](/static/img/6b4d7c1d3fab656a47936194a34d4b28.image.webp)

代码示例


```java
    @Test
    void testRangeIndexDocument() throws IOException {
     // 使用mybatis-plus读取数据库数据
        List<Hotel> hotelList = hotelService.list();
        BulkRequest request = new BulkRequest();
        for (Hotel hotel : hotelList) {
            HotelDoc hotelDoc = new HotelDoc(hotel);
            request.add(new IndexRequest("hotel").id(hotelDoc.getId().toString()).source(JSON.toJSONString(hotelDoc),XContentType.JSON));
        }
        client.bulk(request, RequestOptions.DEFAULT);
    }
```

# 5.elasticsearch搜索功能

DSL查询

![image.png](/static/img/6e52a6b48acbead635380e3a30816056.image.webp)

基本语法
查询所有
![image.png](/static/img/13871c0be5a24aa8f88b5748f84a4168.image.webp)
```DSL
GET /hotel/_search
{
  "query":{
  "match_all":{
    
  }
  }
}
```
全文检索查询（搜索框搜索）

![image.png](/static/img/b6dc20114b16a49f2373b15f35ccfa06.image.webp)


![image.png](/static/img/307d71910c3e832adc89857cd0925812.image.webp)

使用all搜索设置好的字段

```DSL
# match 单字段查询
Get /hotel/_doc/_search
{
  "query":{
    "match":{
      "all":"外滩"
    }
    
  }
}
```

```DSL
# multi_match 多字段查询
Get /hotel/_doc/_search
{
  "query":{
    "multi_match":{
      "query":"外滩如家",
      "fields":["brand","name","business"]
    }
    
  }
}
```
精确查询


![image.png](/static/img/84c969f4bb09909f700c32aa1e9a1df0.image.webp)

![image.png](/static/img/ce7152107152e47d128e1b4e55b1455d.image.webp)
```DSL
# term查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city" : {
        "value": "北京"
      }
    }
  }
}
```
价格在 100到300（包含100 300）

```DSL
# range
GET /hotel/_search
{
  "query":{
    "range":{
      "price":{
        "gte":100,
        "lte":300
      }
    }
  }
}
```
价格在 1341到3000（不包含1341 3000）

```DSL
GET /hotel/_search
{
  "query":{
    "range":{
      "price":{
        "gt":1341,
        "lt":3000
      }
    }
  }
}
```

地理查询

geo_bounding_box

![image.png](/static/img/26ba8e368cf3b67985d302c87b96e592.image.webp)

geo_distance

![image.png](/static/img/2e59196ccdcc4e08837bccb6c9fee6ff.image.webp)

```DSL
GET /hotel/_search
{
  "query":{
    "geo_distance":{
      "distance":"15km",
      "location":"31.21,121.5"
    }
  }
}

```

复合查询

![image.png](/static/img/3c067c75b523faf5dd7caf6b6360f019.image.webp)

![image.png](/static/img/7884f5f6d237e80fe6c31a8db6cecb15.image.webp)

![image.png](/static/img/a2d8d9a7463f08aad26dd5dd50788279.image.webp)

控制查询

![image.png](/static/img/ef1afeda7e7ab54e0b743b924cf30c93.image.webp)

控制品牌为如家的酒店放在最上面

```DSL
# function score
GET /hotel/_search
{
  "query":{
    "function_score": {
      "query": {
        "match":{
          "all":"外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 100
        }
      ],
      "boost_mode": "multiply"
    }
  }
}
```


![image.png](/static/img/98f4d9fdea5459a0e75ceeffaadd4259.image.webp)

案例

![image.png](/static/img/fa2ec2c33a660e4efcdc24128398ce63.image.webp)

```DSL
GET /hotel/_search
{
  "query":{
    "bool":{
      "must": [
        {
          "match": {
            "name": "如家"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}
```
在filter中的内容不参与算分降低性能消耗

RestClient(1)

# 1.elasticsearch介绍



![image.png](/static/img/c8cdd575c51a3fd66f5139e99b1addbe.image.webp)
![image.png](/static/img/6fec0f491602131d10bf9d34c67f1c28.image.webp)
# 2.正向索引和倒排索引

![image.png](/static/img/bb4234cf8223a9e203445c1bc9e87fa1.image.webp)
概念对比

![image.png](/static/img/8c08b09aff1568fde2ee669f5280acce.image.webp)
# 3。安装elastsearch
# 4.安装kibana

```sh
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601 \
kibana:7.12.1

```
# 5.分词器
安装分词器
## (1)到github下载ik，放入挂载es-plugins的卷中
![image.png](/static/img/e8e9c7d09a8060e08dbaced68b48f81c.image.webp)
重启es实例
# 6.配置分词器的禁用和拓展词
![image.png](/static/img/4288c6396118a411d40b9af9ed3770c9.image.webp)
创建禁用词和拓展词的文件
![image.png](/static/img/1485dbab296f2053475fd844db567061.image.webp)
重启es使配置的拓展词库和禁用词生效
# 7.索引库操作
mapping属性
![image.png](/static/img/9abc8798a65d0a1d7bbc55bdf67dbded.image.webp)
# 8.创建索引库
![image.png](/static/img/76dafe14b4195d4151763ca5948dbbc7.image.webp)

```DSL
put /heima
{
  "mappings":{
    "properties":{
      "info":{
        "type": "text",
        "analyzer":"ik_smart"
      },
      "email":{
        "type":"keyword",
        "index":false
      },
      "name":{
        "type":"object",
        "properties":{
          "firstName":{
            "type":"keyword"
          },
          "lastName":{
            "type":"keyword"
          }
        }
      }
    }
    
  }
}
```
查询和删除索引库

![image.png](/static/img/9138b7ff977564c19419c9ecffbe9e58.image.webp)
修改索引库（禁止直接修改原索引库）
![image.png](/static/img/9e4cce600b40940ceaa11430cec964ee.image.webp)
# 8.文档操作
文档插入

```DSL
POST /heima/_doc/1
{
  "info":"测试数据",
  "email":"test@qq.com",
  "name":{
    "firstName":"测",
    "lastName":"试"
  }
}
```
返回

```log
{
  "_index" : "heima",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}
```
查询和删除文档

```DSL
# 查询文档
GET /heima/_doc/1


# 删除文档
DELETE /heima/_doc/1
```
# 9.修改文档
全量修改
![image.png](/static/img/5e9cb099d3db4995448aca3ca28a1fe0.image.webp)
会将原文档删除并重新添加（既能修改又能更新）

增量修改
![image.png](/static/img/f138cdef4863d6b88188407f3aab9706.image.webp)


![image.png](/static/img/bd741fc8cbbd4bac592da77ccfdd3880.image.webp)

ElasticSearch(1)

# 1.消息队列




![image.png](/static/img/fe85c7921c1eea8c76fb91d0d230e0e9.image.webp)
# 2.基础概念

![image.png](/static/img/bb525212a719ad153fb3457d03da8005.image.webp)
# 3.Hello World案例
## (1)publisherTest

```java
public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.42.10");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
```
## (2)ConsumerTest代码

```java
public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.42.10");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
```

![image.png](/static/img/bc4f32e6ebcc763a50489c240003cceb.image.webp)
# 4.Spring AMQP

![image.png](/static/img/f18b8b360e93cb5f99b7e44fe277cb30.image.webp)
利用Spring AMQP实现HelloWorld案例

![image.png](/static/img/94890abe884a3c7d350a9fe48acc20ac.image.webp)

```pom
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
```
编写配置

![image.png](/static/img/09c2b9e35ae8c4607c5da6dc7158ce8d.image.webp)
编写测试

```java
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void RabbitMqTest(){
        String queueName = "simple.queue";
        String message = "Hello World";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}
```

![image.png](/static/img/a83aa3bbf2b52b3e3a1cd54393f55cbf.image.webp)
接收消息

![image.png](/static/img/02804effa0c65fbb564371af16f27843.image.webp)
# 5.工作队列 work queue

![image.png](/static/img/a733e23d6dbfa9f37491822006546bb2.image.webp)
案例

![image.png](/static/img/30d560ca5e12f4f79daba2e5c9a5c4ef.image.webp)
发布50条数据到队列

```java
    @Test
    public  void RabbitMqTestWorkQueue() throws InterruptedException {
        String queueName = "simple.queue";
        String message = "Hello World__";
        for (int i = 1;i<=50;i++){
            rabbitTemplate.convertAndSend(queueName,message+i);
            Thread.sleep(20);
        }
    }
```
接受数据

```java
    @RabbitListener(queues = "simple.queue")
    public void lisstenerWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息:["+msg+"]");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void lisstenerWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息:["+msg+"]"+ LocalTime.now());
        Thread.sleep(200);
    }
```
显示数据

```log
消费者2接收到消息:[Hello World__1]16:28:43.674
消费者1接收到消息:[Hello World__2]
消费者1接收到消息:[Hello World__4]
消费者1接收到消息:[Hello World__6]
消费者2接收到消息:[Hello World__3]16:28:43.874
消费者1接收到消息:[Hello World__8]
消费者1接收到消息:[Hello World__10]
消费者1接收到消息:[Hello World__12]
消费者1接收到消息:[Hello World__14]
消费者2接收到消息:[Hello World__5]16:28:44.088
消费者1接收到消息:[Hello World__16]
消费者1接收到消息:[Hello World__18]
消费者1接收到消息:[Hello World__20]
消费者2接收到消息:[Hello World__7]16:28:44.304
消费者1接收到消息:[Hello World__22]
消费者1接收到消息:[Hello World__24]
消费者1接收到消息:[Hello World__26]
消费者1接收到消息:[Hello World__28]
消费者2接收到消息:[Hello World__9]16:28:44.517
消费者1接收到消息:[Hello World__30]
消费者1接收到消息:[Hello World__32]
消费者1接收到消息:[Hello World__34]
消费者2接收到消息:[Hello World__11]16:28:44.729
```
当消费者接受数据时会预取数据两个消费者平分数据
![image.png](/static/img/c79defc2bd0deb6c5150eddcf8df16d0.image.webp)
可以修改预取值来控制消费者按照处理速度修改提高效率

```data
消费者2接收到消息:[Hello World__1]16:36:22.113
消费者1接收到消息:[Hello World__2]
消费者1接收到消息:[Hello World__3]
消费者1接收到消息:[Hello World__4]
消费者1接收到消息:[Hello World__5]
消费者1接收到消息:[Hello World__6]
消费者1接收到消息:[Hello World__7]
消费者1接收到消息:[Hello World__8]
消费者2接收到消息:[Hello World__9]16:36:22.346
消费者1接收到消息:[Hello World__10]
消费者1接收到消息:[Hello World__11]
消费者1接收到消息:[Hello World__12]
消费者1接收到消息:[Hello World__13]
消费者1接收到消息:[Hello World__14]
消费者1接收到消息:[Hello World__15]
消费者1接收到消息:[Hello World__16]
消费者2接收到消息:[Hello World__17]16:36:22.597

```
修改过后提高处理速度
# 6.发布订阅模式

![image.png](/static/img/1f49e50ee3f83783b898386c5c159274.image.webp)

![image.png](/static/img/45c9f9988525bc25d90cf8e3a3de9bf1.image.webp)

![image.png](/static/img/2386c27349c588edb267a6fe9fa17c35.image.webp)

```java
@Configurable
public class FanoutConfig {

//    创建交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
//创建消息队列1
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("itcast.fanout1");
    }
//绑定消息队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
//创建消息队列2
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("itcast.fanout2");
    }
//绑定消息队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}
```
编写接收消息代码

```java
    @RabbitListener(queues = "fanout.queue1")
    public void lisstenerWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息:["+msg+"]");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void lisstenerWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息:["+msg+"]"+ LocalTime.now());
        Thread.sleep(200);
    }
```
修改publisher端代码

```java
    @Test
    public void RabbitMqTestWorkQueue2() throws InterruptedException {
        String queueName = "itcast.fanout";
        String message = "Hello World test fanout";
        rabbitTemplate.convertAndSend(queueName,"",message);
    }
```
# 7.路由模式

![image.png](/static/img/35ab95e35999185b6a42cc241cc40db4.image.webp)
修改消费者监听代码

```java
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void listenDirectQueue1(String msg)   {
        System.out.println("消费者接收到direct.queue1消息:"+msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg)   {
        System.out.println("消费者接收到direct.queue2消息:"+msg);
    }
```
修改发布者发布代码

```java
    @Test
    public void RabbitMqTestWorkQueue2() throws InterruptedException {
        String queueName = "itcast.direct";
        String message = "Hello yellow";
        rabbitTemplate.convertAndSend(queueName,"yellow",message);
    }
```
发布者只发布给yellow
# 8.发布订阅 TopicExchange
通配符订阅
![image.png](/static/img/1bc8f6d4a0f28ba9d955da464db156c6.image.webp)
交换机配置部分不变修改listen部分代码

```java
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listenTopicQueue1(String msg)   {
        System.out.println("消费者接收到topic.queue1消息:"+msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listenTopicQueue2(String msg)   {
        System.out.println("消费者接收到topic.queue2消息:"+msg);
    }
```
发送端测试

```java
    @Test
    public void RabbitMqTestTopicQueue3() throws InterruptedException {
        String queueName = "itcast.topic";
        String message = "Hello china";
        rabbitTemplate.convertAndSend(queueName,"china.news",message);
    }
```
# 9.消息转换器

## (1)创建一个消息队列

```java
    @Bean
    public Queue fanoutQueue3(){
        return new Queue("object.queue");
    }
```
## (2)向"object.queue"发送对象数据

```java
    @Test
    public  void sendObjectQueue(){
        Map<String,Object> msg = new HashMap<>();
        msg.put("name","柳岩");
        msg.put("age",18);
        rabbitTemplate.convertAndSend("object.queue",msg);
    }
```
## (3)获取数据
![image.png](/static/img/0f941692ea5c804e85be55808ed52fe3.image.webp)
上面传输的对象数据并没有配置消息转换器无法直接查看
## (4)配置消息转换器
![image.png](/static/img/4e3274bb1bc9b6ce9cfb9d5e011304cf.image.webp)

```pom
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.9.10</version>
        </dependency>
```

```java
    @Bean
    public MessageConverter jsonMessageConverter() {
        return new Jackson2JsonMessageConverter();
    }
```
![image.png](/static/img/5df653ba2654499c65b3f3a441f0961a.image.webp)
消息转换器配置成功

## (5)消费端输出接收到的消息

配置消息转换器并编写队列监听代码
```java
    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg)   {
        System.out.println("接收到object.queue:"+msg);
    }
```

RabbitMQ

# 1.拉取Docker镜像



```shell
docker pull nginx
```
`[root@localhost ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
d107e437f729: Pull complete 
cb497a329a81: Pull complete 
f1c4d397f477: Pull complete 
f72106e86507: Pull complete 
899c83fc198b: Pull complete 
a785b80f5a67: Pull complete 
6c50e4e0c439: Pull complete 
Digest: sha256:d5f28ef21aabddd098f3dbc21fe5b7a7d7a184720bc07da0b6c9b9820e97f25e
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
`
# 2.

Docker

# 1.为什么需要网关


![image.png](/static/img/468eda077abcf30ae8735a661f62d2e4.image.webp)
# 2.操作
## （1）创建项目引入依赖服务发现和gateway网关依赖


![image.png](/static/img/cdb250b04a724143b93c399eccf551aa.image.webp)
```pom
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>
```
## (2)实现请求路由功能

![image.png](/static/img/b3d370fad4372e7db7564266f75ee1ab.image.webp)

```config
spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: localhost:80
    gateway:
      routes:
        - id: user-service
          uri: lb://userservice # 路由的目标地址
          predicates:
            - Path=/user/** # 判断路径是否是user开头
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**
server:
  port: 10010
```
## (3)总结

![image.png](/static/img/092984b9635df7b42947f1b9a0317748.image.webp)
## （4）路由断言工厂

![image.png](/static/img/dd4033b163041b4cc82c76549ae0b5ab.image.webp)
## （5）过滤器工厂

![image.png](/static/img/a0a2201ea4ca8e3a8f57589b2fd42825.image.webp)
代码示例

```config
    gateway:
      routes:
        - id: user-service
          uri: lb://userservice # 路由的目标地址
          predicates:
            - Path=/user/** # 判断路径是否是user开头
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**
          filters:
            - AddRequestHeader=Truth,Hello world # 添加的过滤器
```
向所有微服务添加过滤器
**默认过滤器**
![image.png](/static/img/ebcac6233ff72d094445a87df0f0e803.image.webp)
**全局过滤器**
编写代码自定义过滤逻辑
实现golabalFilter接口
![image.png](/static/img/71dcf5725e3c2359d6830db05773b13c.image.webp)
**案例：**

![image.png](/static/img/37a775fd9f108467e2badd3ab3339724.image.webp)

```java
package cn.itcast.gateway;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;



@Order(-1) // 定义过滤器的顺序 默认最低 数字越小最先执行
@Component
public class AuthorizeFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

//        1.获取请求参数
        ServerHttpRequest request =exchange.getRequest();
        MultiValueMap<String,String> params= request.getQueryParams();
//        2获取参数中的authorization
        String auth = params.getFirst("authorization");
        if ("admin".equals(auth)){
            return chain.filter(exchange); // 放行
        }
        // 否 拦截

        // 设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        // 拦截请求
        return exchange.getResponse().setComplete();
        //
    }
}

```
**过滤器执行顺序**
1.当前路由过滤器
2.DefaultFilter
3.GlobalFilter
![image.png](/static/img/ebd52358f434cca28a1c79e48bc902e9.image.webp)
![image.png](/static/img/a818ed1a3cfe45b36dec21858889bdd5.image.webp)
![image.png](/static/img/353c55977b8734c89602637806be49c5.image.webp)
## （6）跨域问题

![image.png](/static/img/07020596503477f58e5f6bfb1c378411.image.webp)