springboot 整合rabbitMq保证消息一致性方案

news2025/1/11 14:20:42

rabbitMq介绍

RabbitMQ是一种开源的消息代理软件，它实现了高级消息队列协议（AMQP）标准，可用于在应用程序之间传递消息。RabbitMQ最初由LShift开发，现在由Pivotal Software维护。
RabbitMQ可以在多个平台上运行，包括Windows、Mac OS X和各种Linux发行版。它提供了多种编程语言的客户端库，如Java、Python、Ruby、.NET等等。RabbitMQ的主要特点包括：

  1. 可靠性：RabbitMQ使用多种机制确保消息传递的可靠性，例如消息确认、持久化和备份机制等。
  2. 灵活性：RabbitMQ支持多种消息传递模式，如点对点、发布/订阅、RPC等，可根据具体应用场景选择适合的模式。
  3. 可扩展性：RabbitMQ可以通过集群方式实现水平扩展，从而提高系统的吞吐量和可用性。
  4. 可插拔性：RabbitMQ支持多种插件，如消息传递追踪、消息转换、限流等，可以根据需要选择使用。
  5. 易用性：RabbitMQ提供了简单易用的管理界面，可用于监控和管理消息队列。同时，它还提供了丰富的文档和社区支持，方便用户学习和使用。

rabbitMq工作原理

在这里插入图片描述
RabbitMQ的工作原理主要包括生产者（Producer）、消息队列（Queue）和消费者（Consumer）三个部分。

  1. 生产者将消息发送到消息队列：生产者将消息发送到RabbitMQ的消息队列中，消息队列会暂时存储这些消息。
  2. 消费者从消息队列中获取消息：消费者可以从消息队列中获取消息，并对这些消息进行处理。
  3. 消费者处理完消息后发送确认：消费者在处理完消息后，向RabbitMQ发送确认信息，表示已经处理完该消息。
  4. RabbitMQ将已确认的消息从队列中移除：当RabbitMQ接收到消费者的确认信息后，会将已经确认的消息从队列中移除，这样其他消费者就不会再次获取到该消息。
    RabbitMQ使用交换机（Exchange）将消息发送到相应的消息队列中。交换机根据特定的路由规则（Routing Key）将消息发送到一个或多个消息队列中

工作模式

  1. 简单模式（Simple Mode）：也称为点对点（Point-to-Point）模式，消息只能被一个消费者消费。生产者将消息发送到队列中，消费者从队列中获取消息并处理，消息处理完后从队列中删除。这种模式下的队列只能有一个消费者。
  2. 发布/订阅模式（Publish/Subscribe Mode）：也称为广播模式（Broadcasting），消息可以被多个消费者消费。生产者将消息发送到交换机中，交换机将消息复制到多个队列中，每个队列对应一个消费者。消费者从队列中获取消息并处理。
  3. 路由模式（Routing Mode）：消息可以根据路由规则（Routing Key）被不同的消费者消费。生产者将消息发送到交换机中，交换机根据消息的路由规则将消息发送到一个或多个队列中，每个队列对应一个消费者。消费者从队列中获取消息并处理。
  4. 主题模式（Topic Mode）：也称为通配符模式（Wildcards），消息可以根据模糊匹配的路由规则被不同的消费者消费。生产者将消息发送到交换机中，交换机根据消息的路由规则和通配符规则将消息发送到一个或多个队列中，每个队列对应一个消费者。消费者从队列中获取消息并处理。

rabbitMq安装

