rabbitmq的4种交换机

RabbitMQ交换机类型

1、Direct exchange: 直连交换机,根据Routing Key(路由键)进行投递到不同队列。

路由键1
路由键2
Direct exchange
消息队列1
消息队列2

代码实现:

消息发送者,在pom.xml导入相关依赖
	<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
     </dependencies>

在application.yml自定义direct交换机的属性
# 应用名称
spring:
  application:
    name:
      001-rabbitmq-send
  rabbitmq:
    host: 192.168.126.124 #rabbitmq服务器地址
    port: 5672 #AMQP协议端口
    username: admin #账号
    password: admin #密码
    virtual-host: / #虚拟机
server:
  port:
    1001

#自定义消息队列的属性
custom:
  rabbitmq:
    # direct类型的消息的发送
    direct:
      queue-name: directQueue
      exchange-name: directExchange
      routing-key: directRoutingKey
读取application.yml自定义属性付给实体类对象
@Data
@Component
@ConfigurationProperties(prefix = "custom.rabbitmq.direct")
public class ExchangeProperties {
    private String queueName;
    private String exchangeName;
    private String routingKey;
}

声明Direct类型交换机、消息队列、绑定关系
@Configuration
public class RabbitMqConfiguration {
    @Autowired
    private ExchangeProperties exchangeProperties

    //声明Direct类型交换机、消息队列、绑定关系
    @Bean
    public DirectExchange directExchange(){
        //默认创建的交换机为持久化、非自动删除(自动删除没有监听的交换机,该交换机会被自动删除)的交换机
        return new DirectExchange(exchangeProperties.getExchangeName());
    }

    @Bean
    public Queue directQueue(){
        //默认创建的消息队列持久化、非自动删除、非排外(当前消息可以被任意消息消费,但是只能有一个消费者消费)
        return new Queue(exchangeProperties.getQueueName());
    }

    @Bean
    public Binding directBinding(Queue directQueue,DirectExchange directExchange){
        return BindingBuilder
                .bind(directQueue)
                .to(directExchange)
                .with(exchangeProperties.getRoutingKey());
    }

}
消息发送者发送消息
@Service
public class SendMsgImpl implements SendMsg {
    @Autowired
    private RabbitTemplate rabbitTemplate;

 
    @Autowired
    private ExchangeProperties exchangeProperties;


    @Override
    public void sendDirectMessage() throws JsonProcessingException {


        rabbitTemplate.convertAndSend(
                exchangeProperties.getExchangeName(),
                exchangeProperties.getRoutingKey(),
                "这是第2条测试消息"
        );
    }
}
消息接收者,application.yml
# 应用名称
spring:
  application:
    name:
      001-rabbitmq-receive
  rabbitmq:
    host: 192.168.126.124 #rabbitmq服务器地址
    port: 5672 #AMQP协议端口
    username: admin #账号
    password: admin #密码
    virtual-host: / #虚拟机
    listener:
      simple:
        #消息确认机制,manual表示手动确认,auto代表自动确认
        acknowledge-mode: manual
# 应用服务 WEB 访问端口
server:
  port:
    2001
消息接收者接收消息并手动确认消息
package com.wen.servive.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.Channel;
import com.wen.servive.ReceiveMsg;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.List;
import java.util.Map;

@Service
public class ReceiveMsgImpl implements ReceiveMsg {

    @RabbitListener(queues = "directQueue")
    public void receiveDirectMessage(Message msg, Channel channel) throws IOException {
        System.out.println(msg);
        //手动消费,注入一个参数Channel对象
        channel.basicAck(
                //根据消息标识,来手动消费消息
                msg.getMessageProperties().getDeliveryTag(),false);
    }
}

2、Fanout exchange
不使用路由键,使用广播模式,将消息传递到所有绑定Fanout exchang的消息队列,当消息队列未被消息消费者监听时,自动删除消息队列,所以消息队列的消息是非持久化。

binding
binding
Direct exchange
消息队列1
消息队列2
消息发送者,application.yml自定义fanout交换机的属性
#自定义消息队列的属性
custom:
  rabbitmq:
    # fanout类型的消息的发送
    fanout:
      queue-name: fanoutQueue
      exchange-name: fanoutExchange
读取application.yml自定义属性付给实体类对象
@Data
@Component
@ConfigurationProperties(prefix = "custom.rabbitmq.fanout")
public class FanoutProperties {

