2.9日学习打卡----初学RabbitMQ（四）

2.9日学习打卡

一.RabbitMQ 死信队列

在这里插入图片描述
在MQ中，当消息成为死信（Dead message）后，消息中间件可以将其从当前队列发送到另一个队列中，这个队列就是死信队列。而在RabbitMQ中，由于有交换机的概念，实际是将死信发送给了死信交换机（Dead Letter Exchange，简称DLX）。死信交换机和死信队列和普通的没有区别。
在这里插入图片描述
消息成为死信的情况：

  1. 队列消息长度到达限制。
  2. 消费者拒签消息，并且不把消息重新放入原队列。
  3. 消息到达存活时间未被消费。

在这里插入图片描述
死信队列：
死信交换机和普通交换机，只是名字不同，其余的都一样；就是说死信交换机绑定死信队列，普通交换机绑定普通队列。

并且普通队列需要在创建的同时绑定死信交换机和死信队列的路由关键字；就是说当普通队列的消息达到死信的条件时，会通过绑定的死信交换机根据绑定的死信队列路由关键字发送该普通队列的消息，这个就是成为死信的过程。

除了拒签成为死信的需要监听普通队列，其余俩个不需要到达消费者端就会成为死信。
死信会有专门的死信消费者去监听。

创建死信队列

package com.jjy.rabbitproducer;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig4 {
    private final String DEAD_EXCHANGE = "dead_exchange";
    private final String DEAD_QUEUE = "dead_queue";

    private final String NORMAL_EXCHANGE = "normal_exchange";
    private final String NORMAL_QUEUE = "normal_queue";
    // 死信交换机
    @Bean(DEAD_EXCHANGE)
    public Exchange deadExchange(){
        return ExchangeBuilder
                .topicExchange(DEAD_EXCHANGE)
                .durable(true)
                .build();
    }

    // 死信队列
    @Bean(DEAD_QUEUE)
    public Queue deadQueue(){
        return QueueBuilder
                .durable(DEAD_QUEUE)
                .build();
    }

    // 死信交换机绑定死信队列
    @Bean
    public Binding bindDeadQueue(@Qualifier(DEAD_EXCHANGE) Exchange exchange, @Qualifier(DEAD_QUEUE)Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("dead_routing")
                .noargs();
    }

    // 普通交换机
    @Bean(NORMAL_EXCHANGE)
    public Exchange normalExchange(){
        return ExchangeBuilder
                .topicExchange(NORMAL_EXCHANGE)
                .durable(true)
                .build();
    }

    // 普通队列
    @Bean(NORMAL_QUEUE)
    public Queue normalQueue(){
        return QueueBuilder
                .durable(NORMAL_QUEUE)
                .deadLetterExchange(DEAD_EXCHANGE) // 绑定死信交换机
                .deadLetterRoutingKey("dead_routing") // 死信队列路由关键字
                .ttl(10000) // 消息存活10s
                .maxLength(10) // 队列最大长度为10
                .build();
    }

    // 普通交换机绑定普通队列
    @Bean
    public Binding bindNormalQueue(@Qualifier(NORMAL_EXCHANGE) Exchange exchange,@Qualifier(NORMAL_QUEUE)Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("my_routing")
                .noargs();
    }
}

测试死信队列

生产者发送消息

 @Test
    public void TestDlx(){
        // 存活时间过期后变成死信
          rabbitTemplate.convertAndSend("normal_exchange","my_routing","测试死信");
        // 超过队列长度后变成死信
            for (int i = 0; i < 20; i++) {
               rabbitTemplate.convertAndSend("normal_exchange","my_routing","测试死信");
            }
        // 消息拒签但不返回原队列后变成死信
        rabbitTemplate.convertAndSend("normal_exchange","my_routing","测试死信");
    }

消费者拒收消息

package com.jjy.rabbitconsumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class DlxConsumer {
    @RabbitListener(queues = "normal_queue")
    public void listenMessage(Message message, Channel channel) throws IOException {
        // 拒签消息
        channel.basicNack(message.getMessageProperties().getDeliveryTag(),true,false);
    }
}