安装步骤如下

  1. 下载 Erlang：RabbitMQ 是基于 Erlang 语言开发的，因此需要先安装 Erlang。Erlang 的下载地址为 https://www.erlang.org/downloads，根据系统类型和版本下载对应的安装程序，然后按照提示进行安装。
  2. 下载 RabbitMQ：RabbitMQ 的下载地址为 https://www.rabbitmq.com/download.html，根据系统类型和版本下载对应的安装程序，然后按照提示进行安装。
  3. 启动 RabbitMQ：在安装完成后，可以通过命令行或者图形化界面启动 RabbitMQ。在 Windows 系统中，可以在开始菜单中找到 RabbitMQ Server，然后选择启动 RabbitMQ Server。在 Linux 或者 Mac 系统中，可以在命令行中输入 rabbitmq-server start 命令来启动 RabbitMQ。
  4. 配置 RabbitMQ：启动 RabbitMQ 后，默认会监听 5672 端口，如果需要更改监听端口、配置虚拟主机、添加用户等操作，可以通过 RabbitMQ 的管理控制台或者命令行来进行配置。
  5. 使用 RabbitMQ：安装和配置完成后，就可以开始使用 RabbitMQ 进行消息传递了。可以选择使用 RabbitMQ 的客户端库或者 AMQP 协议来进行消息传递。

需要注意的是，安装 RabbitMQ 之前需要先安装 Erlang，而且版本要匹配。另外，如果在安装过程中出现问题，可以参考 RabbitMQ 的官方文档或者社区论坛来解决。
安装成功后 访问127.0.0.1:15672 出现登录页面安装成功。

springboot整合RabbitMQ

首先通过idea准备springboot的项目，添加rabbitMQ的依赖

<!-- SpringBoot web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- SpringBoot amqp启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <!-- SpringBoot 测试启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--  数据库连接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--  mybatis 连接-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>

配置rabbitMq如下

spring:
  rabbitmq:   #配置文件
    host: 39.104.177.194  #ip
    port: 5672
    username: admin
    password: daizhihua1996
    virtual-host: /
    connection-timeout: 15000
    publisher-confirm-type: correlated  #开启 confirms 回调  P →  Exchange
    publisher-returns: true  # 开启 returnedMessage 回调 Exchange →  Queue
    template:
      mandatory: true   # 抵达队列异步发送有效回调
    listener:
      simple:
        acknowledge-mode: manual  # 表示消费者消费成功消息以后需要手工的进行签收(ack)，默认为auto
        concurrency: 5   #当前线线程数
        max-concurrency: 10  # 最大线程数
        prefetch: 10
        retry:
          enabled: true
          max-attempts: 5
          max-interval: 10000ms   # 重试最大间隔时间10s
          initial-interval: 2000ms  # 重试初始间隔时间2s
          multiplier: 2 # 间隔时间乘子，间隔时间*乘子=下一次的间隔时间，最大不能超过设置的最大间隔时间，重试时间依次是2s，4s，8s，10s
   

       #消息message
com.acrdpm.smart_topic_queue=smart.queue
com.acrdpm.smart_topic_exchange=smart.exchange
com.acrdpm.smart_topic_routingKey=smart.routing.key

#延迟队列
com.acrdpm.delayed_queue=delayed.queue
com.acrdpm.delayed_exchange=delayed.exchange
com.acrdpm.delayed_routingKey=delayed.routing.key

配置rabbitMq配置文件

@Configuration
@Slf4j
//启用rabbitmQ
@EnableRabbit
@Getter
public class RabbitConfig {

	
    private final RabbitTemplate rabbitTemplate;
	// 将配置文件封装成工具类
    private final RabbitPropertiesConfig rabbitPropertiesConfig;
    // 消息备份类
    private final MsgLogService msgLogService;



    public RabbitConfig(RabbitTemplate rabbitTemplate, RabbitPropertiesConfig rabbitPropertiesConfig, MsgLogService msgLogService) {
        this.rabbitTemplate = rabbitTemplate;
        this.rabbitPropertiesConfig = rabbitPropertiesConfig;
        this.msgLogService = msgLogService;
    }




    /**
     * 定义硬件需要的topic
     * @return
     */
    @Bean
    public Queue smartQueue() {
        return new Queue(rabbitPropertiesConfig.getSmart_topic_queue(), true);
    }

