SpringBoot(7)消息处理

最新推荐文章于 2023-11-06 16:44:54 发布
最新推荐文章于 2023-11-06 16:44:54 发布
阅读量700 收藏 1
点赞数
分类专栏： spring boot 文章标签： spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43994244/article/details/130066173
版权

消息处理

消息

对于消息的生产者与消费者的工作模式，还可以将消息划分成两种模式，同步消费与异步消息。

同步消息就是生产者发送完消息，等待消费者处理，消费者处理完将结果告知生产者，然后生产者继续向下执行业务。这种模式过于卡生产者的业务执行连续性，在现在的企业级开发中，上述这种业务场景通常不会采用消息的形式进行处理。

异步消息就是生产者发送完消息，无需等待消费者处理完毕，生产者继续向下执行其他动作。比如生产者发送了一个日志信息给日志系统，发送过去以后生产者就向下做其他事情了，无需关注日志系统的执行结果。日志系统根据接收到的日志信息继续进行业务执行，是单纯的记录日志，还是记录日志并报警，这些和生产者无关，这样生产者的业务执行效率就会大幅度提升。并且可以通过添加多个消费者来处理同一个生产者发送的消息来提高系统的高并发性，改善系统工作效率，提高用户体验。一旦某一个消费者由于各种问题宕机了，也不会对业务产生影响，提高了系统的高可用性。

Java处理消息的标准规范

目前企业级开发中广泛使用的消息处理技术共三大类，具体如下：

JMS

JMS（Java Message Service）： 这是一个规范，作用等同于JDBC规范，提供了与消息服务相关的API接口。

JMS规范中规范了消息有两种模型。分别是点对点模型和发布订阅模型。

  • 点对点模型：peer-2-peer，生产者会将消息发送到一个保存消息的容器中，通常使用队列模型，使用队列保存消息。一个队列的消息只能被一个消费者消费，或未被及时消费导致超时。这种模型下，生产者和消费者是一对一绑定的。
  • 发布订阅模型：publish-subscribe，生产者将消息发送到一个保存消息的容器中，也是使用队列模型来保存。但是消息可以被多个消费者消费，生产者和消费者完全独立，相互不需要感知对方的存在。

以上分类是从消息的生产和消费过程来进行区分，针对消息所包含的信息不同，还可以进行不同类别的划分。

JMS消息种类： 根据消息中包含的数据种类划分，可以将消息划分成6种消息。
TextMessage，MapMessage，BytesMessage ，StreamMessage，ObjectMessage，Message （只有消息头和属性）

JMS实现： ActiveMQ、Redis、HornetMQ (RabbitMQ、RocketMQ没有完全满足其规范)

JMS在使用过程中开始被人诟病，原因在于JMS的设计是J2EE规范，站在Java开发的角度思考问题。但是现实往往是复杂度很高的。比如有一个.NET开发的系统A，有一个Java开发的系统B，现在要从A系统给B系统发业务消息，结果两边数据格式不统一，没法操作。JMS不是可以统一数据格式吗？提供了6种数据种类，总有一款适合的。NO，一个都不能用。因为A系统的底层语言不是Java语言开发的，根本不支持那些对象。这就意味着如果想使用现有的业务系统A继续开发已经不可能了，必须推翻重新做使用Java语言开发的A系统。

AMQP

AMQP（advanced message queuing protocol）： 一种协议（高级消息队列协议，也是消息代理规范），规范了网络交换的数据格式，兼容JMS
优点： 具有跨平台性，服务器供应商，生产者，消费者可以使用不同的语言来实现
AMQP消息种类： byte[]
AMQP消息模型： direct exchange，fanout exchange，topic exchange，headers exchange，system exchange
AMQP实现： RabbitMQ、StormMQ、RocketMQ

MQTT

MQTT（Message Queueing Telemetry Transport）： 消息队列遥测传输，专为小设备设计，是物联网（IOT）生态系统中主要成分之一。由于与JavaEE企业级开发没有交集，此处不作过多的说明。

kafka

Kafka，一种高吞吐量的分布式发布订阅消息系统，提供实时消息功能。Kafka技术并不是作为消息中间件为主要功能的产品，但是其拥有发布订阅的工作模式，也可以充当消息中间件来使用，而且目前企业级开发中其身影也不少见。

案例准备

