RabbitMQ使用案例

最新推荐文章于 2024-09-22 15:13:23 发布
最新推荐文章于 2024-09-22 15:13:23 发布
阅读量3.1k 收藏 16
点赞数 1
文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40068304/article/details/122217163
版权

一.发布与订阅模式(队列-->交换机)

yml配置:

server:
  port: 8088
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    publisher-confirm-type: correlated    #消息确认方式,通过 correlated 来确认(将来的消息中才会带 correlation_id,只有通过 correlation_id 我们才能将发送的消息和返回值之间关联起来)
    publisher-returns: true     #开启发送失败退回
    #1.开启 confirm 确认机制

maven依赖:

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

1.配置类:

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 13:58
 * @description：MQ配置
 * @version: V1.1
 */
@Configuration
public class RabbitConfig {

    public static final String RPC_QUEUE1 = "queue_1";      //通道1
    public static final String RPC_QUEUE2 = "queue_2";          //通道2
    public static final String RPC_EXCHANGE = "rpc_exchange";       //  交换机

    /**
     * 设置消息发送RPC队列
     */
    @Bean
    Queue msgQueue() {
        return new Queue(RPC_QUEUE1);
    }

    /**
     * 设置返回队列
     */
    @Bean
    Queue replyQueue() {
        return new Queue(RPC_QUEUE2);
    }

    /**
     * 设置交换机
     */
    @Bean
    TopicExchange exchange() {
        return new TopicExchange(RPC_EXCHANGE);
    }

    /**
     * 请求队列和交换器绑定
     */
    @Bean
    Binding msgBinding() {
        return BindingBuilder.bind(msgQueue()).to(exchange()).with(RPC_QUEUE1);
    }

    /**
     * 返回队列和交换器绑定
     */
    @Bean
    Binding replyBinding() {
        return BindingBuilder.bind(replyQueue()).to(exchange()).with(RPC_QUEUE2);
    }


    /**
     * 使用 RabbitTemplate发送和接收消息
     * 并设置回调队列地址
     */
    @Bean
    RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        template.setReplyAddress(RPC_QUEUE2);
        template.setReplyTimeout(6000);
        return template;
    }


    /**
     * 给返回队列设置监听器
     */
    @Bean
    SimpleMessageListenerContainer replyContainer(ConnectionFactory connectionFactory) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setQueueNames(RPC_QUEUE2);
        container.setMessageListener(rabbitTemplate(connectionFactory));
        return container;
    }
}

2.生产者

import com.yl.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
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;

import java.util.HashMap;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 14:02
 * @description：MQ生产者
 * @version: V1.1
 */
@Slf4j
@RestController
public class RpcClientController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/send")
    public String send(String message) {
        // 创建消息对象
        Message newMessage = MessageBuilder.withBody(message.getBytes()).build();
        log.info("生产者发送消息----->>>>>", newMessage);
        //客户端发送消息
        Message result = rabbitTemplate.sendAndReceive(RabbitConfig.RPC_EXCHANGE, RabbitConfig.RPC_QUEUE1, newMessage);

        String response = "";
        if (result != null) {
            // 获取已发送的消息的 correlationId
            String correlationId = newMessage.getMessageProperties().getCorrelationId();
            log.info("生产者----->>>>>{}", correlationId);

            // 获取响应头信息
            HashMap<String, Object> headers = (HashMap<String, Object>) result.getMessageProperties().getHeaders();

            // 获取 server 返回的消息 id
            String msgId = (String) headers.get("spring_returned_message_correlation");

            if (msgId.equals(correlationId)) {
                response = new String(result.getBody());
                log.info("生产者发送消息----->>>>>：{}", response);
            }
        }
        return response;
    }
}

3.消费者

import com.yl.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
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.io.UnsupportedEncodingException;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 14:04
 * @description：MQ消费者
 * @version: V1.1
 */
@Slf4j
@Component
public class RpcServerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RabbitListener(queues = RabbitConfig.RPC_QUEUE1)
    public void process(Message msg) throws UnsupportedEncodingException {
        String message=new String(msg.getBody(),"UTF-8");

        log.info("消费者消费消息的消息体：{}----->>>>>"+message);
        Message response = MessageBuilder.withBody(("i'm receive:"+new String(msg.getBody())).getBytes()).build();
        CorrelationData correlationData = new CorrelationData(msg.getMessageProperties().getCorrelationId());
        rabbitTemplate.sendAndReceive(RabbitConfig.RPC_EXCHANGE, RabbitConfig.RPC_QUEUE2, response, correlationData);
    }
}

postmain:http://localhost:8088/send?message=听闻广陵不知寒,大雪龙骑下江南