    @Bean
    public TopicExchange smartExchange() {
        return new TopicExchange(rabbitPropertiesConfig.getSmart_topic_exchange(), true, false);
    }

    @Bean
    public Binding smartBinding() {
        return BindingBuilder.bind( smartQueue()).to(smartExchange()).with(rabbitPropertiesConfig.getSmart_topic_routingKey());
    }


    /**
     * 定义延迟队列
     */
    @Bean
    public Queue delayedQueue(){
        return new Queue(rabbitPropertiesConfig.getDelayed_queue());
    }

    @Bean
    public CustomExchange delayedExchange(){
        Map<String, Object> args = new HashMap<>();
        //自定义交换机的类型
        args.put("x-delayed-type", "direct");
        return new CustomExchange(rabbitPropertiesConfig.getDelayed_exchange(), "x-delayed-message", true, false,
                args);
    }

    @Bean
    public Binding bindingDelayedQueue(){
        return BindingBuilder.bind(delayedQueue()).to(delayedExchange()).with(rabbitPropertiesConfig.getDelayed_routingKey()).noargs();
    }




    /**
     * 定制RabbitTemplate
     * 1、服务收到消息就会回调
     * 1、spring.rabbitmq.publisher-confirms: true
     * 2、设置确认回调
     * 2、消息正确抵达队列就会进行回调
     * 1、spring.rabbitmq.publisher-returns: true
     * spring.rabbitmq.template.mandatory: true
     * 2、设置确认回调ReturnCallback
     * <p>
     * 3、消费端确认(保证每个消息都被正确消费，此时才可以broker删除这个消息)
     * MyRabbitConfig对象创建完成以后，执行这个方法
     */
    @PostConstruct
    public void initRabbitTemplate() {

        /**
         * 1、只要消息抵达Broker就ack=true
         * correlationData：当前消息的唯一关联数据(这个是消息的唯一id)
         * ack：消息是否成功收到
         * cause：失败的原因
         */
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            log.info("confirm...correlationData[,{}",correlationData);
            log.info("ack是:{}",ack);
            log.info("case是:{}",cause);
            System.out.println("confirm...correlationData[" + correlationData + "]==>ack:[" + ack + "]==>cause:[" + cause + "]");
            if (ack) {
                log.info("消息成功发送到Exchange");
                String msgId = correlationData.getId();
                msgLogService.updateStatus(msgId, MsgLogStatus.DELIVER_SUCCESS);
            } else {
                log.info("消息发送到Exchange失败, {}, cause: {}", correlationData, cause);
            }
        });

        // 触发setReturnCallback回调必须设置mandatory=true, 否则Exchange没有找到Queue就会丢弃掉消息, 而不会触发回调
        rabbitTemplate.setMandatory(true);
        /**
         * 只要消息没有投递给指定的队列，就触发这个失败回调
         * message：投递失败的消息详细信息
         * replyCode：回复的状态码
         * replyText：回复的文本内容
         * exchange：当时这个消息发给哪个交换机
         * routingKey：当时这个消息用哪个路邮键
         * 修改数据库状态
         */
        rabbitTemplate.setReturnsCallback((returnCallback) -> {
            Message message = returnCallback.getMessage();
            String exchange = returnCallback.getExchange();
            int replyCode = returnCallback.getReplyCode();
            String routingKey = returnCallback.getRoutingKey();
            String replyText = returnCallback.getReplyText();
            if(rabbitPropertiesConfig.getDelayed_exchange().equals(exchange)){
                /**
                 * 使用了x-delayed-message 延迟插件，结果每次都强制触发returnedMessage回调方法
                 * 因为发送方确实没有投递到队列上，只是在交换器上暂存，等过期时间到了 才会发往队列。
                 * 并非是BUG，而是有原因的，所以使用利用if去拦截这个异常，判断延迟队列交换机名称，然后break;
                 */
                log.info("如果是延迟队列那么break");
                return;
            }
            log.info("Fail Message[" + message + "]==>replyCode[" + replyCode + "]" +
                    "==>replyText[" + replyText + "]==>exchange[" + exchange + "]==>routingKey[" + routingKey + "]");

            log.info("消息从Exchange路由到Queue失败: exchange: {}, route: {}, replyCode: {}, replyText: {}, message: {}", exchange,
                    routingKey,replyCode,replyText,message);
            //todo 没有发送到指定的队列 数据暂存到数据库认定消费失败 再次重新上传
        });
    }

}