二. RabbitMQ 延迟队列

在这里插入图片描述
延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

例如：用户下单后，30分钟后查询订单状态，未支付则会取消订单
在这里插入图片描述
但RabbitMQ中并未提供延迟队列功能，我们可以使用死信队列实现延迟队列的效果。
在这里插入图片描述

延迟队列_死信队列实现

在这里插入图片描述
编写配置文件


spring:
  rabbitmq:
    host: 192.168.66.100
    port: 5672
    username: jjy
    password: jjy
    virtual-host: /

# 日志格式
logging:
  pattern:
    console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'

创建队列和交换机

package com.jjy.yanchirabbitmqdemo;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class RabbitmqConfig {
    // 订单交换机和队列
    private final String ORDER_EXCHANGE = "order_exchange";
    private final String ORDER_QUEUE = "order_queue";
    // 过期订单交换机和队列
    private final String EXPIRE_EXCHANGE = "expire_exchange";
    private final String EXPIRE_QUEUE = "expire_queue";
    // 过期订单交换机
    @Bean(EXPIRE_EXCHANGE)
    public Exchange deadExchange(){
        return ExchangeBuilder
                .topicExchange(EXPIRE_EXCHANGE)
                .durable(true)
                .build();
    }
    // 过期订单队列
    @Bean(EXPIRE_QUEUE)
    public Queue deadQueue(){
        return QueueBuilder
                .durable(EXPIRE_QUEUE)
                .build();
    }
    // 将过期订单队列绑定到交换机
    @Bean
    public Binding bindDeadQueue(@Qualifier(EXPIRE_EXCHANGE) Exchange exchange,@Qualifier(EXPIRE_QUEUE) Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("expire_routing")
                .noargs();
    }

    // 订单交换机
    @Bean(ORDER_EXCHANGE)
    public Exchange normalExchange(){
        return ExchangeBuilder
                .topicExchange(ORDER_EXCHANGE)
                .durable(true)
                .build();
    }
    // 订单队列
    @Bean(ORDER_QUEUE)
    public Queue normalQueue(){
        return QueueBuilder
                .durable(ORDER_QUEUE)
                .ttl(10000) // 存活时间为10s,模拟30min
                .deadLetterExchange(EXPIRE_EXCHANGE) // 绑定死信交换机
                .deadLetterRoutingKey("expire_routing") // 死信交换机的路由关键字
                .build();
    }
    // 将订单队列绑定到交换机
    @Bean
    public Binding bindNormalQueue(@Qualifier(ORDER_EXCHANGE) Exchange exchange,@Qualifier(ORDER_QUEUE) Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("order_routing")
                .noargs();
    }
}

编写下单的控制器方法，下单后向订单交换机发送消息

@RestController
public class OrderController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @GetMapping("/place/{orderId}")
    public String placeOrder(@PathVariable String orderId){
        System.out.println("处理订单数据");
        //将订单id发送到订单队列
        rabbitTemplate.convertAndSend("order_exchange","order_routing",orderId);
        return "下单成功，修改库存";
    }
    
}

编写监听死信队列的消费者

package com.jjy.yanchirabbitmqdemo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ExpireOrderConsumer {
   //监听过期订单队列
   @RabbitListener(queues = "expire_queue")
   public void listenMessage(String orderId){
       System.out.println("查询"+orderId+"订单状态，如果已支付无需处理，未支付，回退库存");
   }
   @RabbitListener(queues = "delayed_queue")
   public void listenMessage2(String orderId){
       System.out.println("查询"+orderId+"号订单的状态，如果已支付则无需处理，如果未支付则需要回退库存");
   }

}

RabbitMQ延迟队列_插件实现

在这里插入图片描述
在使用死信队列实现延迟队列时，会遇到一个问题：RabbitMQ只会移除队列顶端的过期消息，如果第一个消息的存活时长较长，而第二个消息的存活时长较短，则第二个消息并不会及时执行。
在这里插入图片描述
RabbitMQ虽然本身不能使用延迟队列，但官方提供了延迟队列插
件，安装后可直接使用延迟队列。
在这里插入图片描述
安装延迟队列插件

  1. 使用rz将rabbitmq_delayed_message_exchange-3.10.2.ez 插件上传到虚拟机
  2. 安装插件
