RocketMq使用示例

已于 2025-04-23 13:34:41 修改
阅读量409 收藏 9
点赞数 8
文章标签： java android 数据库
于 2025-04-23 11:09:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43076660/article/details/147444353
版权

以下是根据你提供的 RocketProducer 和 BaseMessage 封装的 多场景测试代码，包含不同 Topic 的生产者调用和对应的消费者监听实现，代码中会覆盖所有发送方式
在这里插入图片描述

public class RocketProducer {
    @Generated
    private static final Logger log = LoggerFactory.getLogger(RocketProducer.class);
    private final RocketMQTemplate rocketMQTemplate;

    public RocketProducer(RocketMQTemplate rocketMQTemplate) {
        this.rocketMQTemplate = rocketMQTemplate;
    }

    public SendMsgResult send(String topic, BaseMessage message) {
        return this.send(topic, (String)null, message);
    }

    public SendMsgResult send(String topic, String tag, BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSend(this.buildDest(topic, tag), sendMessage);
        log.info("send message end({})! messageId:{}, topic:{}, tag:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, tag, JacksonUtil.obj2String(message)});
        return this.convertMsgResult(sendResult);
    }

    public void sendAsync(final String topic, final BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSend(topic, sendMessage, new SendCallback() {
            public void onSuccess(SendResult sendResult) {
                RocketProducer.log.info("send message end({})!  messageId:{}, topic:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, JacksonUtil.obj2String(message)});
            }

            public void onException(Throwable e) {
                RocketProducer.log.info("send message failed!!! topic:{}, message:{}, errorMessage:{}, errorStack:{}", new Object[]{topic, JacksonUtil.obj2String(message), e.getMessage(), JacksonUtil.obj2String(e.getStackTrace())});
            }
        });
    }

    public void sendAsync(final String topic, final String tag, final BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSend(this.buildDest(topic, tag), sendMessage, new SendCallback() {
            public void onSuccess(SendResult sendResult) {
                RocketProducer.log.info("send message end({})! messageId:{}, topic:{}, tag:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, tag, JacksonUtil.obj2String(message)});
            }

            public void onException(Throwable e) {
                RocketProducer.log.info("send message failed!!! topic:{}, tag:{}, message:{}", new Object[]{topic, tag, JacksonUtil.obj2String(message)});
            }
        });
    }

    public void sendAsync(String topic, BaseMessage message, SendCallback callback) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSend(topic, sendMessage, callback);
        log.info("async send message end! topic:{}, message:{}", topic, JacksonUtil.obj2String(message));
    }

    public SendMsgResult sendDelay(String topic, BaseMessage message, int delayLevel, long timeout) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSend(topic, sendMessage, timeout, delayLevel);
        log.info("send delay message end({})! messageId:{}, topic:{}, delayLevel:{}, timout:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, delayLevel, timeout, message});
        return this.convertMsgResult(sendResult);
    }

    public void sendDelayAsync(final String topic, final BaseMessage message, final int delayLevel, final long timeout) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSend(topic, sendMessage, new SendCallback() {
            public void onSuccess(SendResult sendResult) {
                RocketProducer.log.info("send delay message end({})! messageId:{}, topic:{}, delayLevel:{}, timout:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, delayLevel, timeout, message});
            }

            public void onException(Throwable throwable) {
                RocketProducer.log.info("send message failed!!! topic:{}, message:{}", topic, JacksonUtil.obj2String(message));
            }
        }, timeout, delayLevel);
    }

    public SendMsgResult sendDelayTimeMills(String topic, BaseMessage message, long delayTime) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSendDelayTimeMills(topic, sendMessage, delayTime);
        log.info("send delay message end({})! messageId:{}, topic:{}, delayTime:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, delayTime, message});
        return this.convertMsgResult(sendResult);
    }

    public SendMsgResult sendDelayTimeMills(String topic, String tag, BaseMessage message, long delayTime) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSendDelayTimeMills(this.buildDest(topic, tag), sendMessage, delayTime);
        log.info("send delay message end({})! messageId:{}, topic:{}, delayTime:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, delayTime, message});
        return this.convertMsgResult(sendResult);
    }

    public void sendOrderly(String topic, String hashKey, BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSendOrderly(topic, sendMessage, hashKey);
        log.info("send orderly message end({})! messageId:{}, topic:{}, message:{}, hashKey:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, message, hashKey});
    }

    public void sendOrderly(String topic, String tag, String hashKey, BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.syncSendOrderly(this.buildDest(topic, tag), sendMessage, hashKey);
        log.info("send orderly message end({})! messageId:{}, topic:{}, tag:{} message:{}, hashKey:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, tag, message, hashKey});
    }

    public void asyncSendOrderly(String topic, BaseMessage message, String hashKey, SendCallback sendCallback) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSendOrderly(topic, sendMessage, hashKey, sendCallback, 0L, 0);
        log.info("send asyncSendOrderly message topic:{}, message:{}, hashKey:{} ", new Object[]{topic, message, hashKey});
    }

    public void asyncSendOrderly(String topic, String tag, BaseMessage message, String hashKey, SendCallback sendCallback) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.asyncSendOrderly(this.buildDest(topic, tag), sendMessage, hashKey, sendCallback, 0L, 0);
        log.info("send asyncSendOrderly message topic:{}, message:{}, hashKey:{} ", new Object[]{topic, message, hashKey});
    }

    public void sendOneWay(String topic, BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.sendOneWay(topic, sendMessage);
        log.info("send sendOneWay message topic:{}, message:{}", topic, message);
    }

    public void sendOneWayOrderly(String topic, BaseMessage message, String hashKey) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.sendOneWayOrderly(topic, sendMessage, hashKey);
        log.info("send sendOneWay message topic:{}, message:{} hashKey{}", new Object[]{topic, message, hashKey});
    }

    public void sendBroadcast(String topic, BaseMessage message) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        this.rocketMQTemplate.convertAndSend(topic, sendMessage);
        log.info("send broadcast message end! topic:{}, message:{}", topic, message);
    }