注意rabbitMq延迟队列需要安装插件，可参考官网

配置日志消息类

@Service
@Slf4j
public class MsgLogService {

    private final MsgLogMapper msgLogMapper;

    public MsgLogService(MsgLogMapper msgLogMapper) {
        this.msgLogMapper = msgLogMapper;
    }

    public void saveMsg(MsgLog msgLog){
        msgLogMapper.insert(msgLog);
    }

    public void updateStatus(String msgId, Integer status) {
        log.info("执行");
        msgLogMapper.updateStatus(msgId,status);
    }


    public MsgLog selectByMsgId(String msgId) {
        if (!ObjectUtils.isEmpty(msgId)){
            return msgLogMapper.seletMsgFormsgId(msgId);
        }
        return null;
    }


    public List<MsgLog> selectTimeoutMsg() {

        return msgLogMapper.selectTimeOutMsg();
    }


    public void updateTryCount(String msgId, Integer tryCount) {
        MsgLog msgLog = new MsgLog();
        msgLog.setMsgId(msgId);
        msgLog.setTryCount(tryCount);
        msgLogMapper.updateByMsgId(msgLog);
    }

}


@Data
@NoArgsConstructor
public class MsgLog {

    private static final long serialVersionUID = 4990197789742500403L;
    private String msgId;

    private JSONObject msg;

    private String exchange;

    private String routingKey;

    private Integer status;

    private Integer tryCount;

    private String nextTryTime;

    private String createTime;

    private String updateTime;

    private String msgCase;


}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cvdmp.dao.MsgLogMapper">

  <insert id="insert" parameterType="com.cvdmp.domain.entity.MsgLog">

    insert into msg_log
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="msgId != null">
        msg_id,
      </if>
      <if test="exchange != null">
        exchange,
      </if>
      <if test="routingKey != null">
        routing_key,
      </if>
      <if test="status != null">
        status,
      </if>
      <if test="tryCount != null">
        try_count,
      </if>
      <if test="nextTryTime != null">
        next_try_time,
      </if>
      <if test="createTime != null">
        create_time,
      </if>
      <if test="updateTime != null">
        update_time,
      </if>
      <if test="msg != null">
        msg,
      </if>
        <if test="msgCase!=null">
          msg_case,
        </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="msgId != null">
        #{msgId,jdbcType=VARCHAR},
      </if>
      <if test="exchange != null">
        #{exchange,jdbcType=VARCHAR},
      </if>
      <if test="routingKey != null">
        #{routingKey,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        #{status,jdbcType=INTEGER},
      </if>
      <if test="tryCount != null">
        #{tryCount,jdbcType=INTEGER},
      </if>
      <if test="nextTryTime != null">
        #{nextTryTime},
      </if>
      <if test="createTime != null">
        #{createTime},
      </if>
      <if test="updateTime != null">
        #{updateTime},
      </if>
      <if test="msg != null">
        #{msg,typeHandler=com.cvdmp.service.handler.JsonObjectTypeHandler},
      </if>
        <if test="msgCase !=null">
          #{msgCase},
        </if>
    </trim>
  </insert>

  <update id="updateStatus" parameterType="map">
    update msg_log set status = #{status}, update_time = now()
    where msg_id = #{msgId}
  </update>

  <select id="selectTimeOutMsg" resultType="com.cvdmp.domain.entity.MsgLog">
    select
    *
    from msg_log
    where status = 0
    and next_try_time &lt;= now()
  </select>
  <select id="seletMsgFormsgId" parameterType="string" resultType="com.cvdmp.domain.entity.MsgLog">
    select
      *
    from msg_log
    where msg_id = #{msgId}
  </select>

  <update id="updateByMsgId" parameterType="com.cvdmp.domain.entity.MsgLog">

    update msg_log
    <set>
      <if test="exchange != null">
        exchange = #{exchange,jdbcType=VARCHAR},
      </if>
      <if test="routingKey != null">
        routing_key = #{routingKey,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        status = #{status,jdbcType=INTEGER},
      </if>
      <if test="tryCount != null">
        try_count = #{tryCount,jdbcType=INTEGER},
      </if>
      <if test="nextTryTime != null">
        next_try_time = #{nextTryTime},
      </if>
      <if test="createTime != null">
        create_time = #{createTime},
      </if>
      <if test="updateTime != null">
        update_time = #{updateTime},
      </if>
      <if test="msg != null">
        msg = #{msg,typeHandler=com.cvdmp.service.handler.JsonObjectTypeHandler},
      </if>
    </set>
    where msg_id = #{msgId,jdbcType=VARCHAR}
  </update>