    private String queueName;
    private String exchangeName;
}
消息发送者发送消息
   @Override
    public void sendFanoutMessage() throws JsonProcessingException {
        rabbitTemplate.convertAndSend(
                //Fanout交换机没有路由键
                fanoutProperties.getExchangeName(), "","这是第3条测试消息");

    }

消息接收者接收消息服务
 - 声明fanout类型交换机、消息队列、绑定关系 
 - 接收消息
   @RabbitListener(bindings = {
            @QueueBinding(
                    //声明绑定关系中的消息队列,如果没有命名消息队列名称,是随机命名的名称
                    value = @Queue,
                    exchange = @Exchange(name="fanoutExchange",type = "fanout")
            )
    })
    public void receiveFanoutMessage(Message msg, Channel channel) throws IOException {
        System.out.println(msg);
        //手动消费,注入一个参数Channel对象
        channel.basicAck(
                //根据消息标识,来手动消费消息
                msg.getMessageProperties().getDeliveryTag(), false
        );
    }

3、Topic exchange:主题交换机,对路由键进行模式匹配后进行投递,符号#表示一个或多个词,.表示一个词。

例子:
路由键为routingKeyA aa,routingKeyB aa.bb,routingKeyC aa.bb.cc
Topic exchange的路由通配规则如下
aa.*  必须以aa开头的两个单词,只有routingKeyB符合
aa.# 必须以aa开头的零个或多个单词,routingKeyA routingKeyB routingKeyC符合
消息发送者,application.yml自定义Topic 交换机的属性
#自定义消息队列的属性
custom:
  rabbitmq:
      # topic类型的消息的发送
    topic:
      queue-name1: topicQueue1
      queue-name2: topicQueue2
      queue-name3: topicQueue3
      binding-key1: aa
      binding-key2: aa.*
      binding-key3: aa.#
      exchange-name: topicExchange
      routing-key1: aa
      routing-key2: aa.bb
      routing-key3: aa.bb.cc
读取application.yml自定义属性付给实体类对象
@Data
@Component
@ConfigurationProperties(prefix = "custom.rabbitmq.topic")
public class TopicProperties {
    private String queueName1;
    private String queueName2;
    private String queueName3;
    private String bindingKey1;
    private String bindingKey2;
    private String bindingKey3;
    private String exchangeName;
    private String routingKey1;
    private String routingKey2;
    private String routingKey3;
}

声明Topic类型交换机、消息队列、绑定关系
@Configuration
public class RabbitMqConfiguration {
   
    @Autowired
    private TopicProperties topicProperties;

    //声明 Topic类型交换机(1)、消息队列(3)、绑定关系(3)
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(topicProperties.getExchangeName());
    }
    @Bean
    public Queue topicQuene1(){
        return new Queue(topicProperties.getQueueName1());
    }

    @Bean
    public Queue topicQuene2(){
        return new Queue(topicProperties.getQueueName2());
    }
    @Bean
    public Queue topicQuene3(){
        return new Queue(topicProperties.getQueueName3());
    }

    @Bean
    public Binding topicBinding1(){
        return BindingBuilder
                .bind(topicQuene1())
                .to(topicExchange())
                .with(topicProperties.getBindingKey1());
    }

    @Bean
    public Binding topicBinding2(){
        return BindingBuilder
                .bind(topicQuene2())
                .to(topicExchange())
                .with(topicProperties.getBindingKey2());
    }
    @Bean
    public Binding topicBinding3(){
        return BindingBuilder
                .bind(topicQuene3())
                .to(topicExchange())
                .with(topicProperties.getBindingKey3());
    }
}
消息发送者发送消息
 @Override
    public void sendTopicMessage() throws JsonProcessingException {
        rabbitTemplate.convertAndSend(
                topicProperties.getExchangeName(), topicProperties.getRoutingKey1(),"这是第4条测试消息");

        rabbitTemplate.convertAndSend(
                //Fanout交换机没有路由键
                topicProperties.getExchangeName(), topicProperties.getRoutingKey2(),"这是第5条测试消息");

        rabbitTemplate.convertAndSend(
                //Fanout交换机没有路由键
                topicProperties.getExchangeName(), topicProperties.getRoutingKey3(),"这是第6条测试消息");
    }

