rabbitMq 简单代码测试。

 配置类

package org.jeecg.modules.rabbitMqConf;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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


@Configuration
@SuppressWarnings("all")
public class TopicMqConfig {
    public final static  String ROUTING_KEY_1="routingKey1";
    public final static  String ROUTING_KEY_2="routingKey2";
    public final static  String ROUTING_KEY_3="routingKey3";
    public final static  String ROUTING_KEY_4="routingKey4";
    public final static  String ROUTING_KEY_5="routingKey5";
    public final static  String ROUTING_KEY_TTL="routingTtl";
    public final static  String ROUTING_KEY_DEAD="routingDead";

    //新建队列
    @Bean
    public Queue directQueue1(){
        return new Queue("directQueue1",true);
    }
    @Bean
    public Queue directQueue2(){
        return new Queue("directQueue2",true);
    }
    @Bean
    public Queue directQueue3(){
        return new Queue("directQueue3",true);
    }
    @Bean
    public Queue directQueue4(){
        return new Queue("directQueue4",true);
    }
    @Bean
    public Queue directQueue5(){
        return new Queue("directQueue5",true);
    }
    /**
     * 创建队列
     * durable:是否持久化
     * exclusive:默认false，只能在当前创建连接时使用，连接关闭后队列自动删除，该优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或消费者使用该交换机时，会自动删除
     */
    @Bean
    public Queue ttlQueue(){
        Map<String, Object> map = new HashMap<>();
        //设置过期时间为10s
        //map.put("x-message-ttl",10000);
        //设置队列最大长度为5，超过5个就放进死信队列
        map.put("x-max-length",5);
        //下方设置死信队列的交换机名称，因为我是direct的交换机，所以还需要设置其routingKey，若是fanout模式则不需要设置routingKey
        //下方设置的意思是：设置交换机为死信交换机，对应的路由KEy为dead
        map.put("x-dead-letter-exchange","dead-direct-exchange");
        map.put("x-dead-letter-routing-key","dead");
        return new Queue("ttlQueue",true,false,false,map);
    }

    /**
     * 创建队列
     * durable:是否持久化
     * exclusive:默认false，只能在当前创建连接时使用，连接关闭后队列自动删除，该优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或消费者使用该交换机时，会自动删除
     */
    //创建死信的队列
    @Bean
    public Queue deadQueue(){
        return new Queue("deadQueue",true);
    }


    /**
     * 创建交换机 死信交换机
     * durable:是否持久化
     * autoDelete:是否自动删除，当没有生产者或消费者使用该交换机时，会自动删除
     */
    //创建死信direct交换机
    @Bean
    public DirectExchange deadDirectExchange(){
        return new DirectExchange("dead-direct-exchange",true,false);
    }

    /**
     * 创建交换机
     * durable:是否持久化
     * autoDelete:是否自动删除，当没有生产者或消费者使用该交换机时，会自动删除
     */
    @Bean
    public DirectExchange directExchange(){
        return  new DirectExchange("directExchange",true,false);
    }

    /**
     * 创建交换机
     * durable:是否持久化
     * autoDelete:是否自动删除，当没有生产者或消费者使用该交换机时，会自动删除
     */
    //创建direct交换机
    @Bean
    public DirectExchange ttlDirectExchange(){
        return new DirectExchange("ttl-direct-exchange",true,false);
    }


    //进行交换机和队列的绑定
    //设置绑定key
    @Bean
    public Binding Binding1(){
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with(ROUTING_KEY_1);
    }
    @Bean
    public Binding Binding2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with(ROUTING_KEY_2);
    }
    @Bean
    public Binding Binding3(){
        return BindingBuilder.bind(directQueue3()).to(directExchange()).with(ROUTING_KEY_3);
    }
    @Bean
    public Binding Binding4(){
        return BindingBuilder.bind(directQueue4()).to(directExchange()).with(ROUTING_KEY_4);
    }
    @Bean
    public Binding Binding5(){
        return BindingBuilder.bind(directQueue5()).to(directExchange()).with(ROUTING_KEY_5);
    }

    //ttl队列绑定交换机
    @Bean
    public Binding ttlDirectBinding(){
        return BindingBuilder.bind(ttlQueue()).to(ttlDirectExchange()).with(ROUTING_KEY_TTL);
    }

    /**
     * 绑定交换机和队列
     */
    //死信交换机与死信队列绑定
    @Bean
    public Binding deadDirectBinding(){
        return BindingBuilder.bind(deadQueue()).to(deadDirectExchange()).with("dead");
    }

}

测试接口

@Resource
	 private RabbitMqClient rabbitMqClient;

	 @Resource
	 private RabbitTemplate rabbitTemplate;



	 @GetMapping("/testSendMq")
	 @ApiOperationSupport(order = 1)
	 @ApiOperation(value = "测试发送消息", notes = "测试发送消息")
	 public Result<?> testSendMq(@RequestParam(name="exchange" ,required = false) String exchange,
								 @RequestParam(name="routingKey" ,required = false) String routingKey,
								 @RequestParam(name="msg" ,required = false) String msg) {
		 rabbitTemplate.convertAndSend(exchange,routingKey,msg);
		 return Result.ok("测试发送消息成功！");
	 }


	 @GetMapping("/testGetMq")
	 @ApiOperationSupport(order = 1)
	 @ApiOperation(value = "测试获取消息", notes = "测试获取消息")
	 public Result<?> testGetMq(@RequestParam(name="exchange" ,required = false) String exchange,
								@RequestParam(name="queueName" ,required = false) String queueName) {
		 //DirectExchange directExchange = new DirectExchange(exchange);
		 //Message receive = rabbitTemplate.receive(queueName);
		 //String s = rabbitMqClient.receiveFromQueue(directExchange, queueName);
		 String s1 = rabbitMqClient.receiveFromQueue(queueName);
		 if (StringUtils.isBlank(s1)) {
			 s1 = "消息读取完毕";
		 }
		 return Result.ok("测试获取消息:"+s1);
	 }