</mapper>

最后我们定义生产者和消费者


/**
 * mq消息推送策略
 * 1、通过rabbitmq完成消息的推送保证消息推送成功
 * @author daizhihua
 * @time 2023/4/25
 */
@Component(value = "mqStrategy")
public class MqStrategyService {

    private final RabbitConfig rabbitConfig;

    private final MsgLogService msgLogService;

    public MqStrategyService(RabbitConfig rabbitConfig, MsgLogService msgLogService) {
        this.rabbitConfig = rabbitConfig;
        this.msgLogService = msgLogService;
   }


    public void sendMessage(JSONObject map, HttpServletRequest request) {
        RabbitPropertiesConfig rabbitPropertiesConfig = rabbitConfig.getRabbitPropertiesConfig();
        String msgId = RandomUtil.getRandomNumber(32);
        //设置消息id
        map.put("msgId",msgId);
        MsgLog msgLog = new MsgLog();
        msgLog.setMsgId(msgId);
        msgLog.setMsg(map);
        msgLog.setExchange(rabbitPropertiesConfig.getSmart_topic_exchange());
        msgLog.setRoutingKey(rabbitPropertiesConfig.getSmart_topic_routingKey());
        msgLog.setNextTryTime(DateUtil.getNow());
        msgLogService.saveMsg(msgLog);
        //生成消息的唯一id
        CorrelationData correlationData = new CorrelationData(msgId);
        RabbitTemplate rabbitTemplate = rabbitConfig.getRabbitTemplate();
        // 发送消息
        rabbitTemplate.convertAndSend(rabbitPropertiesConfig.getSmart_topic_exchange(),
                rabbitPropertiesConfig.getSmart_topic_routingKey(), map, correlationData);



    }

    /**
     * 发送延迟队列消息
     * @param map
     * @param delayTime
     */
    public void sendMessageDelay(JSONObject map,int delayTime){
        RabbitPropertiesConfig rabbitPropertiesConfig = rabbitConfig.getRabbitPropertiesConfig();
        String msgId = RandomUtil.getRandomNumber(32);
        //设置消息id
        map.put("msgId",msgId);
        MsgLog msgLog = new MsgLog();
        msgLog.setMsgId(msgId);
        msgLog.setMsg(map);
        msgLog.setExchange(rabbitPropertiesConfig.getDelayed_exchange());
        msgLog.setRoutingKey(rabbitPropertiesConfig.getDelayed_routingKey());
        msgLog.setNextTryTime(DateUtil.getNow());
        //生成消息的唯一id
        CorrelationData correlationData = new CorrelationData(msgId);
        RabbitTemplate rabbitTemplate = rabbitConfig.getRabbitTemplate();
        rabbitTemplate.convertAndSend(rabbitPropertiesConfig.getDelayed_exchange(),
                rabbitPropertiesConfig.getDelayed_routingKey(), map, message -> {
                    message.getMessageProperties().setDelay(delayTime);
                    return message;},correlationData);
    }

}

