RabbitMq使用

最新推荐文章于 2024-05-22 00:06:31 发布

Moon.月亮

最新推荐文章于 2024-05-22 00:06:31 发布

阅读量395

点赞数 9

文章标签： rabbitmq 分布式

本文链接：https://blog.csdn.net/qq_45000856/article/details/135226438

版权

引入依赖

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

连接配置

  # 注意：mq事件配置不正确（包括Tab和空格格式不正确），会导致服务注册失败
  rabbitmq:
    host: 你的mq部署地址
    port: 5672
    #    账号密码
    username: 你的账号
    password: 你的密码
    #支持发布确认
    publisher-confirm-type: correlated
    #支持发布返回
    publisher-returns: true
    #虚拟主机
    virtual-host: 你的虚拟主机（例如：smz）
    listener:
      retry:
        enabled: true
        max-attempts: 3
      simple:
        concurrency: 10 #最小并发数
        max-concurrency: 20 #最大并发数
        prefetch: 100 #从mq一次获取消息的数量
        default-requeue-rejected: true #如果出现异常，是否需要重新投递消息， false表示丢弃。  也有相应的Exception， true-MessageRejectedWhileStoppingException false-AmqpRejectAndDontRequeueException
        acknowledge-mode: manual #ack机制：手动确认，可以具体业务中设置是否ack确认
    template:
      retry:
        enabled: true
        max-attempts: 3

设置配置文件

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

@Configuration
@Slf4j
public class RabbitConfig {
  @Resource RabbitTemplate rabbitTemplate;

  //  @Bean
  //  public RabbitMqSender rabbitMqSender() {
  //    return new RabbitMqSender();
  //  }

  /**
   * 定制化amqp模版 可根据需要定制多个
   *
   * <p>
   *
   * <p>此处为模版类定义 Jackson消息转换器 ConfirmCallback接口用于实现消息发送到RabbitMQ交换器后接收ack回调 即消息发送到exchange ack
   * ReturnCallback接口用于实现消息发送到RabbitMQ 交换器，但无相应队列与交换器绑定时的回调 即消息发送不到任何一个队列中 ack
   *
   * @return the amqp template
   */
  //    @Primary
  @Bean
  public AmqpTemplate amqpTemplate() {
    Logger log = LoggerFactory.getLogger(RabbitTemplate.class);
    //          使用jackson 消息转换器
    rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
    rabbitTemplate.setEncoding("UTF-8");
    //        开启returncallback     yml 需要 配置    publisher-returns: true
    rabbitTemplate.setMandatory(true);
    rabbitTemplate.setReturnCallback(
        (message, replyCode, replyText, exchange, routingKey) -> {
          String correlationId = message.getMessageProperties().getCorrelationId();
          log.info(
              "消息：{} 发送失败, 应答码：{} 原因：{} 交换机: {}  路由键: {}",
              correlationId,
              replyCode,
              replyText,
              exchange,
              routingKey);
        });
    //        消息确认  yml 需要配置   publisher-returns: true
    rabbitTemplate.setConfirmCallback(
        (correlationData, ack, cause) -> {
          if (ack) {
            if (correlationData != null) {
              log.info("消息发送到exchange成功,id: {}", correlationData.getId());
            }
          } else {
            log.error("消息发送到exchange失败,原因: {}", cause);
          }
        });
    return rabbitTemplate;
  }
}

发送消息配置

import lombok.extern.slf4j.Slf4j;
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;

@Component
@Slf4j
public class RabbitMqSender {

  @Autowired private RabbitTemplate rabbitTemplate;

  /**
   * 所有发送到Topic Exchange的消息被转发到所有关心RouteKey中指定Topic的Queue上
   * 发送正常消息
   * @param exchange 交换机名称
   * @param routeKey 路由key
   * @param data 发送的数据
   */
  public void sendMQ(String exchange, String routeKey, Object data) {
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    log.info(
        "send: exchange={}, routeKey={}, message={}, id={}",
        exchange,
        routeKey,
        data,
        correlationData.getId());
    this.rabbitTemplate.convertAndSend(exchange, routeKey, data, correlationData);
  }
   /**
   * 发送延时信息
   *
   * @param exchange 交换机名称
   * @param routeKey 路由key
   * @param data 发送的数据
   * @param delayTimes  延迟时间/秒
   */
  public void sendDelayMessage(
      String exchange, String routeKey, Object data, final Integer delayTimes) {
    // 给延迟队列发送消息
    this.rabbitTemplate.convertAndSend(
        exchange,
        routeKey,
        data,
        message -> {
          // 给消息设置延迟毫秒值
          message.getMessageProperties().setHeader("x-delay", delayTimes * 1000);
          return message;
        });
    log.info("send delay message data:{}", data);
  }
}

公共枚举

public interface MqConstants {
  String containerFactory = "rabbitListenerContainerFactory"; // 容器工厂

  String exchange = "exchange-common"; // 交换机

  String queue_like = "common-like"; // 队列
  String rountingKey_like = "commonLike"; // 路由key

  String delayexchange = "delayexchange-common"; // 延迟交换机
  String delayqueue_like = "delay_common-demo"; // 队列
  String delayrountingKey_like = "delay_commonLike"; // 路由key
}

公共对象

import lombok.Data;

@Data
public class MqTestRequest {
  private String msg;
  private Integer seconds;
}

生产者

import com.smz.framework.config.rabbitmq.RabbitMqSender;
import com.smz.service.mq.domain.MqTestRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Desc 消息发送
 */
@Component
@Slf4j
public class MqProducer {
  @Autowired RabbitMqSender rabbitMqSender;

  /** 正常消息 */
  public void demo(MqTestRequest request) {
    log.info("测试mq：req={}", request);
    rabbitMqSender.sendMQ(MqConstants.exchange, MqConstants.rountingKey_like, request);
  }
  /** 延时消息 */
  public void delayeddemo(MqTestRequest request) {
    log.info("测试mq：req={}", request);
    rabbitMqSender.sendDelayMessage(
        MqConstants.delayexchange,
        MqConstants.delayrountingKey_like,
        request,
        request.getSeconds());
  }
}

消费者

import com.fasterxml.jackson.databind.ObjectMapper;
import com.smz.service.mq.domain.MqTestRequest;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;

/**
 * @Desc 点mq监听消费者
 */
@Service
@Slf4j
public class MqConsumer {
  @Autowired private ObjectMapper objectMapper;

  @RabbitListener(
      containerFactory = MqConstants.containerFactory,
      bindings =
          @QueueBinding(
              value = @Queue(value = MqConstants.queue_like, durable = "true"),
              exchange = @Exchange(value = MqConstants.exchange, type = ExchangeTypes.TOPIC),
              key = MqConstants.rountingKey_like))
  public void demo(Message message) throws IOException {
    MqTestRequest request = objectMapper.readValue(message.getBody(), MqTestRequest.class);
     
    System.out.println("-------普通消息->>>" + request.getMsg());
  }

  @RabbitListener(
      containerFactory = MqConstants.containerFactory,
      bindings =
          @QueueBinding(
              value = @Queue(value = MqConstants.delayqueue_like, durable = "true"),
              exchange =
                  @Exchange(
                      value = MqConstants.delayexchange,
                      durable = "true",
                      type = ExchangeTypes.TOPIC,
                      delayed = "true"),
              key = MqConstants.delayrountingKey_like))
  public void delayeddemo(Message message) throws IOException {
    MqTestRequest request = objectMapper.readValue(message.getBody(), MqTestRequest.class);
    System.out.println("-------------------延时消息->>>" + request.getMsg());
  }
}