手机验证码案例需求如下：

  • 执行下单业务时（模拟此过程），调用消息服务，将要发送短信的订单id传递给消息中间件
  • 消息处理服务接收到要发送的订单id后输出订单id（模拟发短信）

由于不涉及数据读写，仅开发业务层与表现层，其中短信处理的业务代码独立开发，代码如下：

订单业务层接口：

public class OrderServiceImpl implements OrderService {
    @Autowired
    private MessageService messageService;
    
    @Override
    public void order(String id) {
        //一系列操作，包含各种服务调用，处理各种业务
        System.out.println("订单处理开始");
        //短信消息处理
        messageService.sendMessage(id);
        System.out.println("订单处理结束");
        System.out.println();
    }
}

订单表现层

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("{id}")
    public void order(@PathVariable String id){
        orderService.order(id);
    }
}

短信处理业务层接口

@Service
public class MessageServiceImpl implements MessageService {
    private ArrayList<String> msgList = new ArrayList<String>();

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列，id："+id);
        msgList.add(id);
    }

    @Override
    public String doMessage() {
        String id = msgList.remove(0);
        System.out.println("已完成短信发送业务，id："+id);
        return id;
    }
}

表现层接口

@RestController
@RequestMapping("/msgs")
public class MessageController {

    @Autowired
    private MessageService messageService;

    @GetMapping
    public String doMessage(){
        String id = messageService.doMessage();
        return id;
    }
}

整合ActiveMQ

1.导入springboot整合ActiveMQ的starter

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

2.配置ActiveMQ的服务器地址

spring:
  activemq:
    broker-url: tcp://localhost:61616

3.使用JmsMessagingTemplate操作ActiveMQ

@Service
public class MessageServiceActivemqImpl implements MessageService {
    @Autowired
    private JmsMessagingTemplate messagingTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列，id："+id);
        messagingTemplate.convertAndSend("order.queue.id",id);
    }

    @Override
    public String doMessage() {
        String id = messagingTemplate.receiveAndConvert("order.queue.id",String.class);
        System.out.println("已完成短信发送业务，id："+id);
        return id;
    }
}

4.使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息

@Component
public class MessageListener {
    @JmsListener(destination = "order.queue.id")
    @SendTo("order.other.queue.id")
    public String receive(String id){
        System.out.println("已完成短信发送业务，id："+id);
        return "new:"+id;
    }
}

5.切换消息模型由点对点模型到发布订阅模型，修改jms配置即可

spring:
  activemq:
    broker-url: tcp://localhost:61616
  jms:
    pub-sub-domain: true

总结

  1. springboot整合ActiveMQ提供了JmsMessagingTemplate对象作为客户端操作消息队列
  2. 操作ActiveMQ需要配置ActiveMQ服务器地址，默认端口61616
  3. 企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@JmsListener
  4. 配置jms的pub-sub-domain属性可以在点对点模型和发布订阅模型间切换消息模型

整合RabbitMQ

RabbitMQ参考：https://blog.csdn.net/weixin_43994244/article/details/128648348
1.入springboot整合amqp的starter，amqp协议默认实现为rabbitmq方案

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2.配置RabbitMQ的服务器地址

spring:
  rabbitmq:
    host: localhost
    port: 5672

3.初始化直连模式系统设置， 由于RabbitMQ不同模型要使用不同的交换机，因此需要先初始化RabbitMQ相关的对象，例如队列，交换机等

@Configuration
public class RabbitConfigDirect {
    @Bean
    public Queue directQueue(){
        return new Queue("direct_queue");
    }
    @Bean
    public Queue directQueue2(){
        return new Queue("direct_queue2");
    }
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }
    @Bean
    public Binding bindingDirect(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("direct");
    }
    @Bean
    public Binding bindingDirect2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with("direct2");
    }
}

4.使用AmqpTemplate操作RabbitMQ

@Service
public class MessageServiceRabbitmqDirectImpl implements MessageService {
    @Autowired
    private AmqpTemplate amqpTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列（rabbitmq direct），id："+id);
        amqpTemplate.convertAndSend("directExchange","direct",id);
    }
}

5.使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息

@Component
public class MessageListener {
    @RabbitListener(queues = "direct_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务(rabbitmq direct)，id："+id);
    }
}

整合(topic模型)

步骤①：同上，步骤②：同上

