Rabbit发送消息与消费消息

KGF886

已于 2022-12-02 15:00:20 修改

阅读量293

点赞数

文章标签： java rabbitmq

于 2021-09-16 09:34:31 首次发布

本文链接：https://blog.csdn.net/weixin_45732391/article/details/120272559

版权

本文展示了如何使用RabbitMQ进行消息发送和消费。通过建立ConnectionFactory，配置连接参数，实现ChannelAwareMessageListener并重写onMessage方法，设置监听队列，实现了消息的自动确认和手动拒绝。此外，还提供了消息处理的详细步骤和日志记录。

摘要由CSDN通过智能技术生成

Rabbit发送消息与消费消息

发送：

public void testRabbit() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("ip");
        factory.setPort(5672);
        factory.setVirtualHost("claim");
        factory.setUsername("claim");
        factory.setPassword("claim");
        Connection connection = factory.newConnection();
        System.out.println("---------连接成功");
        Channel channel = connection.createChannel();
        channel.queueDeclare("wjg_test_queue",false,false,false,null);
        String message = "Hello World";
        for (int i = 0; i < 5; i++) {
            message+=i;
            channel.basicPublish("wjg.apply.image.exchange","imageSystem",null,message.getBytes(StandardCharsets.UTF_8));
        }
        System.out.println("---------发送成功");
        channel.close();
        connection.close();
    }

消费：
实现ChannelAwareMessageListener ，重写onMessage方法，@RabbitListener(queues = “队列名称”)

package com.sinosig.nonveh.endorseapp.service.rabbitMQ;

import com.rabbitmq.client.Channel;
import com.sinosig.saab.util.SpringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @description:
 * @author: wangjinguo
 * @date 2021/8/9 17:15
 */
@Component(value = "rabbitMqConsumer")
public class RabbiMqConsumer implements ChannelAwareMessageListener {

    private static final Logger logger = LoggerFactory.getLogger(RabbiMqConsumer.class);

    @Value("${mq.routing.key}")
    private String ROUTING_KEY_CALLBACK;
    @Value("${mq.exchange}")
    private String EXCHANGE;
    @Value("${mq.host}")
    private String HOST;
    @Value("${mq.username}")
    private String USERNAME;
    @Value("${mq.password}")
    private String PASSWORD;
    @Value("${mq.queue}")
    private String REPLY_QUEUE;

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(HOST);
        //connectionFactory.setHost(HOST);
        //connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("image");
        logger.info(HOST+"  "+USERNAME +"  "+PASSWORD);
        connectionFactory.setConnectionTimeout(5000);
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        return connectionFactory;
    }

    @Bean
    public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setQueueNames(REPLY_QUEUE);              // 监听的队列
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);        // 手动确认
        container.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {      //消息处理
            logger.info("====接收到消息=====");
            logger.info(new String(message.getBody()));
            if(message.getMessageProperties().getHeaders().get("error") == null){
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
                logger.info("消息已经确认");
            }else {
                //channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
                logger.info("消息拒绝");
            }

        });
        return container;
    }
    @RabbitHandler
    public void processMessage2(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tags){
        logger.info(message);
        try{
            channel.basicAck(tags,false);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    @Bean
    public TopicExchange exchange() {
        return new TopicExchange(EXCHANGE, true, false);
    }
    @Override
    @RabbitListener(queues = "callbackimage.prpall.queue")
    public void onMessage(Message message, Channel channel) throws Exception {
        CallBackImageService emailService = (CallBackImageService) SpringUtil.getBean("CallBackImageServiceImpl");
        byte[] body = message.getBody();
        String strBody = new String(body);
        emailService.handle(strBody);
    }
}