    private String buildDest(String topic, String tag) {
        StringBuilder dest = new StringBuilder((String)Objects.requireNonNull(topic));
        if (StringUtils.hasLength(tag)) {
            dest.append(":").append(tag);
        }

        return dest.toString();
    }

    private Message<BaseMessage> putMessage(BaseMessage message) {
        MessageBuilder<BaseMessage> baseMessageMessageBuilder = MessageBuilder.withPayload(message);
        String traceId = message.getTraceId();

        try {
            traceId = TraceUtil.getTraceId();
            if (StringUtils.hasText(traceId)) {
                message.setTraceId(traceId);
            }
        } catch (Throwable var5) {
        }

        baseMessageMessageBuilder.setHeader("traceId", traceId);
        return baseMessageMessageBuilder.build();
    }

    private SendMsgResult convertMsgResult(SendResult sendResult) {
        return SendMsgResult.builder().sendStatus(sendResult.getSendStatus()).msgId(sendResult.getMsgId()).offsetMsgId(sendResult.getOffsetMsgId()).queueId(sendResult.getMessageQueue().getQueueId()).queueOffset(sendResult.getQueueOffset()).topic(sendResult.getMessageQueue().getTopic()).build();
    }

    /** @deprecated */
    @Deprecated
    public SendMsgResult sendMessageInTransaction(String topic, BaseMessage message, Object arg) {
        Message<BaseMessage> sendMessage = this.putMessage(message);
        SendResult sendResult = this.rocketMQTemplate.sendMessageInTransaction(topic, sendMessage, arg);
        log.info("send delay message end({})! messageId:{}, topic:{}, delayLevel:{}, timout:{}, message:{}", new Object[]{sendResult.getSendStatus(), sendResult.getMsgId(), topic, arg, message});
        return this.convertMsgResult(sendResult);
    }
}


public class BaseMessage implements Serializable {
    private static final long serialVersionUID = 5708121021148373786L;
    protected LocalDateTime sendTime = LocalDateTime.now();
    protected String traceId = UUID.randomUUID().toString();

    @Generated
    public BaseMessage() {
    }

    @Generated
    public LocalDateTime getSendTime() {
        return this.sendTime;
    }

    @Generated
    public String getTraceId() {
        return this.traceId;
    }

    @Generated
    public void setSendTime(LocalDateTime sendTime) {
        this.sendTime = sendTime;
    }

    @Generated
    public void setTraceId(String traceId) {
        this.traceId = traceId;
    }

