RabbitMQ四种工作模式

RabbitMQ四种工作模式

创建队列

public final static String USER_LOG = "user.log";

@Bean
public Queue userLogQueue() {
    /*
        durable：队列是否可持久化，默认为true。
        exclusive： 队列是否具有排它性，默认为false。
        autoDelete：队列没有任何订阅的消费者时是否自动删除，默认为false。
        */
    return new Queue(USER_LOG, true, false, false);
}

DIRECT

• 创建交换机

public final static String DIRECT_EXCHANGE = "directExchange";

/**
* Direct（直连）模式下可实现消息的精确匹配
* 队列和交换机可通过指定的routerKey绑定
* 且默认会提供一个routerKey，就是队列的name
* 生产者通过指定的routerKey或者queueName发送消息，队列都能收到并消费
*
* @return DirectExchange
*/
@Bean(DIRECT_EXCHANGE)
public DirectExchange directExchange() {
        /*
        交换机持久化且不自动删除
        */
    return new DirectExchange(DIRECT_EXCHANGE, true, false);
}

• 将队列绑定交换机

// 只能匹配routerKey为direct.user.log的队列
private final static String DIRECT_ROUTER_KEY = "direct.user.log";

@Bean
public Binding bindingUserLogByDirect(Queue userLogQueue, DirectExchange exchange) {
    return BindingBuilder.bind(userLogQueue).to(exchange)
            .with(DIRECT_ROUTER_KEY)
            // .withQueueName();
}

TOPIC

• 创建交换机

public final static String TOPIC_EXCHANGE = "topicExchange";

/**
* TOPIC（主题）模式下，匹配规则更加灵活
* 可通过通配符 *，# 
*       topic.*.A（代表中间有一个任意单词）
*       topic.#.B（代表中间有多个任意单词）
* 实现routerKey的模糊匹配，将消息分发到多个队列中
* 如果不使用通配符，则和Direct模式无区别
*
* @return TopicExchange
*/
@Bean(TOPIC_EXCHANGE)
public TopicExchange topicExchange() {

    return new TopicExchange(TOPIC_EXCHANGE, true, false);
}

• 将队列绑定交换机

// 可模糊匹配routerKey前缀为topic.user.log的所有队列
public final static String TOPIC_ROUTER_KEY = "topic.user.log.*";

@Bean
public Binding bindingUserLogByTopic(Queue userLogQueue, TopicExchange exchange) {
    return BindingBuilder.bind(userLogQueue).to(exchange).with(TOPIC_ROUTER_KEY);
}

FANOUT

• 创建交换机

public final static String FANOUT_EXCHANGE = "fanoutExchange";

/**
* FANOUT（广播）模式下，交换机会向所有绑定的队列发送消息
* 不需要路由转发，速度最快
* 一般都是发送广播消息
*
* @return FanoutExchange
*/
@Bean(FANOUT_EXCHANGE)
public FanoutExchange fanoutExchange() {
    return new FanoutExchange(FANOUT_EXCHANGE, true, false);
}

• 将队列绑定交换机

/**
* 不需要设置任何路由，直接绑定交换机即可
* 
* @param userLogQueue
* @param exchange
* @return
*/
@Bean
public Binding bindingUserLogByFanout(Queue userLogQueue, FanoutExchange exchange) {
    return BindingBuilder.bind(userLogQueue).to(exchange);
}

HEADERS

• 创建交换机

/**
* HEADERS模式是忽略routerKey的一种模式
* 只会根据你messageProperties中的headers的值
* 和你队列绑定交换机的headers来判断是否发送到该队列中
*
* @return
*/
@Bean(HEADERS_EXCHANGE)
public HeadersExchange headersExchange() {
    return new HeadersExchange(HEADERS_EXCHANGE, true, false);
}

• 将队列绑定交换机

@Bean
public Binding bindingUserLogByHeaders(Queue userLogQueue, HeadersExchange exchange) {
    Map<String, Object> headers = new HashMap<>();
    headers.put("headers1", "value1");

    return BindingBuilder.bind(userLogQueue).to(exchange)
            // messageProperties中headers
            // 转发到该队列时所需要满足的条件
            // 包含所有的key值，只需要判断key
            // .whereAll("key1","key2").exist()

            // 包含任意某个key值
            // .whereAny("key1","key2").exist()

            // 包含所有的key和value值，同时需要判断key和value
            // .whereAll(headers).match()

            // 包含任意某个key + value
            .whereAny(headers).match();
}

• 测试

@PostMapping("/sendByHeaders")
public String sendByHeaders(String str) {
    //配置消息规则
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setHeader("headers1", "value1");
    messageProperties.setHeader("headers2", "value2");
    //要发送的消息，第一个参数为具体的消息字节数组，第二个参数为消息规则
    Message msg = new Message(str.getBytes(), messageProperties);

    rabbitTemplate.convertAndSend(RabbitMQConfig.FANOUT_EXCHANGE, "", str);
    return "SUCCESS";
}