结果:

  

二.路由模式(路由--->交换机)

yml配置:
 

server:
  port: 8084
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    publisher-confirms: true    #1.开启 confirm 确认机制
    publisher-returns: true    #2.开启 return 确认机制
     #3.设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
    template:
      mandatory: true


maven配置:

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

1.RabbitMQ配置

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/28 17:38
 * @description：RabbitMQ配置
 * @version: V1.1
 */
@Configuration
public class RabbitQueueConfig {
    /**
     * 方式二：
     * 通道--->交换机---->路由模式
     * */
    public static final String QUEUE_NAME="rollback-queue";     //通道
    public static final String EXCHANGE_NAME="rollback-exchange";       //交换机
    public static final String ROUTINGKEY_NAME="rollback-routingkey";       //路由

    /*---------------------------------方式二-------------------------------------------------*/
    /**
     * 1.设置消息发送RPC队列
     * */
    @Bean
    public Queue queue(){
        return new Queue(QUEUE_NAME,true);
    }

    /**
     * 2.设置交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(EXCHANGE_NAME);
    }

    /**
     * 3.绑定路由
     */
    @Bean
    public Binding binding(){
        return BindingBuilder.bind(queue()).to(directExchange())
                .with(ROUTINGKEY_NAME);
    }
}

2.重写RabbitTemplate，创建RabbitTemplateConfig配置类(手动确认消费)

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
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;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 11:10
 * @description：
 * @version: V1.1
 */

@Configuration
@Slf4j
public class RabbitTemplateConfig {

    //第二种方式
    final RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() 		{
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            log.info("ConfirmCallback，相关数据：{}", correlationData);
            log.info("ConfirmCallback，确认消息：{}", ack);
            log.info("ConfirmCallback，原因：{}", cause);
        }
    };

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate=new RabbitTemplate();
        //设置连接工厂Bean
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //手动开启
        rabbitTemplate.setMandatory(true);

        //设置传输数据是json格式
        rabbitTemplate.setMessageConverter(jsonMessageConverter());

        //流程：生产者-->交换机-->路由键-->队列
        //ConfirmCallback
        //流程：生产者-->交换机
        //1）成功  触发回调
        //2）失败  触发回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                log.info("ConfirmCallback，相关数据：{}", correlationData);
                log.info("ConfirmCallback，确认消息：{}", ack);
                log.info("ConfirmCallback，原因：{}", cause);
            }
        });

        //第二种方式
        //rabbitTemplate.setConfirmCallback(confirmCallback);

        //ReturnCallback：该回调函数的触发器与mandatory: true参数有必要关系
        //流程：交换机-->队列
        //成功  不触发回调
        //失败  触发回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                log.info("ReturnCallback，消息：{}", message);
                log.info("ReturnCallback，回应码：{}", replyCode);
                log.info("ReturnCallback，回应信息：{}", replyText);
                log.info("ReturnCallback，交换机：{}", exchange);
                log.info("ReturnCallback，路由键：{}", routingKey);
            }
        });

        return rabbitTemplate;
    }


    @Bean
    public Jackson2JsonMessageConverter jsonMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

3.消息监听指定具体的队列

import com.yl.controller.RabbitQueueReceiver;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 13:11
 * @description：消费消息
 * @version: V1.1
 */

@Configuration
public class MessageListenerConfig {

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(
            ConnectionFactory connectionFactory,
            RabbitQueueConfig rabbitQueueConfig,
            RabbitQueueReceiver rabbitQueuReceiver){
        SimpleMessageListenerContainer container=new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);//设置mq连接工厂对象
        container.setConcurrentConsumers(1);//设置并发消费者
        container.setMaxConcurrentConsumers(1);//设置最多的并发消费者
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息

//        container.setMessageConverter(jackson2JsonMessageConverter());



        //注意：此处不能使用Autowired根据类型自动注入队列，必须调用rabbitmqDirectConfig.firstQueue()获得，why?
        // 因为项目中可能存在多个队列，它们的类型都是Queue，自动注入会报错
        container.setQueues(rabbitQueueConfig.queue());
        container.setMessageListener(rabbitQueuReceiver);

        return container;
    }

    @Bean
    public Jackson2JsonMessageConverter jackson2JsonMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

4.消息生产者

import com.yl.common.Result;
import com.yl.common.SnowflakeIdWorker;
import com.yl.entity.Journal;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 11:11
 * @description：mq生产者
 * @version: V1.1
 */

@RestController
@Slf4j
public class SendController {