# 将插件放入RabbitMQ插件目录中
mv rabbitmq_delayed_message_exchange-
3.9.0.ez /usr/local/rabbitmq/plugins/
# 启用插件
rabbitmq-plugins enable
rabbitmq_delayed_message_exchange
  1. 重启RabbitMQ服务
#停止rabbitmq
rabbitmqctl stop
#启动rabbitmq
rabbitmq-server restart -detached

此时登录管控台可以看到交换机类型多了延迟消息
管控台地址（https://自己地址:15672）默认账号和密码都是 guest
在这里插入图片描述
此时交换机是x-delayed-message类型的；延迟队列就是说发送延迟交换机及其绑定延迟队列的路由关键字和MessagePostProcessor对象，MessagePostProcessor对象是用来设置延迟时长等属性的。

延迟队列只是创建延迟交换机时跟普通不同，其他基本相同。

执行流程就是浏览器通过url映射到Controller的@RequestMapping注解的value中，然后执行方法体，执行到发送MQ，然后结束方法体；MQ此时延迟方法体中设置的时长，再发送给消费端，消费端监听到再处理延迟队列的MQ。
使用延迟队列

package com.jjy.yanchirabbitmqdemo;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitmqConfig2 {
    public final String DELAYED_EXCHANGE = "delayed_exchange";
    public final String DELAYED_QUEUE = "delayed_queue";

    //1.延迟交换机
    @Bean(DELAYED_EXCHANGE)
    public Exchange delayedExchange() {
        // 创建自定义交换机
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "topic"); // topic类型的延迟交换机
        return new CustomExchange(DELAYED_EXCHANGE, "x-delayed-message", true, false, args);
    }

    //2.延迟队列
    @Bean(DELAYED_QUEUE)
    public Queue delayedQueue() {
        return QueueBuilder
                .durable(DELAYED_QUEUE)
                .build();
    }

    // 3.绑定
    @Bean
    public Binding bindingDelayedQueue(@Qualifier(DELAYED_QUEUE) Queue queue, @Qualifier(DELAYED_EXCHANGE) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("order_routing").noargs();
    }
}

编写下单的控制器方法

package com.jjy.yanchirabbitmqdemo.controller;

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @GetMapping("/place2/{orderId}")
    public String placeOrder2(@PathVariable String orderId) {
        System.out.println("处理订单数据...");


        // 设置消息延迟时间为10秒
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setDelay(10000);
                return message;
            }
        };
        // 将订单id发送到订单队列
        rabbitTemplate.convertAndSend("delayed_exchange", "order_routing", orderId, messagePostProcessor);
        return "下单成功，修改库存";
    }

}

编写消费者

package com.jjy.yanchirabbitmqdemo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ExpireOrderConsumer {
    //监听过期订单队列
    @RabbitListener(queues = "expire_queue")
    public void listenMessage(String orderId){
        System.out.println("查询"+orderId+"订单状态，如果已支付无需处理，未支付，回退库存");
    }
    @RabbitListener(queues = "delayed_queue")
    public void listenMessage2(String orderId){
        System.out.println("查询"+orderId+"号订单的状态，如果已支付则无需处理，如果未支付则需要回退库存");
    }

}

三. RabbitMQ集群

在这里插入图片描述
在生产环境中，当单台RabbitMQ服务器无法满足消息的吞吐量及
安全性要求时，需要搭建RabbitMQ集群。

搭建RabbitMQ集群

设置两个RabbitMQ服务

# 关闭RabbitMQ服务
rabbitmqctl stop
# 设置服务一
RABBITMQ_NODE_PORT=5673 RABBITMQ_NODENAME=rabbit1 rabbitmq-server
start -detached
# 设置服务二
RABBITMQ_NODE_PORT=5674 RABBITMQ_SERVER_START_ARGS="-rabbitmq_management listener
[{port,15674}]" RABBITMQ_NODENAME=rabbit2 rabbitmq-server start -detached

将两个服务设置到同一集群中