延迟队列的消费

@Slf4j
@Component
@RabbitListener(queues = "${com.acrdpm.delayed_queue}")
public class MessageConsumer {

    private final MqStrategyService mqStrategyService;

    public MessageConsumer(MqStrategyService mqStrategyService) {
        this.mqStrategyService = mqStrategyService;
    }

    @RabbitHandler
    public void consume(Message message, JSONObject map, Channel channel) throws IOException {
        System.out.println("First Queue received msg : " );
        log.info("数据是:{}",map);
        System.out.println(message);
        System.out.println(channel);
        long tag = message.getMessageProperties().getDeliveryTag();
        channel.basicAck(tag, false);

    }

}

订阅消息的消费者

@Slf4j
@Component
@RabbitListener(queues = {"${com.acrdpm.smart_topic_queue}"})
public class SmartConsumer {

    private MsgLogService msgLogService;


    @RabbitHandler
    public void consume(Message message, JSONObject mail, Channel channel) throws IOException {
        log.info("接收到消息了");
        log.info("消息 {}",message);
        log.info("收到的消息是:{}",mail);
        long tag = message.getMessageProperties().getDeliveryTag();
        channel.basicAck(tag, false);

        String msgId = mail.getMsgId();
        MsgLog msgLog = msgLogService.selectByMsgId(msgId);
        if (null == msgLog || msgLog.getStatus().equals(MsgLogStatus.CONSUMED_SUCCESS)) {
            // 消费幂等性：确定不是重复的消息：及消费完成的消息
            log.info("重复消费, msgId: {}", msgId);
            return;
        }
         //获取投送标签
        long tag = message.getMessageProperties().getDeliveryTag();
//        boolean success = false;
//        if (success) {
//            log.info("成功发送消息");
//            msgLogService.updateStatus(msgId, MsgLogStatus.CONSUMED_SUCCESS);
//            // 消费确认手动ack
//            channel.basicAck(tag, false);
//        } else {
//            channel.basicAck(tag, false);
//        }
//        try {
            boolean success = EmailUtil.sendEmail(mail);
//
//        } catch (EmailException e) {
//            log.error("email 发送异常" , e);
//        } catch (IOException e) {
//            log.error("消息处理异常" , e);
//        }

    }
}

在发送消息的过程中，肯定会出现网络异常等情况所以我们定义了发送消息的持久化，为了保证一致性,可参考如下时序图

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机网络笔记：TCP协议 和UDP协议（传输层）

计算机网络笔记：TCP协议 和UDP协议（传输层）

TCP 和 UDP都是传输层协议&#xff0c;他们都属于TCP/IP协议族。 TCP 基本概念 TCP的全称是传输控制协议是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP 是面向连接的、可靠的流协议&#xff08;流就是指不间断的数据结构&#xff09; TCP报文格式 TCP报文是…
阅读更多...
图神经网络：在Cora上动手实现图神经网络

图神经网络：在Cora上动手实现图神经网络

文章说明&#xff1a; 1)参考资料&#xff1a;PYG官方文档。超链。 2)博主水平不高&#xff0c;如有错误还望批评指正。 3)我在百度网盘上传了这篇文章的jupyter notebook。超链。提取码8888。 文章目录 代码实操1&#xff1a;GCN的复杂实现代码实操2&#xff1a;GCN的简单实现…
阅读更多...
C++语言练习题位运算

C++语言练习题位运算

位运算(01)基础 位运算(02)从一个 16 位的单元中取出某几位 题目描述 从一个 16 位的单元中取出某几位&#xff08;即该几位保留原值&#xff0c;其余位为 0. 使用 value 存放该 16 位的数&#xff0c;n1 为欲取出的起始位&#xff0c;n2 为欲取出的结束位。&#xff…
阅读更多...
thinkphp6 JWT报错 ‘“kid“ empty, unable to lookup correct key‘解决办法