步骤③：初始化主题模式系统设置

@Configuration
public class RabbitConfigTopic {
    @Bean
    public Queue topicQueue(){
        return new Queue("topic_queue");
    }
    @Bean
    public Queue topicQueue2(){
        return new Queue("topic_queue2");
    }
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }
    @Bean
    public Binding bindingTopic(){
        return BindingBuilder.bind(topicQueue()).to(topicExchange()).with("topic.*.id");
    }
    @Bean
    public Binding bindingTopic2(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("topic.orders.*");
    }

主题模式支持routingKey匹配模式，*表示匹配一个单词，#表示匹配任意内容，这样就可以通过主题交换机将消息分发到不同的队列中，详细内容请参看RabbitMQ系列课程。

匹配键topic.*.*topic.#
topic.order.idtruetrue
order.topic.idfalsefalse
topic.sm.order.idfalsetrue
topic.sm.idfalsetrue
topic.id.ordertruetrue
topic.idfalsetrue
topic.orderfalsetrue

4.使用AmqpTemplate操作RabbitMQ

@Service
public class MessageServiceRabbitmqTopicImpl implements MessageService {
    @Autowired
    private AmqpTemplate amqpTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列（rabbitmq topic），id："+id);
        amqpTemplate.convertAndSend("topicExchange","topic.orders.id",id);
    }
}

发送消息后，根据当前提供的routingKey与绑定交换机时设定的routingKey进行匹配，规则匹配成功消息才会进入到对应的队列中。
5.使用消息监听器在服务器启动后，监听指定队列

@Component
public class MessageListener {
    @RabbitListener(queues = "topic_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务(rabbitmq topic 1)，id："+id);
    }
    @RabbitListener(queues = "topic_queue2")
    public void receive2(String id){
        System.out.println("已完成短信发送业务(rabbitmq topic 22222222)，id："+id);
    }
}

使用注解@RabbitListener定义当前方法监听RabbitMQ中指定名称的消息队列。

总结

  1. springboot整合RabbitMQ提供了AmqpTemplate对象作为客户端操作消息队列
  2. 操作ActiveMQ需要配置ActiveMQ服务器地址，默认端口5672
  3. 企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@RabbitListener
  4. RabbitMQ有5种消息模型，使用的队列相同，但是交换机不同。交换机不同，对应的消息进入的策略也不同

整合RocketMQ

在RocketMQ中，处理业务的服务器称为broker，生产者与消费者不是直接与broker联系的，而是通过命名服务器进行通信。broker启动后会通知命名服务器自己已经上线，这样命名服务器中就保存有所有的broker信息。当生产者与消费者需要连接broker时，通过命名服务器找到对应的处理业务的broker，因此命名服务器在整套结构中起到一个信息中心的作用。并且broker启动前必须保障命名服务器先启动。
在这里插入图片描述
1.导入springboot整合RocketMQ的starter，此坐标不由springboot维护版本

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.1</version>
</dependency>

2.配置RocketMQ的服务器地址

rocketmq:
  name-server: localhost:9876
  producer: #生产者分配组
    group: group_rocketmq

3.使用RocketMQTemplate操作RocketMQ

@Service
public class MessageServiceRocketmqImpl implements MessageService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列（rocketmq），id："+id);
        //异步调用结果 
        SendCallback callback = new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("消息发送成功");
            }
            @Override
            public void onException(Throwable e) {
                System.out.println("消息发送失败！！！！！");
            }
        };
        //发送异步消息
        rocketMQTemplate.asyncSend("order_id",id,callback);
    }
}

4.使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息

@Component
//指定消息队列，消费者组
@RocketMQMessageListener(topic = "order_id",consumerGroup = "group_rocketmq")
public class MessageListener implements RocketMQListener<String> {//消息类型
    @Override
    public void onMessage(String id) {
        System.out.println("已完成短信发送业务(rocketmq)，id："+id);
    }
}

RocketMQ的监听器必须按照标准格式开发，实现RocketMQListener接口，泛型为消息类型。
使用注解@RocketMQMessageListener定义当前类监听RabbitMQ中指定组、指定名称的消息队列。

总结

  1. springboot整合RocketMQ使用RocketMQTemplate对象作为客户端操作消息队列
  2. 操作RocketMQ需要配置RocketMQ服务器地址，默认端口9876
  3. 企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@RocketMQMessageListener

