# 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)

统一网关Gateway

# 1.Feign介绍




![image.png](/static/img/6ce56e37e890a10f6d89a6c509ad4cc7.image.webp)
# 2.定义和使用客户端
   ## (1)引入依赖
   
![image.png](/static/img/401192c64c830db97e495dce267f3287.image.webp)

```config

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
```
   ## (2)在order-service的启动类中加注释开启Fegin的功能
   
![image.png](/static/img/b9d4e7609cf614ea34849eeeb1f72892.image.webp)
   ## (3)编写Feign客户端
   
![image.png](/static/img/91fcbe5e62a20c13603cc5a69a980cbb.image.webp)

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

```java
package cn.itcast.order.clients;


import org.springframework.cloud.openfeign.FeignClient;

@FeignClient("userservice")
public interface UserClient {
}
```
## (4)调用举例

```java
@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private UserClient userClient;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单·
        Order order = orderMapper.findById(orderId);
        
        User user = userClient.getUserById(order.getUserId());
        
        order.setUser(user);
        // 4.返回
        return order;
    }
}
```
# 3.配置feign
法一
![image.png](/static/img/030f9d4c9e50819516f8e857674b757b.image.webp)
法二
![image.png](/static/img/444b464a7cdfa0fea434bfd5c59eade1.image.webp)
# 4.feign性能优化
默认使用URLconnection
使用连接池代替URLconnection
![image.png](/static/img/74b12e1c38ed52ef1dc301d808f4ef37.image.webp)
连接池配置
![image.png](/static/img/95b8089089660df394b7c46cbcd175e2.image.webp)

```pom

        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-httpclient</artifactId>
        </dependency>
```

```config
feign:
  client:
    config:
      default:
        loggerLevel: FULL
  httpclient:
    enabled: true # 开启feign对httpclient的支持
    max-connections: 200 # 最大连接数
    max-connections-per-route: 50 # 每个路径的最大连接数
```
总结

![image.png](/static/img/f3605acba9227a3cb5aea5e1aca2edb6.image.webp)
# 5.feign的最佳实现

![image.png](/static/img/c107bb7e8e57c76310c9087330792d67.image.webp)
抽取具体实现
## （1）创建module

![image.png](/static/img/c51456bc900bc69c1bba3ac192fa49aa.image.webp)
## （2）将pojo和cliens的代码移动到feign-api中

![image.png](/static/img/41093267c68ad955916ec466070a0b0d.image.webp)
![image.png](/static/img/52f6b835c75a3822373600117d5886b9.image.webp)

Feign

# Nacos相关设置
## 1.权限配置


![image.png](/static/img/da99d2b0def0b3cb87fd5f5182a00dc9.image.webp)
在nacos中修改服务器权重如果为0则不访问
## 2.环境隔离

![image.png](/static/img/33600d8464bb99402c8118ee3134190e.image.webp)
![image.png](/static/img/9108aff8b549a3aca93573b26b1a3029.image.webp)
![image.png](/static/img/e5bc6c9faee42dbe8b1eef1b4e3e52d2.image.webp)
每一个namespace都有一个唯一id  
![image.png](/static/img/871a332ef755e496833b80e9d429f14d.image.webp)
不同namespace无法访问
## 3.nacos配置管理
### (1)统一配置管理
实现配置更改热更新
![image.png](/static/img/be686c67806135231a77ad6cdda367ca.image.webp)
![image.png](/static/img/a75c3967bfdfd2778f8df9ab2c601497.image.webp)
![image.png](/static/img/c1b38a06eed0c4259c070d1ad8643aa1.image.webp)
引入依赖
![image.png](/static/img/935a59db453ce409eb73626c372d6692.image.webp)

```config

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
```
编写引导文件
![image.png](/static/img/acee28a0dbac57a1f46f7dd0ed700a81.image.webp)
### (2)配置热更新
![image.png](/static/img/c531647828c091f73a23f2dfeaeb060d.image.webp)
![image.png](/static/img/dfe8aa2994aa07e813d51a210e1b6d7d.image.webp)