    @Generated
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof BaseMessage)) {
            return false;
        } else {
            BaseMessage other = (BaseMessage)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$sendTime = this.getSendTime();
                Object other$sendTime = other.getSendTime();
                if (this$sendTime == null) {
                    if (other$sendTime != null) {
                        return false;
                    }
                } else if (!this$sendTime.equals(other$sendTime)) {
                    return false;
                }

                Object this$traceId = this.getTraceId();
                Object other$traceId = other.getTraceId();
                if (this$traceId == null) {
                    if (other$traceId != null) {
                        return false;
                    }
                } else if (!this$traceId.equals(other$traceId)) {
                    return false;
                }

                return true;
            }
        }
    }

    @Generated
    protected boolean canEqual(Object other) {
        return other instanceof BaseMessage;
    }

    @Generated
    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $sendTime = this.getSendTime();
        result = result * 59 + ($sendTime == null ? 43 : $sendTime.hashCode());
        Object $traceId = this.getTraceId();
        result = result * 59 + ($traceId == null ? 43 : $traceId.hashCode());
        return result;
    }

    @Generated
    public String toString() {
        LocalDateTime var10000 = this.getSendTime();
        return "BaseMessage(sendTime=" + var10000 + ", traceId=" + this.getTraceId() + ")";
    }
}
  1. 生产者测试类
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class RocketMQProducerTest {

    @Autowired
    private RocketProducer rocketProducer;

    // 同步发送测试
    @Test
    public void testSyncSend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.send("SYNC_TOPIC", "SYNC_TAG", message);
    }

    // 异步发送测试
    @Test
    public void testAsyncSend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.sendAsync("ASYNC_TOPIC", "ASYNC_TAG", message);
        // 等待异步回调完成
        try { Thread.sleep(3000); } catch (InterruptedException e) {}
    }

    // 延迟发送（级别）测试
    @Test
    public void testDelayLevelSend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.sendDelay("DELAY_LEVEL_TOPIC", message, 3, 3000); // 延迟级别3（约10秒）
    }

    // 延迟发送（毫秒）测试
    @Test
    public void testDelayMsSend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.sendDelayTimeMills("DELAY_MS_TOPIC", "DELAY_TAG", message, 5000); // 延迟5秒
    }

    // 顺序发送测试
    @Test
    public void testOrderlySend() {
        BaseMessage message = new BaseMessage();
        String hashKey = "order_123"; // 同一订单号确保进入同一队列
        rocketProducer.sendOrderly("ORDERLY_TOPIC", "ORDERLY_TAG", hashKey, message);
    }

    // 单向发送测试
    @Test
    public void testOneWaySend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.sendOneWay("ONEWAY_TOPIC", message);
    }

    // 广播发送测试
    @Test
    public void testBroadcastSend() {
        BaseMessage message = new BaseMessage();
        rocketProducer.sendBroadcast("BROADCAST_TOPIC", message);
    }
}
  1. 消费者监听类
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

// 同步消息消费者
@Component
@RocketMQMessageListener(topic = "SYNC_TOPIC", selectorExpression = "SYNC_TAG", consumerGroup = "SYNC_GROUP")
public class SyncConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[同步消息] 接收消息: " + message.getTraceId());
    }
}

// 异步消息消费者
@Component
@RocketMQMessageListener(topic = "ASYNC_TOPIC", selectorExpression = "ASYNC_TAG", consumerGroup = "ASYNC_GROUP")
public class AsyncConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[异步消息] 接收消息: " + message.getTraceId());
    }
}

// 延迟消息消费者（级别）
@Component
@RocketMQMessageListener(topic = "DELAY_LEVEL_TOPIC", selectorExpression = "DELAY_TAG", consumerGroup = "DELAY_LEVEL_GROUP")
public class DelayLevelConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[延迟消息-级别] 接收消息: " + message.getTraceId() + " | 发送时间: " + message.getSendTime());
    }
}

// 延迟消息消费者（毫秒）
@Component
@RocketMQMessageListener(topic = "DELAY_MS_TOPIC", selectorExpression = "DELAY_TAG", consumerGroup = "DELAY_MS_GROUP")
public class DelayMsConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[延迟消息-毫秒] 接收消息: " + message.getTraceId() + " | 发送时间: " + message.getSendTime());
    }
}

// 顺序消息消费者
@Component
@RocketMQMessageListener(topic = "ORDERLY_TOPIC", selectorExpression = "ORDERLY_TAG", consumerGroup = "ORDERLY_GROUP", consumeMode = ConsumeMode.ORDERLY)
public class OrderlyConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[顺序消息] 接收消息: " + message.getTraceId());
    }
}

// 单向消息消费者
@Component
@RocketMQMessageListener(topic = "ONEWAY_TOPIC", selectorExpression = "ONEWAY_TAG", consumerGroup = "ONEWAY_GROUP")
public class OneWayConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[单向消息] 接收消息: " + message.getTraceId());
    }
}

// 广播消息消费者（启动多个实例测试广播效果）
@Component
@RocketMQMessageListener(topic = "BROADCAST_TOPIC", selectorExpression = "BROADCAST_TAG", consumerGroup = "BROADCAST_GROUP", messageModel = MessageModel.BROADCASTING)
public class BroadcastConsumer implements RocketMQListener<BaseMessage> {
    @Override
    public void onMessage(BaseMessage message) {
        System.out.println("[广播消息] 接收消息: " + message.getTraceId() + " | 实例ID: " + this.hashCode());
    }
}
  1. 关键配置说明
rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: TEST_PRODUCER_GROUP
  consumer:
    # 不同消费者组需单独配置
    SYNC_GROUP:
      message-model: CLUSTERING
    ASYNC_GROUP:
      message-model: CLUSTERING
    DELAY_LEVEL_GROUP:
      message-model: CLUSTERING
    DELAY_MS_GROUP:
      message-model: CLUSTERING
    ORDERLY_GROUP:
      message-model: CLUSTERING
    ONEWAY_GROUP:
      message-model: CLUSTERING
    BROADCAST_GROUP:
      message-model: BROADCASTING

5 这个验证逻辑看起来很完整，包含了不同情况下对消息发送和接收的验证步骤。以下是对每个验证步骤的简要解释：

  1. 同步/异步发送：验证生产者发送消息时是同步还是异步的方式。通过观察控制台日志，确保消息发送成功并且消费者正确接收到消息。

  2. 延迟发送：检查消息接收时间是否与设置的延迟时间一致。例如，如果设置了5秒的延迟时间，确保消息在5秒后被消费者接收。

  3. 顺序发送：发送多个带有相同 hashKey 的消息，确保消费者能够单线程按顺序处理这些消息，而不会乱序处理。

  4. 广播发送：启动多个消费者实例，验证所有实例都能收到同一条消息。这种情况下，消息应该被广播给所有消费者实例，而不是仅发送给其中一个。

6 为了确保顺序消息的正确消费，以下是一些注意事项：

  1. 在使用RocketMQ时，确保所有的Topic都在RocketMQ控制台中预先创建。这样可以确保消息发送和消费的顺利进行。

  2. 对于需要按顺序消费的消息，消费者需要设置consumeMode为ConsumeMode.ORDERLY。这可以确保消息按照顺序进行处理。

  3. 如果使用广播模式发送消息，建议启动多个消费者实例来观察是否所有消息都能被接收。这样可以验证消息的广播是否正常工作。