    final static SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("send")
    public Result send(){
        String exchange="rollback-exchange";
        String routingkey="rollback-routingkey";

        log.info("生产者开始发送消息");
        Journal journal = new Journal();
        journal.setId(idWorker.nextId());
        journal.setTitle("听闻广陵不知寒,大雪龙骑下江南");
//        journal.setCreateTime(LocalDateTime.now());
        journal.setTitleDesc("怒发冲冠⑵，凭阑处⑶、潇潇雨歇⑷。抬望眼，仰天长啸⑸，壮怀激烈⑹。三十功名尘与土⑺，八千里路云和月⑻。莫等闲⑼、白了少年头，空悲切⑽。 靖康耻⑾，犹未雪。臣子恨，何时灭。驾长车，踏破贺兰山缺⑿。壮志饥餐胡虏肉⒀，笑谈渴饮匈奴血⒁。待从头、收拾旧山河，朝天阙⒂。");
        //注意：将消息推送到正常的交换机中
        //参数一：交换机名称
        //参数二：路由键
        //参数三：传递参数
        //流程：生产者-->交换机-->路由键-->队列
        rabbitTemplate.convertAndSend(exchange,routingkey,journal);
        log.info("生产者发送消息完成");
        return Result.succ("操作成功");
    }
}

5.消息的消费者


import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.util.JSONPObject;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.adapter.AbstractAdaptableMessageListener;
import org.springframework.stereotype.Component;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 11:31
 * @description：MQ消费者
 * @version: V1.1
 */
@Slf4j
@Component
@RabbitListener(queues = {"rollback_queue"})
public class RabbitQueueReceiver extends AbstractAdaptableMessageListener {

    /**
     * 消息确认机制，消息不会重复消费
     * */
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        //消息的唯一ID，单调递增正整数，从1开始，当multiple=trues，一次性处理<=deliveryTag的所有
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        boolean multiple=false;  //false单条   true 批量

//       channel.basicAck(deliveryTag, multiple);	//正确消费消息
//       channel.basicReject(deliveryTag,true);     //为true会重新放回队列
//       channel.basicNack(deliveryTag, multiple,true)
        try {
            String msg=new String(message.getBody(),"UTF-8");
            JSONObject json = JSONObject.parseObject(msg);
            Long id = json.getLong("id");
            log.info("消费的消息id"+id+"-------->>>>>>>"+"消费者消费消息的消息体：{}----->>>>>"+message);

            //睡眠四秒
            for(int i=0;i<4;i++){
                Thread.sleep(1000);
                System.out.println("...");
            }

//            if(deliveryTag%2==0){
//                throw new RuntimeException("偶数必须为0");
//            }

            log.info("消息已被正确消费--->>>>>>>>"+deliveryTag);
            //当前模式为单条消费
            channel.basicAck(deliveryTag, multiple);

        } catch (Exception e) {
            e.printStackTrace();
            //报异常重新投递
            channel.basicReject(deliveryTag,true);
        }
    }


//    @RabbitHandler
//    public void handlerMessage(Journal orderVo) {
//        log.info("消费者消费消息"+orderVo.toString());
//    }
}

6.实体类对象

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * @author ：jerry
 * @date ：Created in 2021/12/29 14:37
 * @description：bean对象
 * @version: V1.1
 */
@Data
public class Journal {

    private Long id;

    private String title;

    private String titleDesc;

}

7.工具类



/**
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 -
 * 000000000000 <br>
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
 * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
 * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。
 * 41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
 * 加起来刚好64位，为一个Long型。<br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，
 * SnowFlake每秒能够产生26万ID左右。
 */
//雪花算法 生成主键ID
public class SnowflakeIdWorker {

    // ==============================Fields===========================================
    /** 开始时间截 (2015-01-01) */
    private final long twepoch = 1420041600000L;

    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;

    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;

    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /** 序列在id中占的位数 */
    private final long sequenceBits = 12L;

    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;

    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;

    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /** 工作机器ID(0~31) */
    private long workerId;

    /** 数据中心ID(0~31) */
    private long datacenterId;

    /** 毫秒内序列(0~4095) */
    private long sequence = 0L;

    /** 上次生成ID的时间截 */
    private long lastTimestamp = -1L;

    // ==============================Constructors=====================================
    /**
     * 构造函数
     *
     * @param workerId
     *            工作ID (0~31)
     * @param datacenterId
     *            数据中心ID (0~31)
     */
    public SnowflakeIdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(
                    String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(
                    String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    // ==============================Methods==========================================
    /**
     * 获得下一个ID (该方法是线程安全的)
     *
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();

        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format(
                    "Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        // 如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            // 毫秒内序列溢出
            if (sequence == 0) {
                // 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        // 时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }

        // 上次生成ID的时间截
        lastTimestamp = timestamp;

        // 移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     *
     * @param lastTimestamp
     *            上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 返回以毫秒为单位的当前时间
     *
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }

    // ==============================Test=============================================
    /** 测试 */
    public static void main(String[] args) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 100; i++) {
            long id = idWorker.nextId();
            String insertSQL = "insert into orderNumber value('" + id + "');";
            System.out.println(insertSQL);
        }
    }
}
import lombok.Data;