整合Kafka

1.导入springboot整合Kafka的starter，此坐标由springboot维护版本

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

2.配置Kafka的服务器地址

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: order

3.使用KafkaTemplate操作Kafka

@Service
public class MessageServiceKafkaImpl implements MessageService {
    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列（kafka），id："+id);
        kafkaTemplate.send("itheima2022",id);
    }
}

4.使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息

@Component
public class MessageListener {
    @KafkaListener(topics = "itheima2022")
    public void onMessage(ConsumerRecord<String,String> record){
        System.out.println("已完成短信发送业务(kafka)，id："+record.value());
    }
}

使用注解@KafkaListener定义当前方法监听Kafka中指定topic的消息，接收到的消息封装在对象ConsumerRecord中，获取数据从ConsumerRecord对象中获取即可。

总结

  1. springboot整合Kafka使用KafkaTemplate对象作为客户端操作消息队列
  2. 操作Kafka需要配置Kafka服务器地址，默认端口9092
  3. 企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@KafkaListener。接收消息保存在形参ConsumerRecord对象中
言烬
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot学习
01-29
Spring Boot 基础教程（基于1.3.x-1.5.x） 快速入门 chapter1：基本项目构建（可作为工程脚手架），引入web模块，完成一个简单的RESTful API 使用Intellij中的Spring Initializr来快速构建Spring Boot/Cloud工程 工程配置 chapter2-1-1：配置文件详解：自定义属性、随机数、多环境配置等 chapter2-1-2：2.0 新特性（一）：配置绑定全解析 chapter2-2-1：2.0 新特性（二）：新增事件ApplicationStartedEvent Web开发 chapter3-1-1：构建一个较为复杂的RESTful API以及单元测试 chapter3-1-2：使用Thymeleaf模板引擎渲染web视图 chapter3-1-3：使用Freemarker模板引擎渲染web视图 chapter3-1-4：使用Velocity模板引擎渲染web视图 chapter3-1-5：使用Swagger2构建RESTful API chapter3-1-6：统一异常处理 chapter3-1-7：使用Java 8中LocalDate等时间日期类的问题解决 chapter3-1-8：扩展XML请求和响应的支持 数据访问 chapter3-2-1：使用JdbcTemplate chapter3-2-2：使用Spring-data-jpa简化数据访问层（推荐） chapter3-2-3：多数据源配置（一）：JdbcTemplate chapter3-2-4：多数据源配置（二）：Spring-data-jpa chapter3-2-5：使用NoSQL数据库（一）：Redis chapter3-2-6：使用NoSQL数据库（二）：MongoDB chapter3-2-7：整合MyBatis chapter3-2-8：MyBatis注解配置详解 chapter3-2-9：使用Flyway来管理数据库版本 chapter3-2-10：使用LDAP来统一管理用户信息 chapter3-2-11：Spring Boot中增强对MongoDB的配置（连接池等） 事务管理 chapter3-3-1：使用事务管理 chapter3-3-2：[分布式事务（未完成）] 其他内容 chapter4-1-1：使用@Scheduled创建定时任务 chapter4-1-2：使用@Async实现异步调用 chapter4-1-3：使用@Async实现异步调用：自定义线程池 chapter4-1-4：使用@Async实现异步调用：资源优雅关闭 chapter4-1-5：使用@Async实现异步调用：使用Future以及定义超时 日志管理 chapter4-2-1：默认日志的配置 chapter4-2-2：使用log4j记录日志 chapter4-2-3：对log4j进行多环境不同日志级别的控制 chapter4-2-4：使用AOP统一处理Web请求日志 chapter4-2-5：使用log4j记录日志到MongoDB chapter4-2-6：Spring Boot 1.5.x新特性：动态修改日志级别] 安全管理 chapter4-3-1：使用Spring Security chapter4-3-2：[使用Spring Session（未完成）] 缓存支持 chapter4-4-1：注解配置与EhCache使用 chapter4-4-2：使用Redis做集中式缓存 邮件发送 chapter4-5-1：实现邮件发送：简单邮件、附件邮件、嵌入资源的邮件、模板邮件 消息服务 chapter5-1-1：[JMS（未完成）] chapter5-2-1：Spring Boot中使用RabbitMQ 其他功能 chapter6-1-1：使用Spring StateMachine框架实现状态机 Spring Boot Actuator监控端点小结 在传统Spring应用中使用spring-boot-actuator模块提供监控端点 Spring Boot应用的后台运行配置 Spring Boot自定义Banner Dubbo进行服务治理 chapter9-2-1：Spring Boot中使用Dubbo进行服务治理 chapter9-2-2：Spring Boot与Dubbo中管理服务依赖
基于spring 消息队列
12-04
web前端并发发送ajax请求，action 获取数据并存放到缓冲队列中，消费者消费队列中的数据，并且持久化
（RabbitMQ 四）SpringBoot+RabbitMQ实现用接收器接受多个主题【一条消息通过交换机发往多个消息队列】
myQNUMNINE的博客
09-02 1158
SpringBoot+RabbitMQ实现用接收器接受多个主题（Exchange-交换机初步使用） 本文适合学习RabbitMQ中的Exchange（交换机）的初学者。生产者生产消息通过交换机，根据绑定的规则分别分发给响应的消息队列（Queue）,然后消费者再消费消息队列中的消息。注意：当我一运行项目后，如果创建了交换机（即通过RabbitMQ的管理界面可以看到交换机已经创建之后），那么之后如果项目的交换机即使做出了修改也不会生效，要想修改后的交换机生效，目前我的做法是去管理界面中删除它。 本文出现了三个生
springboot与RabbitMQ整合消息队列，生产者发送消息确认，消费者消息确认模式
追风筝的人博客
10-12 1609
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上这些..
springboot整合rabbitMQ系列（二）一个队列里面的信息，让多个消费者进行消费
一天不写代码难受的博客
10-22 3869
之前讲解了第一个模型，直接队列模型，现在开始讲解工作模型 也就是有多个消费者要消费队列里面的信息，还是没有涉及到交换机。 之前已经讲过，这个模型是rabbitmq默认使用轮询的方式将队列里面的信息发给多个消费者。 那么在springboot项目里面如何使用第二个模型呢？ 发送者 这个和第一个模型是一样的，发送者还是往队列里面发送消息。 往work队列里面发送消息 消费者 既然有了发送者，现在开始写消费者 @Component public class WorkCustomer { @Rabbi
springboot+RabbitMQ实现一条消息被所有consumer消费
qq_35698970的博客
07-10 1339
这样，启动3个ac副本，就有3个queue绑定到了ac的exchange，mq message发送到topic exchange， 通过routing key分发到所有符合规则的queue，就能实现所有副本消费同一条消息。所以，用户登录请求通过负载均衡落到ac副本1（简称ac1）后，ac1生成jwt，除了纵向下发之外，还需要横向同步到ac2 ac3，ac2和ac3再纵向同步jwt，实现全平台的单点登录。ac1发送消息到rabbit mq，其他的所有副本ac2和ac3消费消息。2.添加rabbitMQ配置。
基于 SptringBoot 实现实时消息推送，这里有 7 种解决方案！
m0_71777195的博客
08-22 431
推送的场景比较多，比如有人关注我的公众号，这时我就会收到一条推送消息，以此来吸引我点击打开应用。消息推送(push)通常是指网站的运营工作等人员，通过某种工具对用户当前网页或移动设备APP进行的主动消息推送。消息推送一般又分为web端消息推送和移动端消息推送。上边的这种属于移动端消息推送，web端消息推送常见的诸如站内信、未读邮件数量、监控报警数量等，应用的也非常广泛。
SpringBoot之实现Web消息实时消息推送
上善若泪
10-10 553
长轮询是对上边短轮询的一种改进版本，在尽可能减少对服务器资源浪费的同时，保证消息的相对实时性。长轮询在中间件中应用的很广泛，比如Nacos和apollo配置中心，消息队列中都有用到长轮询。这次使用apollo配置中心实现长轮询的方式，应用了一个类，它是在后经过Spring封装提供的一种异步请求机制，直意就是延迟结果。可以允许容器线程快速释放占用的资源，不阻塞请求线程，以此接受更多的请求提升系统的吞吐量，然后启动异步工作线程处理真正的业务逻辑，处理完成调用提交响应结果。
SpringBoot集成RabbitMQ生产消费消息（简单实用版）
user990378983的博客
06-29 552
概要：要使用RabbitMQ消息队列主要有两个步骤，一个是搭建RabbitMQ服务（需下载安装），二是代码添加依赖开始编码。
SpringBoot整合RabbitMQ
tiantiantbtb的博客
05-02 847
消费者方面.因为考虑到服务器性能,正确的做法,正常希望看到的是能者多劳,速度快的多处理点消息,引入依赖 Spring Web,lombok,Spring for RabbitMQ。Topic模式,其实和Routing模式是非常相似的 只不过以通配符的形式。如果不配置上面两项,消费者无论速度快慢都会平均分发消息。希望消费者2处理消息 key可以传trace。速度慢的少处理点消息,也是一般的做法。#签收模式配置 手动签收。routing模式生产者。消费者1 消费了消息。
springboot做多消费者，实现能者多劳(公平竞争，公平分发)分发策略
qq_54864937的博客
11-06 163
springboot+rabbitmq实现能者多劳、公平竞争，公平分发
SpringBoot项目广场舞团.zip
04-15
利用SpringBoot的快速开发特性和微服务架构，该平台能够高效地处理用户数据和活动信息，同时提供易于使用的Web界面。 系统可能采用了模块化的设计思想，前端使用如Vue.js、React等现代JavaScript框架来构建一个响应...
SpringBoot项目基于Springboot的漫画网站.zip
最新发布
04-15
系统采用前后端分离的架构，前端可能使用Angular、React或Vue.js等现代JavaScript框架来构建用户界面，后端由SpringBoot负责处理业务逻辑，并通过RESTful API与前端进行数据交换。数据库方面，系统可能会选择MySQL、...
SpringBoot项目相亲网站.zip
04-13
7. **用户反馈与投诉**：建立用户反馈机制，及时处理用户的意见和建议，维护良好的交友环境。 8. **多语言支持**：考虑到国际化需求，系统提供多种语言界面，方便不同地区用户的使用。 9. **移动设备兼容**：优化...
springboot参考指南
07-21
使用@SpringBootApplication注解 vii. 19. 运行应用程序 i. 19.1. 从IDE中运行 ii. 19.2. 作为一个打包后的应用运行 iii. 19.3. 使用Maven插件运行 iv. 19.4. 使用Gradle插件运行 v. 19.5. 热交换 viii. 20. 打包...
SpringBoot使用jms整合IBM MQ，实现生产者和消费者
qq_40784783的博客
04-13 5988
工作需要，要在SpringBoot项目中整合IBM MQ，查阅了一些资料已成功整合，这里做下整理，知识嘛，还是需要系统的梳理一下的； 一、导入依赖 <!-- ibm mq --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jms</artifactId> <version>5.2.9.RELEAS
Spring消息简介
快乐的小三菊的博客
12-11 230
       像RMI、Hessian、Burlap、HTTP invoker和Web这些服务，在应用程序之间进行通信的机制都是同步的，客户端应用程序直接与远程服务相交互，并且一直等到远程过程完成后才能继续执行。同步通信有它自己适应的场景。        这种通信方式(同步)不是应用程序之间进行交互的唯一方式，异步消息是一个应用程序向另一个应用程序间接发送消息的一种方式，这种方式无需等待对方的响...
深入理解Spring的事件通知机制
JackChan
04-02 217
深入理解Spring的事件通知机制
实战指南：使用Spring Boot实现消息的发送和接收
长风 爱 跑步去
06-24 1430
当涉及到消息发送和接收的场景时，可以使用Spring Boot和消息中间件RabbitMQ来实现。下面是一个简单的示例代码，展示了如何在Spring Boot应用程序中创建消息发送者和接收者，并发送和接收一条消息。这是一个简单的示例，用于演示如何在Spring Boot应用程序中发送和接收消息。以上代码示例中使用了RabbitMQ作为消息中间件，你可以根据自己的需求选择其他消息中间件，并相应地更改配置。选择一个消息中间件作为你的消息代理，并确保已经安装和配置好该消息中间件。的类，用于发送消息。
如何优化springboot中异常处理
04-01
3. 返回异常信息：在处理异常时，可以返回有用的信息，如错误码、错误消息等等。可以使用@ResponseBody注解来返回JSON格式的异常信息。 4. 日志记录：在异常处理中，可以记录日志，以便于问题的追踪和解决。可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值