RocketMQ开发指导之三——RocketMQ编程示例_rocketmq c++
2401_89285746的博客
12-08 678
说明：生产环境代码使用的 rocketmq 的头文件及库文件的位置，需要根据实际情况存放。本文中是直接使用 rocketmq-client-cpp 源码包中的头文件及库文件。从 GitHub 上下载并解压 rocketmq-client-cpp 源码包，链接为。从上述结果能够看到，生产者程序成功地生产（向消息队列中发送）了 10 条消息。执行下列操作，安装 rocketmq-client-cpp。这里给出两个简单的生产者和消费者的示例代码。
python使用rocketmq发送消息_阿里云消息队列RocketMQ使用示例
weixin_39953481的博客
12-14 1598
本文代码示例参见：https://gitee.com/imlichao/RocketMQ-exampleApache RocketMQ文档：http://rocketmq.apache.org/docs/quick-start/阿里云RocketMQ文档：https://help.aliyun.com/product/29530.html简介消息队列 RocketMQ 是阿里巴巴集团自主研发的专...
RocketMq使用简单案例
每天进步一点点
06-14 552
Spring boot 集成RocketMq简单使用案例
阿里云消息队列RocketMQ使用示例
weixin_34327761的博客
05-09 4293
2019独角兽企业重金招聘Python工程师标准>>> ...
RocketMQ使用
Chocolyte的博客
02-06 870
RocketMQ是一款分布式、队列模型的消息中间件，由阿里巴巴团队研发，借鉴参考了 JMS 规范的MQ实现（如 activeMQ），更参考了优秀的开源消息中间件kafka，具有低延迟，高性能和可靠性。
RocketMQ 使用入门案例
冒险的梦想家的博客~
02-01 2690
SpringCloud Alibaba RocketMQ RocketMQ概述 RocketMQ是一款由阿里研发的高性能高可靠性的分布式消息队列，使用Java语言开发，该项目已经贡献给了Apache基金会，成为Apache的顶级开源项目。 在早期，阿里内部使用ActiveMQ作为其消息传递中间件，随着业务的快速增长，基于ActiveMQ的消息队列集群在处理大规模业务吞吐量时会遇到IO等性能瓶颈，阿里研发团队曾努力优化ActiveMQ，但无奈效果不理想，紧接着他们将目光投向Kafka，不幸的是Kafka并不能
SpringBoot整合RocketMQ入门示例
wangxi06的专栏
04-07 473
RocketMQ主要由 Producer、Broker、Consumer 三部分组成，其中Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。 作者：FastCoder来源：今日头条 环境：springboot2.3.9 + RocketMQ4.8.0 RocketMQ机构及概念 1 消息模型(Message Model) RocketMQ主要由 Producer、Broker、Consumer 三部分组成，其中Producer 负责生产...
RocketMQ-代码示例
姜希成的博客
09-09 338
【代码】RocketMQ-代码示例。
springboot集成rocketmq的示例代码
weixin_42594143的博客
11-06 447
SpringBoot集成RocketMQ可以通过使用spring-boot-starter-rocketmq或者rocketmq-spring-boot-starter等第三方启动器来简化配置。以下是一个使用rocketmq-spring-boot-starter的示例代码，展示如何在SpringBoot项目中集成RocketMQ。如果你使用的是远程的RocketMQ集群，请替换为相应的地址。请注意，上述示例是一个简单的演示，实际生产环境中可能需要更多的配置和处理，比如错误处理、消息重试、幂等性处理等。
RocketMQ入门示例-生产者
money9sun的博客
11-03 219
大家好，本文主要是按照官网的教程把消费者和生产者的示例写下来，开箱即用。
SpringBoot集成RocketMQ示例代码
09-14
在SpringBoot与RocketMQ集成的示例代码中，src目录下会包含几个关键部分。首先是主程序入口，标注了@SpringBootApplication注解的主类，它是整个SpringBoot应用的起点。然后是配置类，可能会用到@EnableRocketMQ注解...
Spring框架下RocketMq使用示例教程
标题中提到的 "RocketMq + Spring 示例" 暗示了本文件集合是关于如何在Spring框架中使用Apache RocketMQ消息中间件的一个实例教程。RocketMQ是一个分布式、高可用性、可靠的消息中间件，常用于构建分布式应用的消息...
2024年RocketMQ开发指导之三——RocketMQ编程示例_rocketmq c++，2024年最新已整理成文档
2401_84973733的博客
05-13 464
从上述结果能够看到，生产者程序成功地生产（向消息队列中发送）了 10 条消息。
RocketMQ（二）RocketMQ实战
HK的博客
12-29 1293
RocketMQ的实际使用
多租户 SaaS 系统中的租户隔离与连接池重建机制设计方案
nbsaas-boot基于Request-Response的企业级快速开发框架
04-22 1132
租户隔离 + 动态连接池管理 = SaaS 系统的核心能力。支持连接配置热更新（更改连接地址、密码后自动重建）租户数量大（上百/上千），无法全量预加载连接池。连接池不能长期缓存冷租户，需有缓存淘汰策略。支持租户动态接入（注册后立即生效）判断连接池上次使用时间（可封装。或自定义 Watcher 实现。不支持运行时动态切换或新增。，保证数据安全与性能隔离。在拦截器或网关处设置。每 30 分钟遍历缓存。超过1小时未访问 →。可结合 Spring。
BigDecimal类详解
沉梦听雨的博客
04-21 1470
在 Java 编程中，处理浮点数时经常会遇到精度问题。为了解决这个问题，Java 提供了一个BigDecimal类，它提供了精确的浮点数运算。本文将详细介绍BigDecimal类的使用方法和一些常见场景。
查看Spring Boot项目所有配置信息的几种方法，包括 Actuator端点、日志输出、代码级获取 等方式，附带详细步骤和示例
最新发布
爱的叹息的专栏
04-22 809
查看Spring Boot项目所有配置信息的几种方法，包括 Actuator端点、日志输出、代码级获取 等方式，附带详细步骤和示例
【Redis】SpringDataRedis
2302_79952574的博客
04-21 593
Spring Data Redis 使得开发者能够更容易地与 Redis 数据库进行交互，并且支持不同的 Redis 客户端实现，如和。Spring Data Redis 会自动选择一个客户端，通常情况下，Spring Boot 默认使用作为 Redis 客户端。你也可以选择使用。
使用标准 JDK 编译和运行 Java 程序
静水深流
04-21 785
CLASSPATH 是一个环境变量，指定 Java 编译器和 JVM 查找用户定义类和包的路径。它可以包含目录、JAR 文件或 ZIP 文件。引导类：Java 平台核心类，位于rt.jar。扩展类：位于 JRE 的扩展目录（如用户类：通过 CLASSPATH 或默认类路径加载。如果程序引用了其他目录或 JAR 文件中的类，需设置 CLASSPATH。命令行选项：使用-cp或-classpathjava -cp .;Windows 使用分号（;），Linux/macOS 使用冒号（:）分隔路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@淡 定

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值