# 关闭服务2
rabbitmqctl -n rabbit2 stop_app
# 重新设置服务2
rabbitmqctl -n rabbit2 reset
# 将服务2加入服务1中
rabbitmqctl -n rabbit2 join_cluster rabbit1@localhost(自己的主机名)
# 启动服务2
rabbitmqctl -n rabbit2 start_app

这个主机名可以到管控台看
在这里插入图片描述
@后面的就是主机名

镜像队列

在这里插入图片描述

搭建了集群后，虽然多个节点可以互相通信，但队列只保存在了一个节点中，如果该节点故障，则整个集群都将丢失消息。

# 关闭服务1
rabbitmqctl -n rabbit1 stop_app

在这里插入图片描述

此时我们需要引入镜像队列机制，它可以将队列消息复制到集群中的其他节点上。如果一个节点失效了，另一个节点上的镜像可以保证服务的可用性。
在这里插入图片描述

在管此时某个节点故障则不会影响整个集群。控台点击Admin—>Policies设置镜像队列
在这里插入图片描述

Name为镜像策略的名字;Pattern（模式）的值为^，即应用于所有交换机和队列， ^xxx则是应用到以xxx开头交换机和队列。
ha-mode=all则是镜像模式：所有，即将队列镜像到集群的所有服务器中。
ha-sync-mode: automatic设置为自动同步，即当某一服务器宕机，而有新的消息发送到来，当该服务器再次启动后，它已经拿不到该消息了，但是通过设置该参数可以自动同步消息。

负载均衡

在这里插入图片描述

无论是生产者还是消费者，只能连接一个RabbitMQ节点，而在我们使用RabbitMQ集群时，如果只连接一个RabbitMQ节点，会造成该节点的压力过大。我们需要平均的向每个RabbitMQ节点发送请求，此时需要一个负载均衡工具帮助我们分发请求，接下来使用Haproxy做负载均衡：
安装Haproxy：yum -y install haproxy
配置Haproxy：vim /etc/haproxy/haproxy.cfg
添加下面内容

# 以下为修改内容
defaults
        # 修改为tcp
        mode tcp


# 以下为添加内容
listen rabbitmq_cluster
        # 对外暴露端口
     bind 0.0.0.0:5672
     mode tcp
     balance roundrobin
     # 代理RabbitMQ的端口
     server node1 127.0.0.1:5673 check inter 5000 rise 2 fall 2
     server node2 127.0.0.1:5674 check inter 5000 rise 2 fall 2


listen stats
        # Haproxy控制台路径
     bind 自己地址:8100
     mode http
     option httplog
     stats enable
     stats uri /rabbitmq-stats
     stats refresh 5s

访问Haproxy控制台：http://自己地址/rabbitmq-stats
在这里插入图片描述

生产者连接Haproxy发送消息

// 生产者
public class Producer {
  public static void main(String[] args) throws IOException, TimeoutException {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.100");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setVirtualHost("/");


    Connection conn = connectionFactory.newConnection();
    Channel channel = conn.createChannel();
    channel.queueDeclare("simple_queue", false, false, false, null);


    channel.basicPublish("", "simple_queue", null, "hello!rabbitmq!".getBytes());


    channel.close();
    conn.close();
   }
}

