RabbitMQ通过代码创建交换机和队列

常见交换机

RabbitMQ提供的交换机一共的四种,分别是:

  1. Fanout:采用广播形式来发送消息,会将消息路由到所有绑定了的队列之中。

  2. Direct:通过Binding Key与队列绑定,生产者在发送信息的时候会通过Routing Key来告诉交换机消息要发送给谁

  3. Topic:与Direct类似,但是Topic支持通配符,能够使用通配符实现多匹配,一般情况下Binding Key是由多个单词组成,而Topic能够通过#和*来模糊匹配,#代表多个单词,*代表一个单词

  4. Headers :根据消息头进行匹配,基本上很少使用,限制较多,而且麻烦

Fanout 扇形交换机

java 复制代码
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {

    // 定义队列名称
    public static final String FANOUT_QUEUE_1 = "fanout.queue.1";
    public static final String FANOUT_QUEUE_2 = "fanout.queue.2";
    // 定义交换机名称
    public static final String FANOUT_EXCHANGE = "fanout.exchange";

    /**
     * 声明第一个队列
     */
    @Bean
    public Queue fanoutQueue1() {
        return new Queue(FANOUT_QUEUE_1);
    }

    /**
     * 声明第二个队列
     */
    @Bean
    public Queue fanoutQueue2() {
        return new Queue(FANOUT_QUEUE_2);
    }

    /**
     * 声明一个扇出交换机
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    /**
     * 将第一个队列绑定到扇出交换机
     */
    @Bean
    public Binding fanoutBinding1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    /**
     * 将第二个队列绑定到扇出交换机
     */
    @Bean
    public Binding fanoutBinding2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }
}

Direct 直连交换机

java 复制代码
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;

@Configuration
public class DirectConfig {

    // 定义队列名称
    public static final String DIRECT_QUEUE = "direct.queue";
    // 定义交换机名称
    public static final String DIRECT_EXCHANGE = "direct.exchange";
    // 定义路由键
    public static final String DIRECT_ROUTING_KEY = "direct.routing.key";

    /**
     * 声明一个队列
     */
    @Bean
    public Queue directQueue() {
        return new Queue(DIRECT_QUEUE);
    }

    /**
     * 声明一个直连交换机
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE);
    }

    /**
     * 将队列绑定到交换机,并指定路由键
     */
    @Bean
    public Binding directBinding() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTING_KEY);
    }
}

Topic 主题交换机

java 复制代码
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicConfig {

    // 定义队列名称
    public static final String TOPIC_QUEUE_1 = "topic.queue.1";
    public static final String TOPIC_QUEUE_2 = "topic.queue.2";
    // 定义交换机名称
    public static final String TOPIC_EXCHANGE = "topic.exchange";
    // 定义路由键模式
    public static final String TOPIC_ROUTING_KEY_1 = "topic.routing.key.1.*";
    public static final String TOPIC_ROUTING_KEY_2 = "topic.routing.key.2.#";

    /**
     * 声明第一个队列
     */
    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE_1);
    }

    /**
     * 声明第二个队列
     */
    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE_2);
    }

    /**
     * 声明一个主题交换机
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    /**
     * 将第一个队列绑定到主题交换机,并指定路由键模式
     */
    @Bean
    public Binding topicBinding1() {
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with(TOPIC_ROUTING_KEY_1);
    }

    /**
     * 将第二个队列绑定到主题交换机,并指定路由键模式
     */
    @Bean
    public Binding topicBinding2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with(TOPIC_ROUTING_KEY_2);
    }
}

Headers 头交换机

java 复制代码
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.HeadersExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class HeadersConfig {

    // 定义队列名称
    public static final String HEADERS_QUEUE_1 = "headers.queue.1";
    public static final String HEADERS_QUEUE_2 = "headers.queue.2";
    // 定义交换机名称
    public static final String HEADERS_EXCHANGE = "headers.exchange";

    /**
     * 声明第一个队列
     */
    @Bean
    public Queue headersQueue1() {
        return new Queue(HEADERS_QUEUE_1);
    }

    /**
     * 声明第二个队列
     */
    @Bean
    public Queue headersQueue2() {
        return new Queue(HEADERS_QUEUE_2);
    }

    /**
     * 声明一个头交换机
     */
    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(HEADERS_EXCHANGE);
    }

    /**
     * 将第一个队列绑定到头交换机,并指定头部属性
     */
    @Bean
    public Binding headersBinding1() {
        Map<String, Object> headers = new HashMap<>();
        headers.put("header1", "value1");
        return BindingBuilder.bind(headersQueue1()).to(headersExchange()).whereAny(headers).match();
    }

    /**
     * 将第二个队列绑定到头交换机,并指定头部属性
     */
   

注意点:

在我测试的过程中,发现在创建的过程中并不会直接去创建,而是在你读取队列后才会被创建,哪怕这个队列不存在,报错了,也会创建交换机和队列并绑定

相关推荐
Bug退退退1238 小时前
RabbitMQ 高级特性之死信队列
java·分布式·spring·rabbitmq
prince059 小时前
Kafka 生产者和消费者高级用法
分布式·kafka·linq
菜萝卜子10 小时前
【Project】基于kafka的高可用分布式日志监控与告警系统
分布式·kafka
幼稚园的山代王17 小时前
RabbitMQ 4.1.1初体验-队列和交换机
分布式·rabbitmq·ruby
小新学习屋17 小时前
Spark从入门到熟悉(篇三)
大数据·分布式·spark
沉着的码农21 小时前
【设计模式】基于责任链模式的参数校验
java·spring boot·分布式
ZHOU_WUYI1 天前
一个简单的分布式追踪系统
分布式
码不停蹄的玄黓2 天前
MySQL分布式ID冲突详解:场景、原因与解决方案
数据库·分布式·mysql·id冲突
王小王-1232 天前
基于Hadoop的公共自行车数据分布式存储和计算平台的设计与实现
大数据·hive·hadoop·分布式·hadoop公共自行车·共享单车大数据分析·hadoop共享单车
要开心吖ZSH2 天前
《Spring 中上下文传递的那些事儿》Part 4:分布式链路追踪 —— Sleuth + Zipkin 实践
java·分布式·spring