thinkphp6 JWT报错 ‘“kid“ empty, unable to lookup correct key‘解决办法

文章目录 JWT简介安装问题先前的代码解决办法修改后的完整代码 JWT简介 JWT全称为Json Web Token&#xff0c;是一种用于在网络应用之间传递信息的简洁、安全的方式。JWT标准定义了一种简洁的、自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。由于它的简洁性、可…
阅读更多...
[论文笔记] In Search of an Understandable Consensus Algorithm (Extended Version)

[论文笔记] In Search of an Understandable Consensus Algorithm (Extended Version)

In Search of an Understandable Consensus Algorithm (Extended Version) 寻找可理解的共识算法 (扩展版) [Extended Paper] [Original Paper] ATC’14 (Original) 摘要 Raft 是一个用于管理复制日志的共识算法. Raft 更易于理解, 且为构建实际的系统提供了更好的基础. Raf…
阅读更多...
apache hive release notes

apache hive release notes

hive release notes位置 https://github.com/apache/hive/blob/master/RELEASE_NOTES.txt 如何查看不同版本的release note
阅读更多...
计算机是如何工作的

计算机是如何工作的

一、冯诺依曼体系&#xff1a; CPU中央处理器&#xff08;运算器控制器&#xff09;&#xff1a;CPU是计算机最核心的部分&#xff0c;进行算数运算和逻辑判断。CPU最重要的指标是“主频”&#xff0c;如&#xff1a;2.5Ghz&#xff0c;描述了CPU的运算速度&#xff0c;可以近…
阅读更多...
【React】redux和React-redux

【React】redux和React-redux

&#x1f380;个人主页&#xff1a;努力学习前端知识的小羊 感谢你们的支持&#xff1a;收藏&#x1f384; 点赞&#x1f36c; 加关注&#x1fa90; Redux和React-redux reduxredux的使用Redux的工作流Redux APIstoreactionreducerstore.dispatch()redux的方法使用 React-Redux…
阅读更多...
python人工智能【隔空手势控制鼠标】“解放双手“

python人工智能【隔空手势控制鼠标】“解放双手“

大家好&#xff0c;我是csdn的博主&#xff1a;lqj_本人 这是我的个人博客主页&#xff1a; lqj_本人的博客_CSDN博客-微信小程序,前端,python领域博主lqj_本人擅长微信小程序,前端,python,等方面的知识https://blog.csdn.net/lbcyllqj?spm1011.2415.3001.5343哔哩哔哩欢迎关注…
阅读更多...
【计算机图形学基础教程】MFC上机操作步骤

【计算机图形学基础教程】MFC上机操作步骤

MFC上机操作步骤 步骤1 在Visual Studio界面&#xff0c;选择文件-新建-项目&#xff1a; 步骤2 在新建项目对话框&#xff0c;选择MFC-MFC应用程序&#xff1a; 步骤3 创建一个带有下列特征的新控制台工程框架&#xff0c;主要内容如下&#xff1a; 基于Win32的单文档…
阅读更多...
PMP/高项 05-项目进度管理

PMP/高项 05-项目进度管理

项目进度管理 概念 项目进度管理&#xff08;Schedule Management) 项目进度管理又叫项目工期管理&#xff08;Duration Management)或项目的时间管理(Time Management) 是一种为管理项目按时完成项目所需的各个过程 进度管理过程 规划进度管理 定义活动 排列活动顺序 估算活…
阅读更多...
前端web3入门脚本五：decode input data

前端web3入门脚本五：decode input data

一、前言 作为一个前端&#xff0c;在调用合约调试的时候&#xff0c;在区块浏览器里拿到一串 hex 格式的 input data&#xff0c;我们应该怎么decode呢&#xff1f; 二、举例 解码交易需要拥有 对应合约的 abi 以及 input data 下面举例介绍怎么获得这两个信息&#xff1a; 参…
阅读更多...
二叉搜索树中的众数

