RabbitMQ消息队列+SpringBoot延迟队列实现

LINUX下安装MQ:

参考： https://blog.csdn.net/tony308001970/article/details/53034320

常用操作：

$ sudo chkconfig rabbitmq-server on # 添加开机启动RabbitMQ服务

$ sudo /sbin/service rabbitmq-server start # 启动服务

$ sudo /sbin/service rabbitmq-server status # 查看服务状态

$ sudo /sbin/service rabbitmq-server stop # 停止服务

查看当前所有用户 $ sudo rabbitmqctl list_users

查看默认guest用户的权限 $ sudo rabbitmqctl list_user_permissions guest

由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户 $ sudo rabbitmqctl delete_user guest

添加新用户 $ sudo rabbitmqctl add_user username password

设置用户tag $ sudo rabbitmqctl set_user_tags username administrator

赋予用户默认vhost的全部操作权限 $ sudo rabbitmqctl set_permissions -p / username "." "." ".*"

查看用户的权限 $ sudo rabbitmqctl list_user_permissions username

开启web管理接口

如果只从命令行操作RabbitMQ，多少有点不方便。幸好RabbitMQ自带了web管理界面，只需要启动插件便可以使用。

$ sudo rabbitmq-plugins enable rabbitmq_management 然后通过浏览器访问

http://localhost:15672

输入用户名和密码访问web管理界面了。

配置RabbitMQ

关于RabbitMQ的配置，可以下载RabbitMQ的配置文件模板到/etc/rabbitmq/rabbitmq.config, 然后按照需求更改即可。 关于每个配置项的具体作用，可以参考官方文档。 更新配置后，别忘了重启服务哦！

开启用户远程访问

默认情况下，RabbitMQ的默认的guest用户只允许本机访问， 如果想让guest用户能够远程访问的话，只需要将配置文件中的loopback_users列表置为空即可，如下：

{loopback_users, []} 另外关于新添加的用户，直接就可以从远程访问的，如果想让新添加的用户只能本地访问，可以将用户名添加到上面的列表, 如只允许admin用户本机访问。

{loopback_users, ["admin"]} 更新配置后，别忘了重启服务哦！

记得要开放5672和15672端口，关闭防火墙、

SpringBoot整合RabbitMQ:

参考： https://www.cnblogs.com/ityouknow/p/6120544.html

添加amqp的POM依赖：

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

添加rabbitMQ服务器配置：

spring.application.name = rabbitmqTest
server.port= 7001

spring.rabbitmq.host=10.0.0.29
spring.rabbitmq.port=5672
spring.rabbitmq.username=username
spring.rabbitmq.password=password

最重要的配置类：

@Configuration
public class RabbitConfig {
    /**
     * 队列1
     * @return
     */
    @Bean
    public Queue queue(){
        return new Queue("first");
    }

    /**
     * 队列2
     * @return
     */
    @Bean
    public Queue queue2(){
        return new Queue("second");
    }

    /**
     *
     * topic交换器
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("exchange");
    }

    /**
     * 绑定路由队列1
     * @return
     */
    @Bean
    public Binding bindingExchangeMessage(){
        return BindingBuilder.bind(queue()).to(topicExchange()).with("queue.first.*");
    }

    /**
     * 绑定路由队列2
     * @return
     */
    @Bean
    public Binding bindingExchangeMessage2(){
        return BindingBuilder.bind(queue2()).to(topicExchange()).with("queue.second.#");
    }

    /**
     * dlx死信路由
     * @return
     */
    @Bean
    public TopicExchange derictExchange(){
        return new TopicExchange("dtlExchange");
    }

    /**
     * 产生死信的队列
     * @return
     */
    @Bean
    public Queue dtlQueue(){
        Map<String,Object> args = new HashMap<>();
        //指定过期消息跳转的交换器名称
        args.put("x-dead-letter-exchange","dtlExchange");
        //指定跳转消息携带的roting-key
        args.put("x-dead-letter-routing-key","dead.msg.aa");
        return QueueBuilder.durable("deadQueue").withArguments(args).build();
    }


    /**
     * 绑定 消费死信的队列 和死信路由
     * @return
     */
    @Bean
    public Binding bindingDeadExchange(){
        //routing-key保持一致
        return BindingBuilder.bind(queue()).to(derictExchange()).with("dead.msg.#");
    }

    /**
     * 绑定 产生死信的队列和任意一个路由
     * @return
     */
    @Bean
    public Binding bindingProductExchange(){
        return BindingBuilder.bind(dtlQueue()).to(topicExchange()).with("test.dead.#");
    }

}

发送消息到队列：

@RestController
public class MqController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    private static final String QUEUE_FIRST = "queue1";

    private static final String QUEUE_SECOND = "queue2";

    @RequestMapping(value = "/sendMsg" , method = RequestMethod.GET)
    public void send(String name){
        User user = new User();
        user.setPwd("1123");
        user.setUserid("admin");
        if(QUEUE_FIRST.equals(name)){
            rabbitTemplate.convertAndSend("exchange","queue.first.a",user);
        }else if(QUEUE_SECOND.equals(name)){
            rabbitTemplate.convertAndSend("exchange","queue.second.asasssa",user);
        }else{
            MessagePostProcessor postProcessor = new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    message.getMessageProperties().setContentEncoding("utf-8");
                    //设置消息存活时间
                    message.getMessageProperties().setExpiration("120000");
                    return message;
                }
            };
            user.setCreateTime(new Date().getTime());
            //发送消息到指定：  交换器，routing-key,消息体（支持对象）,配置文件
            rabbitTemplate.convertAndSend("exchange","test.dead.ok",user,postProcessor);
        }
    }
}

接受参数：

@Component
@RabbitListener(queues = "first")//指定队列名称
public class Recept {

    @RabbitHandler
    public void recept(User user){ //参数和队列里数据保持一致，如果是一个对象则必须要序列化
        Long createTime = user.getCreateTime();
        Long waitTime = null;
        if(createTime !=null){
            waitTime = new Date().getTime()-createTime;
        }
        System.out.println("延迟队列消费时间:"+waitTime+"ms");
       // System.out.println("消费者1:"+user.getUserid()+user.getPwd());
    }
}

转载于:https://my.oschina.net/huayangchen/blog/1802348