spring boot整合rabbitmq

1.属性文件配置

server.port=8080
spring.application.name=rabbitmq

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
spring.rabbitmq.publisher-confirm-type=correlated
# 开启发送失败退回
spring.rabbitmq.publisher-returns=true
# 开启ACK手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual
spring.rabbitmq.listener.simple.acknowledge-mode=manual
#配置每次拉取消息的数量 限流
spring.rabbitmq.listener.simple.prefetch=1

2.RabbitmqConfig

package com.yjw.config;

import java.util.HashMap;
import java.util.Map;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqInfoQueue {

//绑定键
public final static String queue = "springboot_info";

public final static String exchange = "springboot_exchange";

public final static String routingKey = "topic.*";

@Bean
public Queue infoQueue() {
//设置队列过期时间
Map<String,Object> arguments = new HashMap<>();
// arguments.put("x-message-ttl",10000);
// arguments.put("x-max-length", 2);
arguments.put("x-dead-letter-exchange", RabbitmqDlxQueue.exchange);
arguments.put("x-dead-letter-routing-key", RabbitmqDlxQueue.routingKey);
return QueueBuilder.durable(queue).withArguments(arguments).build();
}

@Bean
TopicExchange infoExchange() {
return ExchangeBuilder.topicExchange(exchange).durable(true).build();
}

@Bean
Binding bindingInfoExchangeMessage() {
return BindingBuilder.bind(infoQueue()).to(infoExchange()).with(routingKey);
}

}

3.生产者

package com.yjw.controller;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public final class SendMessageController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @GetMapping("/sendMessage")
    public String sendTopicMessage1(String routingKey,String exchange) {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = routingKey;
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> manMap = new HashMap<>();
        manMap.put("messageId", messageId);
        manMap.put("messageData", messageData);
        manMap.put("createTime", createTime);
        rabbitTemplate.convertAndSend(exchange, routingKey, manMap);
        return "ok";
    }
}

4.消费者

package com.yjw.rabbitmq;

import java.io.IOException;
import java.util.Map;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.rabbitmq.client.Channel;

@Component
public class Consumer1 {

@RabbitListener(queues = "springboot_info")
public void process2(Message message, Channel channel) throws IOException{
System.out.println("springboot_info : " + message.toString());
// channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);

}
//
// @RabbitListener(queues = "springboot_error")
// public void process(Message message, Channel channel) throws IOException {
// System.out.println("springboot_error : " + message.toString());
// 采用手动应答模式, 手动确认应答更为安全稳定
// channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
// channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
// }

// @RabbitListener(queues = "springboot_dlx")
// public void processdlx(Message message, Channel channel) throws IOException {
// System.out.println("springboot_dlx : " + message.toString());
// // 采用手动应答模式, 手动确认应答更为安全稳定
// channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
// }
}

5.重写confirmCallBack

package com.yjw.config;

import javax.annotation.PostConstruct;

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;

@Component
public class RabbitConfirmCallback implements RabbitTemplate.ConfirmCallback {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);     
    }
    
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack) {
            System.out.println("交换机执行成功了:" + cause);
        } else {
            System.out.println("交换机执行失败了" + cause);
        }
    }
}

6.重写returnsCallBack

package com.yjw.config;

import javax.annotation.PostConstruct;

import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitReturnsCallback implements RabbitTemplate.ReturnsCallback {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
    @PostConstruct
    public void init(){
        rabbitTemplate.setReturnsCallback(this);;            
    }
    
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        System.out.println("路由转发失败了");
    }
}