消息接收者接收消息
   @RabbitListener(queues = {"topicQueue1",
            "topicQueue2",
            "topicQueue3"
            })
    public void receiveTopicMessage(Message msg, Channel channel) throws IOException {
        System.out.println(msg);
        //手动消费,注入一个参数Channel对象
        channel.basicAck(
                //根据消息标识,来手动消费消息
                msg.getMessageProperties().getDeliveryTag(), false
        );
    }

4、Header exchange:头交换机,不处理路由键。而是根据发送的消息内容中的headers属性进行匹配。

死信队列:存放过期消息的队列,对应有死信交换机和死信消费者

消息发送者,application.yml自定义正常交换机和死信交换机的属性
#自定义消息队列的属性
custom:
  rabbitmq:
    #模拟死性队列的场景 ,direct类型的交换机
    model:
      queue-name: modelQuene
      exchange-name: modelExchange
      routing-key: modelRoutingKey
    #direct类型的交换机
    dead:
      queue-name: deadQuene
      exchange-name: deadExchange
      routing-key: deadRoutingKey

读取application.yml自定义属性付给实体类对象
@Data
@Component
@ConfigurationProperties(prefix = "custom.rabbitmq.model")
public class ModelProperties {
    private String queueName;
    private String exchangeName;
    private String routingKey;
}

@Data
@Component
@ConfigurationProperties(prefix = "custom.rabbitmq.dead")
public class DeadProperties {
    private String queueName;
    private String exchangeName;
    private String routingKey;
}
声明正常交换机和死信交换机、消息队列、绑定关系
@Configuration
public class RabbitMqConfiguration {
    @Autowired
    private ModelProperties modelProperties;

    @Autowired
    private DeadProperties deadProperties;
    
    //声明死性队列场景
    //向Model中发送消息,等待消息过期,会自动发送到死信交换机中,根据死信routingKey转发到死信队列中
    @Bean
    public DirectExchange modelExchange(){
        return new DirectExchange(modelProperties.getExchangeName());
    }
    @Bean
    public Queue modelQuene(){
        Map<String,Object> arguments = new HashMap<>();
        //指定消息过期的时间,30秒过期
        arguments.put("x-message-ttl",30*1000);
        //指定死信交换机
        arguments.put("x-dead-letter-exchange",deadProperties.getExchangeName());
        //指定死信routingKey
        arguments.put("x-dead-letter-routing-key",deadProperties.getRoutingKey());
        return new Queue(modelProperties.getQueueName(),true,false,false,arguments);
    }

    @Bean
    public Binding modelBinding(){
        return BindingBuilder
                .bind(modelQuene())
                .to(modelExchange())
                .with(modelProperties.getRoutingKey());
    }

    @Bean
    public DirectExchange deadExchange(){
        return new DirectExchange(deadProperties.getExchangeName());
    }
    @Bean
    public Queue deadQuene(){
        return new Queue(deadProperties.getQueueName());
    }
    @Bean
    public Binding deadBinding(){
        return BindingBuilder
                .bind(deadQuene())
                .to(deadExchange())
                .with(deadProperties.getRoutingKey());
    }
}
消息发送者发送消息到正常交换机
    @Override
    public void sendModelMessage() throws JsonProcessingException {
        rabbitTemplate.convertAndSend(
                modelProperties.getExchangeName(), modelProperties.getRoutingKey(),"这是第7条测试消息");
    }

死信消息接收者接收消息

@Service
public class ReceiveMsgImpl implements ReceiveMsg {
   
    //接收modelQueue的消息队列,测试死信队列,这里不能消费消息
   // @RabbitListener(queues = "modelQueue")
    public void receiveModelMessage(Message msg, Channel channel) throws IOException {
        System.out.println(msg);
        //手动消费,注入一个参数Channel对象
        channel.basicAck(
                //根据消息标识,来手动消费消息
                msg.getMessageProperties().getDeliveryTag(), false
        );
    }

    //  当modelQueue消息超时时,会被转发到死信队列中进行处理
    @RabbitListener(queues = "deadQuene")
    public void receiveDeadMessage(Message msg, Channel channel) throws IOException {
        System.out.println("receiveDeadMessage:"+msg);
        //手动消费,注入一个参数Channel对象
        channel.basicAck(
                //根据消息标识,来手动消费消息
                msg.getMessageProperties().getDeliveryTag(), false);
    }
}

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值