总结：

  1. 由Springboot整合RabbitMQ实现通配符模式，通配符模式使用topic交换机，展示消息从生产者到消费者的一个过程。
    生产者由Config配置类+yml配置文件还有发送消息的一个调用操作组成；而消费者由yml配置文件和多个监听指定队列方法的类组成。
    RabbitMQ的Config配置类用来创建交换机、创建队列和将队列绑定到交换机；此时yml配置文件的内容是用来连接RabbitMQ的信息和一些模式的开关。
    模式有确认模式（Confirm），回退模式(Return)，消费者消息确认（Consumer Ack） 三种；前俩种用在生产者，第三种用在消费者。
  • 确认模式是用以消息发送到交换机，此时不论成功或失败都会调用setConfirmCallback返回发送的结果（成功或失败），在失败时打印结果并处理失败的业务，成功时处理成功后的业务。
  • 回退模式则是消息从交换机发到队列的过程，当失败时调用setReturnsCallback方法，输出失败的原因等信息和失败后的处理操作。
  • 消费者消息确认可以设置手动和自动确认，自动确认因消费者监听方法内出现问题或者其他原因会导致消息丢失，所以一般是手动确认，在正常处理后确认签收，在出现异常时捕获异常，处理异常并拒签。
    整个过程总而言之，即从生产者发送消息到指定交换机，交换机再根据生产者给的路由键发送到指定队列，队列再发送到消费者。
  1. 在RabbitMQ的高级属性中，有消费端限流、公平与不公平分发、消息存活时间、优先级队列、死信队列、延迟队列。
  • 消费端限流就是说从队列到消费者的消息，消费者最多只能存在x条未处理的消息。
  • 公平分发就是每个消费者都得到平均分发的消息，一般不设置限流，不公平分发则是处理快的继续处理，没有数额限制，但是需要设置限流且值为1。
  • 消息存活时间可以设置队列消息的存活时间时需要在配置类在创建队列时指定，也可以设置单条消息的存活时间，但是需要在发送消息时创建并添加MessageProperties对象设置存活时间作为参数，俩这都是存活时间一过，消息等到队列顶端后移除。
  • 优先级队列，即需要在创建队列时指定队列的最大优先级，然后在发送消息时创建并添加MessageProperties对象设置优先级数作为参数。
  • 死信队列，即分别创建俩个交换机和俩个队列并将队列绑定到交换机，一个作为死信队列和交换机，一个作为普通队列和交换机，但是普通队列创建时需要绑定死信交换机和死信队列的路由键，并且当普通队列消息过期、拒收并且不重回普通队列、超过普通队列设置的最大消息长度时，将消息发送到死信交换机，死信交换机再发到死信队列，死信队列有专门的消费者进行监听。
  • 延迟队列有2种实现，一种是通过死信队列，设置普通队列的存活时间为延迟的时长，通过死信消费者处理延迟的消息；第二种是通过rabbitmq的延迟队列插件实现延迟队列。

3. RabbitMQ搭建集群及其实现镜像队列、负载均衡

  • 搭建集群就是多个独立的服务器在一个系统中组成一个群体；用以提高系统的可用性、处理能力、响应能力，防止宕机出现数据丢失，和解决服务器无法承受高并发的等问题。
  • 镜像队列就是复制主节点的数据到其他的从节点中，防止因为主节点宕机导致数据丢失。
  • 负载均衡就是将请求访问平均分发到集群的每个节点中，从而提高系统的性能，不会导致某个节点因为访问量过大从而出现系统性能降低或者该节点宕机。

关于RabbitMQ的学习就告一段落了 ，下次就是学习第二个消息中间件RocketMQ

如果我的内容对你有帮助，请点赞，评论，收藏。创作不易，大家的支持就是我坚持下去的动力！
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/382229.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

《CSS 简易速速上手小册》第8章：CSS 性能优化和可访问性（2024 最新版）

《CSS 简易速速上手小册》第8章：CSS 性能优化和可访问性（2024 最新版）

文章目录 8.1 CSS 文件的组织和管理8.1.1 基础知识8.1.2 重点案例&#xff1a;项目样式表结构8.1.3 拓展案例 1&#xff1a;使用BEM命名规范8.1.4 拓展案例 2&#xff1a;利用 Sass 混入创建响应式工具类 8.2 提高网页加载速度的技巧8.2.1 基础知识8.2.2 重点案例&#xff1a;图…
阅读更多...
MySQL-视图（VIEW）

MySQL-视图（VIEW）

文章目录 1. 什么是视图&#xff1f;2. 视图 VS 数据表3. 视图的优点4. 视图相关语法4.1 创建视图4.2 查看视图4.3 修改视图4.4 删除视图4.5 检查选项 5. 案例6. 注意事项 1. 什么是视图&#xff1f; MySQL 视图&#xff08; View&#xff09;是一种虚拟存在的表&#xff0c;同…
阅读更多...
论文笔记：相似感知的多模态假新闻检测

论文笔记：相似感知的多模态假新闻检测