import java.io.Serializable;

@Data
public class Result implements Serializable {

	private int code;
	private String msg;
	private Object data;

	public static Result succ(Object data) {
		return succ(200, "操作成功", data);
	}

	public static Result succ(int code, String msg, Object data) {
		Result r = new Result();
		r.setCode(code);
		r.setMsg(msg);
		r.setData(data);
		return r;
	}

	public static Result fail(String msg) {
		return fail(400, msg, null);
	}

	public static Result fail(int code, String msg, Object data) {
		Result r = new Result();
		r.setCode(code);
		r.setMsg(msg);
		r.setData(data);
		return r;
	}

}

 postmain调用接口生产消息:http://localhost:8084/send

结果: 项目地址:

子午谷
关注
Rabbit MQ 的使用实例
pengweismile的专栏
05-08 1501
1. 创建一个User , Allen 2. 创建一个Virtual Host 3. 为User设置访问Virtual hosts权限 4. 使用Allen 这个user创建一个Queue 名字为Allen_Msg_Queue。 注意需要退出当前登录然后用Allen这个用户登录进去创建 5. 使用procedcer 往这个queue上面发送msg public class Producer { public static void main(.
RabbitMQ入门实例
baidu_41208204的博客
11-23 1620
1.RabbitMQ工作原理 2.添加依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.14.0</version> </dependency> 3.生产者代码 package com.ilearn.prducer;...
rabbitmq完整例子
08-13
rabbitmq完整例子，包含客户端、服务端例子。里面集中了各种案例详解
不止于方案，用代码示例讲解RabbitMQ顺序消费
最新发布
Apple_Boy的博客
09-22 1527
关于消息队列（MQ）顺序消费的讨论比比皆是，网上一搜便是铺天盖地的文章。然而，很多文章只是浅谈思路，对于具体的代码实现却往往一笔带过，让许多开发者（包括我）感到一头雾水。所以有时候空谈方案不来点代码理解一下就等于纸上谈兵~根据业务需要，定义多个队列和与之相关的交换机，比如3个队列，那么他们并发度也相比原来的一个队列提升了2倍！注意每个队列定义的时候也要声明为单活模式！// 定义交换机@Bean// 定义多个队列，假设有三个队列@Bean//最主要的区别就是声明了这个队列是单活模式。
RabbitMQ简单入门实例
格子的博客
03-29 1万+
RabbitMQ简单入门实例
RabbitMQ——Hello World
前尘忆梦的博客
04-25 824
文章目录1、RabbitMQ四个核心概念1.1、四大核心概念1.2、各个名词介绍1.3、安装2、Hello World2.1、依赖2.2、消息生产者 1、RabbitMQ四个核心概念 RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。 RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。 1.
4、RabbitMQ---六大模式之简单队列模式
weixin_45608577的博客
07-19 290
本节我们将用 Java 编写两个程序。发送单个消息的生产者和接收消息并打印 出来的消费者。 1、创建一个maven工程并且添加依赖 <!--指定 jdk 编译版本--> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId>
RabbitMQ简单使用案例
weixin_45229007的博客
09-28 729
RabbitMQ 2、批量确认模式，与单个相比，可以极大地提高吞吐量。但缺点很明显，当有故障时，无法定位那个消息出问题了。这种方案仍然是同步的。1、单个确认模式 效率很慢。效率最好,性价比最高，最常用。
Python队列RabbitMQ 使用方法实例记录
12-31
本文实例讲述了Python队列RabbitMQ 使用方法。分享给大家供大家参考，具体如下： 目前的exchange的路由策略是：每个需要队列的服务独享一个队列（queue），消费者（consumer）采用ACK自动应答模式处理队列消息。 ...
C++/QT 使用RabbitMQ
11-18
本文将详细介绍如何在C++和QT环境下集成并使用RabbitMQ，以便于开发者构建实时通信和高并发的应用。 首先，安装RabbitMQ需要在系统上设置Erlang环境，因为RabbitMQ是用Erlang语言编写的。确保已下载并安装了Erlang ...
C#操作RabbitMQ的完整实例
08-29
C#操作RabbitMQ的完整实例是一个详细介绍了如何使用C#语言操作RabbitMQ的实例，涵盖了从安装RabbitMQ到使用C#语言连接RabbitMQ的所有步骤。通过这个实例，读者可以了解到如何下载和安装RabbitMQ、配置RabbitMQ、创建...
RabbitMQ运行例子
05-03
网上的有关资料都有些老了，我发布了这个我自己写的代码。可以运行。里面有个文档rabbitmq.docx详细记录我参考的网站。
RabbitMQ使用例子
热门推荐
博客
07-12 1万+
一些概念： RabbiMQ的认知：首先要抛弃熟悉的客户端和服务器的观念。对于RabbitMQ应该认为是消息投递服务。、                               其次：从应用程序角度来看RabbitMQ的话，应用程序要先决定是个消息的发送者还是消息的接受者。                                         如果从RabbitMQ的角度来看的话...
rabbitmq 实战例子_RabbitMQ实战
weixin_39851408的博客
12-21 1310
RabbitMQ是采用Erlang语言实现AMQP(Advanced Message Queuing Protocol，高级消息队列协议)。RabbitMQ的具体特定包括下面几点：可靠性：有持久化、传输确认以及发布确认等机制保证可靠性灵活的路由：在消息进入队列之前，通过交换器来路由消息。典型的路由有一些内置交换器实现，复制的路由可能将多个交换器绑定在一起，也可以通过插件机制来实现自己的交换器。扩展...
rabbitMq实例
qq_37520786的博客
08-23 456
rabbitMq实例讲解，以springboot为主 一生产者      1.引包    &lt;dependencies&gt;         &lt;!-- fast json --&gt;         &lt;dependency&gt;             &lt;groupId&gt;com.alibaba&lt;/groupId&gt;             &lt;...
RabbitMQ入门例子
Be Like
02-03 286
spring boot版本：2.1.10.RELEASE 添加依赖 <!--RabbitMQ依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId&g...
RabbitMQ入门案例
不怕万人阻挡，只怕自己投降
12-15 1329
案例中生产者叫做 Task，一个消费者就是一个工作队列，启动两个工作队列消费消息，这个两个工作队列会以轮询的方式消费消息。假设生产者生产 AA BB CC DD这四条消息，理论上工作线程C1和工作线程C2轮询接收到消息，期望测试结果如下。轮询消费消息指的是轮流消费消息，即每个工作队列都会获取一个消息进行消费，并且获取的次数按照顺序依次往下轮流。创建一个类作为消费者，消费 RabbitMQ 队列的消息，消息消费是通过Channel来完成的。在运行第二个工作线程，此时已经开了两个工作线程，如下。
RabbitMq简单使用案例
wh2574021892的博客
04-28 492
1.打开rabbitMq后台管理网址 2.在此处创建队列 3.创建交换机 type此处我们选择direct即可,具体type释义请看 rabbitMq交换机type 4.创建交换机与队列的绑定策略 注:上述操作也可以通过代码在项目里完成配置 那么到此为止简单的后台策略是创建完成了，下面我们回到项目中。 5.在配置文件中填写配置信息 在类中将rabbitMq的操作类注入进来 简单的发送案例 ...
RabbitMQ使用
08-26
RabbitMQ是一个使用Erlang实现的高并发高可靠AMQP消息队列服务器。它支持消息的持久化、事务、拥塞控制、负载均衡等特性，使得RabbitMQ在各种应用场景下被广泛使用。RabbitMQ与Erlang和AMQP密切相关。 Erlang是一种编程语言，它特别适合构建高并发、分布式、实时的系统。RabbitMQ使用Erlang作为其底层开发语言，这使得它能够充分利用Erlang在并发处理和容错性方面的优势。 AMQP（Advanced Message Queuing Protocol）是一个开放标准的消息队列协议，用于在应用程序之间进行可靠的消息传递。RabbitMQ实现了AMQP协议，这意味着它可以与其他遵循AMQP协议的应用程序进行通信，实现可靠的消息传递机制。 要使用RabbitMQ，可以通过Docker安装，使用以下命令运行一个带有管理界面的RabbitMQ容器： ``` docker run -itd --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management ``` 在编写RabbitMQ程序时，可以利用其支持的多种消息模型，例如发布-订阅模型、工作队列模型、路由模型等，根据具体需求选择合适的模型来实现消息传递。 在配置RabbitMQ环境时，可以设置RABBITMQ_SERVER环境变量，并将RabbitMQ的安装路径添加到系统的path变量中，以方便在命令行中直接使用RabbitMQ命令。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [RabbitMQ使用详解](https://blog.csdn.net/qq_43410878/article/details/123656765)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值