rabbitMQ在springboot中的使用_springboot rabbittemplate setconfirmcallback-优快云博客

本文链接：https://blog.youkuaiyun.com/wangyunzhao007/article/details/103945071

本文详细介绍如何在SpringBoot项目中整合RabbitMQ，包括项目搭建、配置文件编写、消费者和生产者代码实现，以及实体类和测试类的创建。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.建立springboot项目，并引入依赖

打开idea，点击File-New-Project，选择下图红色框中的

点击Next，出现下图，可以改名，也可以不改，我的是改了名字的

然后点击下一步，在搜索框输入rabbit

选择红色框中的选项，然后在选择右侧的Messageing，将Spring for RabbitMQ打上对勾。这样springboot会把rabbitmq的依赖自动导入

最后生成的依赖项是对的，但是我没有在test文件夹下的测试类中，是在src的路径写的测试，还需要一些其他依赖。pom文件全部依赖如下

 <dependencies>

        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.编写配置文件

#ip地址和端口号
spring.rabbitmq.addresses=192.168.157.129:5672
#登录rabbit的账号和密码
spring.rabbitmq.username=zhao
spring.rabbitmq.password=123
#虚拟机器名称
spring.rabbitmq.virtual-host=/
spring.rabbitmq.connection-timeout=15000

#监听这设置
spring.rabbitmq.listener.simple.acknowledge-mode=manual
spring.rabbitmq.listener.simple.concurrency=5
spring.rabbitmq.listener.simple.max-concurrency=10

#队列交换机设置
spring.rabbitmq.listener.order.queue.name = queue-2
spring.rabbitmq.listener.order.queue.durable=true
spring.rabbitmq.listener.order.exchange.name=exchange-2
spring.rabbitmq.listener.order.exchange.durable=true
spring.rabbitmq.listener.order.exchange.type=topic
spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true
spring.rabbitmq.listener.order.key=springboot.*

例子概图

3.消费者

package com.example.demo.consumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.util.Map;


@Component
public class RabbitRecever {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "queue-1", declare = "true"),
            exchange = @Exchange(value = "exchange-1",
                    declare = "true",
                    durable = "true", type = "topic",
                    ignoreDeclarationExceptions = "true"),
            key = "springboot.*"
    )
    )
    @RabbitHandler
    public void onMessage(Message message, Channel channel) throws Exception {
        System.out.println("-----------------------------------------");
        System.out.println("消费端Payload：" + message.getPayload());
        long deliveryTag = (Long) message.getHeaders().get(AmqpHeaders.DELIVERY_TAG);

        //手工ack
        channel.basicAck(deliveryTag, false);
    }


//    spring.rabbitmq.listener.order.queue.name = queue-1
//    spring.rabbitmq.listener.order.queue.durable=true
//    spring.rabbitmq.listener.order.exchange.name=exchange-1
//    spring.rabbitmq.listener.order.exchange.durable=true
//    spring.rabbitmq.listener.order.exchange.type=topic
//    spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true
//    spring.rabbitmq.listener.order.key=springboot.*

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "${spring.rabbitmq.listener.order.queue.name}",
                    declare = "${spring.rabbitmq.listener.order.queue.durable}"),
            exchange = @Exchange(value = "${spring.rabbitmq.listener.order.exchange.name}",
                    durable = "${spring.rabbitmq.listener.order.exchange.durable}",
                    type = "${spring.rabbitmq.listener.order.exchange.type}",
                    ignoreDeclarationExceptions = "${spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions}"),
            key = "${spring.rabbitmq.listener.order.key}"
    )
    )
    @RabbitHandler
    public void onOrderMessage(@Payload com.example.demo.entity.Order order, Channel channel,
                               @Headers Map<String, Object> headers) throws Exception {
        System.out.println("-----------------------------------------");
        System.out.println("消费端order：" + order.getId());
        long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);

        //手工ack
        channel.basicAck(deliveryTag, false);
    }
}

4.生产者

package com.example.demo;

import com.example.demo.entity.Order;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.Map;


@Component
public class RabbitSender {

	//自动注入RabbitTemplate模板类
	@Autowired
	private RabbitTemplate rabbitTemplate;  
	
	//回调函数: confirm确认
	final ConfirmCallback confirmCallback = new ConfirmCallback() {
		@Override
		public void confirm(CorrelationData correlationData, boolean ack, String cause) {
			System.err.println("correlationData: " + correlationData);
			System.err.println("ack: " + ack);
			if(!ack){
				System.err.println("异常处理....");
			}
		}
	};

	//回调函数: return返回
	final ReturnCallback returnCallback = new ReturnCallback() {
		@Override
		public void returnedMessage(org.springframework.amqp.core.Message message, int replyCode, String replyText,
				String exchange, String routingKey) {
			System.err.println("return exchange: " + exchange + ", routingKey: " 
				+ routingKey + ", replyCode: " + replyCode + ", replyText: " + replyText);
		}
	};
	
	//发送消息方法调用: 构建Message消息
	public void send(Object message, Map<String, Object> properties) throws Exception {
		MessageHeaders mhs = new MessageHeaders(properties);
		Message msg = MessageBuilder.createMessage(message, mhs);
		rabbitTemplate.setConfirmCallback(confirmCallback);
		rabbitTemplate.setReturnCallback(returnCallback);
		//id + 时间戳 全局唯一 
		CorrelationData correlationData = new CorrelationData("1234567890");
		rabbitTemplate.convertAndSend("exchange-1", "springboot.abc", msg, correlationData);
		System.out.println("发送了！");
	}
	
	//发送消息方法调用: 构建自定义对象消息
	public void sendOrder(Order order) throws Exception {
		rabbitTemplate.setConfirmCallback(confirmCallback);
		rabbitTemplate.setReturnCallback(returnCallback);
		//id + 时间戳 全局唯一 
		CorrelationData correlationData = new CorrelationData("0987654321");
		rabbitTemplate.convertAndSend("exchange-2", "springboot.def", order, correlationData);
	}
	
}

5.实体

package com.example.demo.entity;

import java.io.Serializable;

public class Order implements Serializable {

	private String id;
	private String name;
	
	public Order() {
	}
	public Order(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

6.测试类

package com.example.demo;

import com.example.demo.entity.Order;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {

    @Test
    public void contextLoads(){

    }

    @Autowired
    private RabbitSender rabbitSender;
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    @Test
    public void testSender1() throws Exception{
        Map<String ,Object> properties = new HashMap<>();
        properties.put("number","12345");
        properties.put("send_time",simpleDateFormat.format(new Date()));
        rabbitSender.send("你好！",properties);
        System.out.println("成功了！");
    }

    @Test
    public void testSender2() throws Exception{
        Order order = new Order("001","你好，哈哈！");
        rabbitSender.sendOrder(order);
        System.out.println("成功了！");
    }
}

建立晚上后，运行测试类中的方法即可。