小工具知识网

当前位置: 首页 > 行业知识 > SpringBoot 2.2.5 整合RabbitMQ,实现Topic主题模式的消息发送及消费

行业知识

SpringBoot 2.2.5 整合RabbitMQ,实现Topic主题模式的消息发送及消费

2026-11-19 05:37:57 来源:互联网转载

RabbitMQ六种工作模式简单说明

1、simple简单模式

  1. 消息产生着§将消息放入队列
  2. 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端)

2、work工作模式(资源的竞争)

  1. 消息产生者将消息放入队列消费者可以有多个,消费者1,消费者2,同时监听同一个队列,消息被消费?C1 C2共同争抢当前的消息队列内容,谁先拿到谁负责消费消息(隐患,高并发情况下,默认会产生某一个消息被多个消费者共同使用,可以设置一个开关(syncronize,与同步锁的性能不一样) 保证一条消息只能被一个消费者使用)
  2. 应用场景:红包;大项目中的资源调度(任务分配系统不需知道哪一个任务执行系统在空闲,直接将任务扔到消息队列中,空闲的系统自动争抢)

3、publish/subscribe发布订阅(共享资源)

  1. X代表交换机rabbitMQ内部组件,erlang 消息产生者是代码完成,代码的执行效率不高,消息产生者将消息放入交换机,交换机发布订阅把消息发送到所有消息队列中,对应消息队列的消费者拿到消息进行消费
  2. 相关场景:邮件群发,群聊天,广播(广告)

4、routing路由模式

  1. 消息生产者将消息发送给交换机按照路由判断,路由是字符串(info) 当前产生的消息携带路由字符(对象的方法),交换机根据路由的key,只能匹配上路由key对应的消息队列,对应的消费者才能消费消息;
  2. 根据业务功能定义路由字符串
  3. 从系统的代码逻辑中获取对应的功能字符串,将消息任务扔到对应的队列中业务场景:error 通知;EXCEPTION;错误通知的功能;传统意义的错误通知;客户通知;利用key路由,可以将程序中的错误封装成消息传入到消息队列中,开发者可以自定义消费者,实时接收错误;

5、topic 主题模式(路由模式的一种)

  1. 星号井号代表通配符
  2. 星号代表多个单词,井号代表一个单词
  3. 路由功能添加模糊匹配
  4. 消息产生者产生消息,把消息交给交换机
  5. 交换机根据key的规则模糊匹配到对应的队列,由队列的监听消费者接收消息消费

6、远程调用rpc模式

  1. 客户端发送一个请求消息然后服务器回复一个响应消息。为了收到一个响应,我们需要发送一个’回调’的请求的队列地址。

本文使用的是Topic主题模式,完整代码地址在结尾!!

第一步,在pom.xml加入依赖,如下

    org.springframework.boot    spring-boot-starter-amqp

第二步,编写application.yml配置文件,如下

server:  port: 8184spring:  application:    name: rabbitmq-demo-server  rabbitmq:    host: xxx # ip地址    port: 5672    username: xxx # 连接账号    password: xxx # 连接密码    template:      retry:        enabled: true # 开启失败重试        initial-interval: 10000ms # 第一次重试的间隔时长        max-interval: 300000ms # 最长重试间隔,超过这个间隔将不再重试        multiplier: 2 # 下次重试间隔的倍数,此处是2即下次重试间隔是上次的2倍      exchange: topic.exchange # 缺省的交换机名称,此处配置后,发送消息如果不指定交换机就会使用这个    publisher-confirm-type: correlated # 生产者确认机制,确保消息会正确发送,如果发送失败会有错误回执,从而触发重试    publisher-returns: true    listener:      type: simple      simple:        acknowledge-mode: manual        prefetch: 1 # 限制每次发送一条数据。        concurrency: 3 # 同一个队列启动几个消费者        max-concurrency: 3 # 启动消费者最大数量        # 重试策略相关配置        retry:          enabled: true # 是否支持重试          max-attempts: 5          stateless: false          multiplier: 1.0 # 时间策略乘数因子          initial-interval: 1000ms          max-interval: 10000ms        default-requeue-rejected: true

第三步,创建RabbitMqConstants类,如下