整理了RecSys2020 Progressive Layered Extraction : A Novel Multi-Task Learning Model for Personalized Recommendations&#xff09;论文的阅读笔记 背景模型实验 论文地址&#xff1a;SAFE 背景 在此之前&#xff0c;对利用新闻文章中文本信息和视觉信息之间的关系(相似…
阅读更多...
Java并发基础：LinkedBlockingQueue全面解析！

Java并发基础：LinkedBlockingQueue全面解析！

内容概要 LinkedBlockingQueue类是以链表结构实现高效线程安全队列&#xff0c;具有出色的并发性能、灵活的阻塞与非阻塞操作&#xff0c;以及适用于生产者和消费者模式的能力&#xff0c;此外&#xff0c;LinkedBlockingQueue还具有高度的可伸缩性&#xff0c;能够在多线程环…
阅读更多...
剑指offer——替换空格

剑指offer——替换空格

目录 1. 题目描述与背景1.1 题目描述1.2 背景 2. 一般思路 &#xff08;时间复杂度为O(n)&#xff09;3. 分析4. 完整代码4.1 标准答案 1. 题目描述与背景 1.1 题目描述 请实现一个函数&#xff0c;把字符串中的每个空格替换成 “ %20 ” 。例如&#xff1a;输入“ we are hap…
阅读更多...
【Linux】学习-动静态库

【Linux】学习-动静态库

动静态库 头文件与库的区别 头文件一般而言&#xff0c;是声明和宏定义。头文件是在预处理阶段使用的 库文件是已经编译好的二进制代码。是一种目标文件&#xff0c;库文件是在链接阶段使用的 对于头文件和库我们可以这样理解&#xff0c;就是头文件提供的是一个函数的声明&…
阅读更多...
【5G NR】【一文读懂系列】移动通讯中使用的信道编解码技术-Turbo编码原理

【5G NR】【一文读懂系列】移动通讯中使用的信道编解码技术-Turbo编码原理

目录 Turbo码&#xff1a;无线通信中的革命性技术 引言 一、Turbo码的基本原理 1.1 卷积码基础&#xff1a; 1.2 Turbo码的构造&#xff1a; 1.2.1 分量编码器 1.2.2 随机交织器 1.2.3 穿刺和复接单元 1.3 编码器结构的重要性和影响 1.4 迭代解码&#xff1a; 1.4.1 …
阅读更多...
C#使用RabbitMQ-5_主题模式（主题交换机）

C#使用RabbitMQ-5_主题模式（主题交换机）

简介 主题模式允许发送者根据主题发布消息&#xff0c;而订阅者可以订阅特定的主题。 在主题模式中&#xff0c;生产者发送的消息被发送到一个交换机&#xff08;Exchange&#xff09;&#xff0c;该交换机根据消息的路由键&#xff08;Routing Key&#xff09;和绑定&#x…
阅读更多...
springcloud分布式架构网上商城源码和论文

springcloud分布式架构网上商城源码和论文

首先,论文一开始便是清楚的论述了系统的研究内容。其次,剖析系统需求分析,弄明白“做什么”,分析包括业务分析和业务流程的分析以及用例分析,更进一步明确系统的需求。然后在明白了系统的需求基础上需要进一步地设计系统,主要包罗软件架构模式、整体功能模块、数据库设计。本项…
阅读更多...
React18原理: Fiber架构下的单线程CPU调度策略

React18原理: Fiber架构下的单线程CPU调度策略

概述 React 的 Fiber 架构, 它的整个设计思想就是去参考CPU的调度策略CPU现在都是多核多进程的&#xff0c;重点研究的是 CPU是单核单线程&#xff0c;它是如何调度的?为什么要去研究单线程的CPU&#xff1f; 浏览器中的JS它是单线程的JS 的执行线程和浏览器的渲染GUI 是互斥…
阅读更多...
小兔鲜项目网页版

小兔鲜项目网页版

头部模块 <!-- 头部模块 --><header><!-- 快捷菜单模块 --><div class"xtx-shortcut"><!-- 版心的盒子 --><nav class"container"><ul class"fr"><li><a href"#">请先登录<…
阅读更多...
前端JavaScript篇之对象继承的方式有哪些？

