RabbitMQ Exchange详解以及Spring中Topic实战

前言  

   AMQP,即Advanced Message Queuing Protocol,高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。消息中间件主要用于组件之间的解耦。

业务需求

   后端(集群)通过websocket往各自维持的websocket session推送消息,如果采用每个实例监听同一个queue,那么生产者往该queue中推送一条消息,该消息只能被集群中某个实例消费一次。

   想要实现后端每个实例同时消费该消息,便可采用RabbitMQ中的topic模式,即每个实例启动时,新建一个topic类型的exchange,routing key为"#.queue",并且每个实例的queue与该exchange绑定。每个实例中,根据hostname+".queue"(queue为配置文件中指定的默认队列名称)来创建各自的queue,这样每个实例都各自监听自己的queue。

   生产者往该exchange中推送消息,routing key使用默认队列(或者每台实例自己的队列都可以,只要能匹配到"#.queue"即可),这样exchange接收到消息后,会根据routingkey来匹配与该exchange绑定的queues,并将消息发送到符合条件的queues中,这样每台实例都能收到该消息并消费。

RabbitMQ介绍

   RabbitMQ是一个开源的AMQP实现,服务器端用Erlang语言编写,用于在分布式系统中存储转发消息,在易用性、扩展性、高可用性等方面表现不俗。 

整体结构图

    

概念介绍
  • Broker:简单来说就是消息队列服务器实体
  • Virtual Host:虚拟主机,一个Broker里可以开设多个virtual host,用作不同用户的权限分离
  • Exchange:消息交换机,它指定消息按什么规则,路由到哪个队列
  • Queue:消息队列载体,每个消息都会被投入到一个或多个队列
  • Binding:绑定,它的作用就是把exchange和queue按照路由规则绑定起来
  • Routing Key:路由关键字,exchange根据这个关键字进行消息投递
  • Publisher:消息生产者
  • Consumer:消息消费者
  • Channel:消息通道,在客户端的每个连接里,可建立多个channel,每个channel代表一个会话任务
Exchange详解
   Exchange意思为交换机,从图中可以看出,publisher发送消息,先进入Exchange,然后由Exchange分配到队列Queue
   1. Direct-Exchange

    Direct Exchange是RabbitMQ Broker的默认Exchange,在此类型下,不必指定routing key的名字,创建的Queue有一个默认的routing key,一般与创建的Queue同名。
    

   2. Topic-Exchange

    Topic Exchange是根据routing key和Exchange的类型将message发送到一个或者多个Queue中,可以通过它来实现pub/sub模式,即发布订阅。
    

    注:“#”表示0个或若干个关键字,“*”表示一个关键字
    如果Exchange没有发现能够与RouteKey匹配的Queue,则会抛弃此消息

   3. Fanout-Exchange

    此类型的Exchange比较特殊,会忽略routing key的存在,直接将message广播到所有的Queue中。
    

   4. Headers-Exchange

    Headers Exchange不同于上面三种Exchange,它是根据Message的一些头部信息来分发过滤Message,忽略routing key的属性,如果Header信息和message消息的头信息相匹配,那么这条消息就匹配上了。
    

Spring集成RabbitMQ实现Topic模式

   1. rabbitmq.properties(mq配置文件)

rabbitmq.host=127.0.0.1
rabbitmq.port=5672
rabbitmq.username=admin
rabbitmq.password=admin
rabbitmq.my.exchange=my-exchange
rabbitmq.my.queue=my-queue

   2. 自动注入配置类(注意:需要创建自定义rabbitAdmin,否则启动时不会自动创建exchange、queue、bindings相关信息,具体可以查看RabbitAdmin类中的initialize()方法)    

/**
 * @Description: rabbit mq相关配置
 * @author yehaixiao
 * @date 2018年5月30日
 */
@Configuration
public class RabbitMQConfig {

    private static final Logger LOGGER = Logger.getLogger(RabbitMQConfig.class);

    @Value("${rabbitmq.host}")
    String host;
    @Value("${rabbitmq.port}")
    int port;
    @Value("${rabbitmq.username}")
    String username;
    @Value("${rabbitmq.password}")
    String password;
    @Value("${rabbitmq.my.exchange}")
    String exchange;
    @Value("${rabbitmq.my.queue}")
    String queue;