/** * RabbitMqConstants * * @author luoyu * @date 2019/03/16 22:12 * @description */public class RabbitMqConstants {    public final static String TEST1_QUEUE = "test1-queue";    public final static String TEST2_QUEUE = "test2-queue";    public final static String EXCHANGE_NAME = "test.topic.exchange";    public final static String TOPIC_TEST1_ROUTINGKEY = "topic.test1.*";    public final static String TOPIC_TEST1_ROUTINGKEY_TEST = "topic.test1.test";    public final static String TOPIC_TEST2_ROUTINGKEY = "topic.test2.*";    public final static String TOPIC_TEST2_ROUTINGKEY_TEST = "topic.test2.test";}

第四步,创建RabbitMqConfig配置类,如下

import com.luoyu.rabbitmq.constants.RabbitMqConstants;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.*;import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.config.ConfigurableBeanFactory;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Scope;/** * RabbitMQConfig * * @author luoyu * @date 2019/03/16 21:59 * @description */@Slf4j@Configurationpublic class RabbitMqConfig {    @Autowired    private CachingConnectionFactory connectionFactory;    /**     *  声明交换机     */    @Bean(RabbitMqConstants.EXCHANGE_NAME)    public Exchange exchange(){        //durable(true) 持久化,mq重启之后交换机还在        return ExchangeBuilder.topicExchange(RabbitMqConstants.EXCHANGE_NAME).durable(true).build();    }    /**     *  声明队列     *  new Queue(QUEUE_EMAIL,true,false,false)     *  durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列     *  auto-delete 表示消息队列没有在使用时将被自动删除 默认是false     *  exclusive  表示该消息队列是否只在当前connection生效,默认是false     */    @Bean(RabbitMqConstants.TEST1_QUEUE)    public Queue esQueue() {        return new Queue(RabbitMqConstants.TEST1_QUEUE);    }    /**     *  声明队列     */    @Bean(RabbitMqConstants.TEST2_QUEUE)    public Queue gitalkQueue() {        return new Queue(RabbitMqConstants.TEST2_QUEUE);    }    /**     *  TEST1_QUEUE队列绑定交换机,指定routingKey     */    @Bean    public Binding bindingEs(@Qualifier(RabbitMqConstants.TEST1_QUEUE) Queue queue,                             @Qualifier(RabbitMqConstants.EXCHANGE_NAME) Exchange exchange) {        return BindingBuilder.bind(queue).to(exchange).with(RabbitMqConstants.TOPIC_TEST1_ROUTINGKEY).noargs();    }    /**     *  TEST2_QUEUE队列绑定交换机,指定routingKey     */    @Bean    public Binding bindingGitalk(@Qualifier(RabbitMqConstants.TEST2_QUEUE) Queue queue,                                 @Qualifier(RabbitMqConstants.EXCHANGE_NAME) Exchange exchange) {        return BindingBuilder.bind(queue).to(exchange).with(RabbitMqConstants.TOPIC_TEST2_ROUTINGKEY).noargs();    }    /**     * 如果需要在生产者需要消息发送后的回调,     * 需要对rabbitTemplate设置ConfirmCallback对象,     * 由于不同的生产者需要对应不同的ConfirmCallback,     * 如果rabbitTemplate设置为单例bean,     * 则所有的rabbitTemplate实际的ConfirmCallback为最后一次申明的ConfirmCallback。     * @return     */    @Bean    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)    public RabbitTemplate rabbitTemplate() {        RabbitTemplate template = new RabbitTemplate(connectionFactory);        return template;    }}

第五步,创建RabbitMqUtils工具类,如下

import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.connection.CorrelationData;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;import java.util.UUID;/** * RabbitMqUtils * * @author luoyu * @date 2019/03/16 22:08 * @description */@Slf4j@Componentpublic class RabbitMqUtils implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback{    private RabbitTemplate rabbitTemplate;    /**     * 构造方法注入     */    @Autowired    public RabbitMqUtils(RabbitTemplate rabbitTemplate) {        this.rabbitTemplate = rabbitTemplate;        //这是是设置回调能收到发送到响应        rabbitTemplate.setConfirmCallback(this);        //如果设置备份队列则不起作用        rabbitTemplate.setMandatory(true);        rabbitTemplate.setReturnCallback(this);    }    /**     * 回调确认     */    @Override    public void confirm(CorrelationData correlationData, boolean ack, String cause) {        if(ack){            log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);        }else{            log.info("消息发送失败:correlationData({}),ack({}),cause({})",correlationData,ack,cause);        }    }    /**     * 消息发送到转换器的时候没有对列,配置了备份对列该回调则不生效     * @param message     * @param replyCode     * @param replyText     * @param exchange     * @param routingKey     */    @Override    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {        log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);    }    /**     * 发送到指定Queue     * @param queueName     * @param obj     */    public void send(String queueName, Object obj){        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());        this.rabbitTemplate.convertAndSend(queueName, obj, correlationId);    }    /**     * 1、交换机名称     * 2、routingKey     * 3、消息内容     */    public void sendByRoutingKey(String exChange, String routingKey, Object obj){        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());        this.rabbitTemplate.convertAndSend(exChange, routingKey, obj, correlationId);    }}

第六步,编写RabbitMqListener消费者监听器,如下

import com.luoyu.rabbitmq.constants.RabbitMqConstants;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.ExchangeTypes;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.Exchange;import org.springframework.amqp.rabbit.annotation.Queue;import org.springframework.amqp.rabbit.annotation.QueueBinding;import org.springframework.amqp.rabbit.annotation.RabbitListener;import org.springframework.stereotype.Component;import com.rabbitmq.client.Channel;@Slf4j@Componentpublic class RabbitMqListener {    @RabbitListener(queues = RabbitMqConstants.TEST1_QUEUE)    public void test1Consumer(Message message, Channel channel) {        try {            //手动确认消息已经被消费            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);            log.info("Test1消费消息:" + message.toString() + "。成功!");        } catch (Exception e) {            e.printStackTrace();            log.info("Test1消费消息:" + message.toString() + "。失败!");        }    }    @RabbitListener(queues = RabbitMqConstants.TEST2_QUEUE)    public void test2Consumer(Message message, Channel channel) {        try {            //手动确认消息已经被消费            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);            log.info("Test2消费消息:" + message.toString() + "。成功!");        } catch (Exception e) {            e.printStackTrace();            log.info("Test2消费消息:" + message.toString() + "。失败!");        }    }}

第七步,编写生产者服务类,TestService,TestServiceImpl,如下

TestService

public interface TestService {    String sendTest1(String content);    String sendTest2(String content);}

TestServiceImpl

import com.luoyu.rabbitmq.constants.RabbitMqConstants;import com.luoyu.rabbitmq.service.TestService;import com.luoyu.rabbitmq.util.RabbitMqUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Servicepublic class TestServiceImpl implements TestService {    @Autowired    private RabbitMqUtils rabbitMqUtils;    @Override    public String sendTest1(String content) {        rabbitMqUtils.sendByRoutingKey(RabbitMqConstants.EXCHANGE_NAME,                RabbitMqConstants.TOPIC_TEST1_ROUTINGKEY_TEST, content);        return "发送成功!";    }    @Override    public String sendTest2(String content) {        rabbitMqUtils.sendByRoutingKey(RabbitMqConstants.EXCHANGE_NAME,                RabbitMqConstants.TOPIC_TEST2_ROUTINGKEY_TEST, content);        return "发送成功!";    }}

第八步,编写TestController类,如下

import com.luoyu.rabbitmq.service.TestService;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/** * @author :jhx * @date :2020/12/26 * @desc : */@RestController@Slf4j@RequestMapping(value = "/message")public class TestController {    @Autowired    private TestService testService;    /**     * 发送消息test1     * @param content     * @return     */    @PostMapping(value = "/test1")    public String sendTest1(@RequestBody String content) {        return testService.sendTest1(content);    }    /**     * 发送消息test2     * @param content     * @return     */    @PostMapping(value = "/test2")    public String sendTest2(@RequestBody String content) {        return testService.sendTest2(content);    }}

第九步,启动项目,使用postman调用不同Topic主题的发送消息接口,通过控制台打印日志,可知消息成功发送并成功被消费。

完整代码地址:https://github.com/Jinhx128/springboot-demo

注:此工程包含多个module,本文所用代码均在rabbitmq-demo模块下

()()

上一篇:战区怎么连不上服务器?

下一篇:企业网站建设方案该怎么做