二叉搜索树中的众数

1题目 给你一个含重复值的二叉搜索树&#xff08;BST&#xff09;的根节点 root &#xff0c;找出并返回 BST 中的所有 众数&#xff08;即&#xff0c;出现频率最高的元素&#xff09;。 如果树中有不止一个众数&#xff0c;可以按 任意顺序 返回。 假定 BST 满足如下定义&…
阅读更多...
存储资源调优技术——智能缓存分区

存储资源调优技术——智能缓存分区

SmartPratition智能缓存分区 基本概念 本质上就是一种Cache分区技术 通过对系统核心资源的分区&#xff08;隔离不同业务所需要的缓存资源&#xff09;&#xff0c;保证关键应用的性能 工作原理 用户可以以LUN或文件系统为单位设置SmartPartition分区 每个SmartPartition分区的…
阅读更多...
Qt文件系统源码分析—第二篇QSaveFile

Qt文件系统源码分析—第二篇QSaveFile

范围 深度 首先指定深度分析深度&#xff0c;否者会陷入代码海洋之中。 本文只分析到Win32 API/Windows Com组件/STL库函数层次&#xff0c;再下层代码不做探究 本文主要了解QSaveFile及其具体实现&#xff0c;使用到父类数据的地方只讨论关键点 QT Private类 大部分Qt类有…
阅读更多...
基础篇-设计模式

基础篇-设计模式

单例模式&#xff1a; 注意&#xff1a;这里的唯一实例不是使用时候才创建,而是构造时候就会创建; 注意&#xff1a;提前创建了对象&#xff0c;并不是调用时候才创建 解决方法&#xff1a; 枚举饿汉单例&#xff1a; 注意: 饿汉式枚举不会通过反序列化破坏单例 懒汉模式&…
阅读更多...
SQL笔记（3）——MySQL数据类型

SQL笔记（3）——MySQL数据类型

学习MySQL&#xff0c;通常应该是先学习数据类型的&#xff0c;因为不管是开发还是MySQL中&#xff0c;每个数据对象都有其对应的数据类型&#xff0c;MySQL提供了丰富的数据类型&#xff0c;如在创建表的时候就需要指定列的数据类型&#xff0c;在向表中插入数据时&#xff0c…
阅读更多...
ElasticSearch（一）下载及安装（windows）

ElasticSearch（一）下载及安装（windows）

1. 官网 ElasticSearch官网地址ElasticSearch生态组件下载地址Kibana下载地址ik中文分词插件 备注&#xff1a;网址打不开&#xff0c;或者打开速度慢是正常情况。 2. 解压后目录结构 bin &#xff1a;脚本文件&#xff0c;包括启动elasticsearch&#xff0c;安装插件&#…
阅读更多...
目录打开显示提示文件或目录损坏且无法读取、文件或目录损坏且无法读取的破解之道

目录打开显示提示文件或目录损坏且无法读取、文件或目录损坏且无法读取的破解之道

咱们在平日工作时&#xff0c;通常都会将资料放进不同的目录中&#xff0c;方便咱们找到&#xff0c;随着时间的推移就会产生有越来越多目录。最近有位用户了这样一个问题&#xff0c;就是目录无论怎么都无法打开&#xff0c;这样就无法浏览、使用里面的资料了&#xff0c;影响…
阅读更多...
springboot sharding-jdbc 主从 读写分离

springboot sharding-jdbc 主从 读写分离

目录 1 mysql 主从搭建 1.1 docker mysql 主从搭建 1.2 非docker mysql 主从搭建 2 springboot sharding-jdbc 主从 读写分离 2.1 pom 加依赖 2.1 yml 配置文件 3 测试 -> 直接使用 就是读写分离 3.1 实体类User -> 数据字段 对象字典 3.2 Mapper -> 增删改查…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023