    /**
     * 创建rabbit mq连接工厂
     */
    @Bean(name = "rabbitConnectionFactory")
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(host + ":" + port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setPublisherConfirms(true);
        return connectionFactory;
    }

    /**
     * 自定义connectionFactory,需要声明rabbitAdmin 内部initialize()方法会进行exchanges、queues、bindings声明
     */
    @Bean
    public RabbitAdmin rabbitAdmin() {
        return new RabbitAdmin(connectionFactory());
    }

    /**
     * 创建amqp消息模版,用于发送者发送消息
     */
    @Bean
    public AmqpTemplate amqpTemplate() {
        RabbitTemplate amqpTemplate = new RabbitTemplate(connectionFactory());
        // json消息转化
        amqpTemplate.setMessageConverter(messageConverter());
        return amqpTemplate;
    }

    /**
     * 创建topic类型交换器
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(exchange, false, true);
    }

    /**
     * 根据hostname创建queue(目的:为了实现多个集群中多个实例共享一条消息)
     * durable:是否持久化 
     * exclusive:仅创建者可以使用的私有队列,断开后自动删除 
     * auto-delete:当所有消费端连接断开后,是否自动删除队列
     */
    @Bean
    public Queue queue() {
        InetAddress netAddress = null;
        try {
            netAddress = InetAddress.getLocalHost();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        String hostName = netAddress.getHostName();
        String queueName = String.format("%s." + queue, hostName);
        LOGGER.info("dynamic create queue name:" + queueName);
        Queue queue = new Queue(queueName, false, false, true);
        return queue;
    }

    /**
     * 将队列queue与exchange绑定,binding_key为#.queue,模糊匹配
     */
    @Bean
    public Binding binding(Queue queue, TopicExchange topicExchange) {
        return BindingBuilder.bind(queue).to(topicExchange).with("#." + queue);
    }

    /**
     * 创建消息监听器
     */
    @Bean
    public MessageListener customizeMessageListener() {
        return new CustomizeMessageListener();
    }

    /**
     * 创建json消息转化器
     */
    @Bean
    public MessageConverter messageConverter() {
        Jackson2JsonMessageConverter fastJsonMessageConverter = new Jackson2JsonMessageConverter();
        return fastJsonMessageConverter;
    }

    /**
     * 绑定queue和listener关系
     */
    @Bean
    public SimpleMessageListenerContainer mqMessageContainer(Queue queue, MessageListener customizeMessageListener) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue);
        container.setExposeListenerChannel(true);
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setMessageListener(customizeMessageListener);
        return container;
    }
}

   3. 消息消费者(通过实现MessageListener来重写onMessage()方法)

/**
 * @Description: 消息监听器
 * @author yehaixiao
 * @date 2018年5月24日
 */
@Service
public class CustomizeMessageListener implements MessageListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(CustomizeMessageListener.class);

    @Override
    public void onMessage(Message message) {
        try {
            String queue = message.getMessageProperties().getConsumerQueue();
            String msg = new String(message.getBody());
            LOGGER.info("consumer msg : {}, from queue : {}", msg, queue);
        } catch (Exception e) {
            LOGGER.error("consumer message error!", e);
        }
    }
}

   4. 消息生产者(通过AmqpTemplate发送消息) 

/**
 * @Description: 消息生产者
 * @author yehaixiao
 * @date 2018年5月28日
 */
@Service
public class MessageProducer {

    private static final Logger LOGGER = LoggerFactory.getLogger(MessageProducer.class);

    @Value("${rabbitmq.my.exchange}")
    private String exchange;

    @Value("${rabbitmq.my.queue}")
    private String queue;

    @Resource
    private AmqpTemplate amqpTemplate;

    public void sendMessage(Object message) {
        LOGGER.info("send message : {} , to queue : {}", JSON.toJSONString(message), queue);
        // message是需要传递的信息, 指定特定的queue
        amqpTemplate.convertAndSend(exchange, queue, message);
    }
}
posted @ 2018-06-04 21:16  yehx  阅读(2701)  评论(0编辑  收藏  举报