前端JavaScript篇之对象继承的方式有哪些？

目录 对象继承的方式有哪些&#xff1f;1. 原型链继承2. 借用构造函数3. 组合继承4. 原型式继承5. 寄生式组合继承 对象继承的方式有哪些&#xff1f; 1. 原型链继承 当使用原型链继承时&#xff0c;子类型的原型对象被设置为父类型的一个实例。这意味着子类型通过其原型可以…
阅读更多...
Python爬虫——请求库安装

Python爬虫——请求库安装

目录 1.打开Anaconda Prompt 创建环境2.安装resuests3.验证是否安装成功4.安装Selenium5.安装ChromeDriver5.1获取chrom的版本5.1.1点击浏览器右上三个点5.1.2点击设置5.1.3下拉菜单&#xff0c;点击最后关于Chrome&#xff0c;获得其版本 5.2 打开网址 [chromedriver](https:/…
阅读更多...
ADMap：Anti-disturbance framework for reconstructing online vectorized HD map

ADMap：Anti-disturbance framework for reconstructing online vectorized HD map

参考代码&#xff1a;ADMap 动机与出发点 局部地图构建算法在实际中会遇到部分车道线偏离的或是错误的情况&#xff0c;这往往是全局信息获取上存在欠缺&#xff0c;毕竟地图元素的回归很依赖于全局信息的获取。那么从特征提取、attention layer设计和loss构建上可以做一些工作…
阅读更多...
qt-C++笔记之判断一个QLabel上有没有load图片

qt-C++笔记之判断一个QLabel上有没有load图片

qt-C笔记之判断一个QLabel上有没有load图片 code review! 在Qt框架中&#xff0c;QLabel是用来显示文本或者图片的一个控件。如果你想判断一个QLabel控件上是否加载了图片&#xff0c;你可以检查它的pixmap属性。pixmap属性会返回一个QPixmap对象&#xff0c;如果没有图片被加…
阅读更多...
基于springboot广场舞团管理系统源码和论文

基于springboot广场舞团管理系统源码和论文

随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&#xff0c;各行各业相继进入信息管理时代&#xf…
阅读更多...
Linux中常用的工具

Linux中常用的工具

软件安装 yum 软件包 在Linux中&#xff0c;软件包是一种预编译的程序集合&#xff0c;通常包含了用户需要的应用程序、库、文档和其他依赖项。 软件包管理工具是用于安装、更新和删除这些软件包的软件。常见的Linux软件包管理工具包括APT&#xff08;Advanced Packaging To…
阅读更多...
吉他学习：C大调第一把位音阶，四四拍曲目练习 小星星，练习的目的

吉他学习：C大调第一把位音阶，四四拍曲目练习 小星星，练习的目的

第十三课 C大调第一把位音阶https://m.lizhiweike.com/lecture2/29364198 第十四课 四四拍曲目练习 小星星https://m.lizhiweike.com/lecture2/29364131 C大调第一把位音阶非常重要，可以多练习&#x
阅读更多...
耳机壳UV树脂制作耳机壳的工艺流程是什么？

耳机壳UV树脂制作耳机壳的工艺流程是什么？

使用耳机壳UV树脂制作耳机壳的工艺流程如下&#xff1a; 获取耳模&#xff1a;首先&#xff0c;需要获取用户的耳模。这通常是通过使用一种柔软的材料注入到用户的耳朵中&#xff0c;然后取出并用来制作耳机的内芯。选择UV树脂&#xff1a;接下来&#xff0c;需要选择合适的UV…
阅读更多...
二十、K8S-1-权限管理RBAC详解

二十、K8S-1-权限管理RBAC详解

目录 k8s RBAC 权限管理详解 一、简介 二、用户分类 1、普通用户 2、ServiceAccount 三、k8s角色&角色绑定 1、授权介绍&#xff1a; 1.1 定义角色&#xff1a; 1.2 绑定角色&#xff1a; 1.3主体&#xff08;subject&#xff09; 2、角色&#xff08;Role和Cluster…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站