交换机

简单介绍

上一篇博客都是创建了一个工作队列,假设的是工作队列背后,每个任务都恰好交付给一个消费者(工作线程)。在这一部分,我们将做一些完全不同的事情。我们将消息传递给多个消费者,这种模式就是 “发布、订阅”
简单实验
构建一个简单的日志系统,将两个程序组成:第一个程序将发出日志消费,第二个程序是消费者,其中我们会启动两个消费者,其中一个消费者接收到消息后把日志存储早磁盘。另外一个消费者接收到消息后把消息打印出来 ,事实上第一个程序发出的日志消息将广播给所有消费者。

Exchanges 概念

RabbitMQ 消息传递模型的核心思想是:生产者的消息从不会直接发送到队列 实际上,通常生产者甚至都不知道这些消息传递到了那些队列中。
生产者只能将消息发送到交换机 ,交换机的工作非常简单。接收来自生产者的消息。推入队列,交换机必须知道如何处理收到的消息,应该把这些消息放到特定队列。都是由交换机的类型决定的。

交换机的类型

直接,主题,标题,扇出

无名(Exchange)

之前上篇博客中我们对于交换机的部分都是一个空的字符串

认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_工作队列

临时队列

每当我们链接Rabbit 的时候 我们都需要一个全新的空的队列,为此可以创建一个具有随机名称的队列,或者能让服务器为我们选择一个随机队列名称就好了,其次一旦我们断开了消费者的链接,队列就会被自动删除。
创建临时队列方式

String queueName = channel.queneDeclare().getQuene();

Fanout (扇出)

Fanout 这种类型非常简单 正如从名称中猜到的那样 它将接收到的所有消息广播到它知道的所有队列中,系统中默认有些 exchange 类型。

消费者代码 01

// 消息接收
public class ReceiveLogs01 {
    // 交换机名称
    public static final String EXCHANGE_NAME ="logs";
    public static void main(String[] args) throws Exception{
    // 创建链接
        Channel channel = RabbitmqUtil.getChannel();
        // 创建一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        // 生成一盒临时的队列
        String queueName = channel.queueDeclare().getQueue();
        // 绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("等待接收消息");
        // 接收消息
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println("02 new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
    }
}

消费者一和二是一样的

生产者代码

public class LOgs {
    // 交换机名称
    public static final String EXCHANGE_NAME ="logs";

    public static void main(String[] args) throws Exception{
         // 创建连接的对象
        Channel channel = RabbitmqUtil.getChannel();
        // 交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes("UTF-8"));
            System.out.println("message = " + message);

        }
    }
}

效果

认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_java_02

认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_java_03
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_工作队列_04
这样一个消息可以被2个不同的消费者获取。

Direct exchange

小总结
上面构建一个简单的日志系统。可以接收许多接受者广播的日志消息。但是这个交换机的可以只让某个消费者订阅发布的部分内容。加入说我们只想吧错误的定向存储到日志文件 同时任然能够打印出所有的信息。

Direct exchange 介绍

这个就可以很好的把我们日志消息写入磁盘的程序,接收严重的错误(errors)不存储那些警告或者其他的日志消息写入磁盘空间,Fanout 这种交换并不能给我们带来很大的灵活性 他只能进行无意识的广播,在这里我们将使用 direct 这种类型来进行替换 这种类型的工作方式是 消息只去到它绑定的 routingkey 队列中去

代码

**这个负责 info 和 警告 **

public class Direct {
    // 交换机的名字
    public static final String EXCHANGE_NAME   = "DirectLogs";

    public static void main(String[] args) throws Exception {
        // 获取到 信道
        Channel channel = RabbitmqUtil.getChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明一个队列
        channel.queueDeclare("console",false,false,false,null);

        channel.queueBind("console",EXCHANGE_NAME,"info");
          channel.queueBind("console",EXCHANGE_NAME,"warning");
        // 接收消息
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println("new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
        };
        // 消费者取消消息时回调接口
        channel.basicConsume("cosole",true,deliverCallback,consumerTag ->{});
    }
}

这个是 错误



public class Direct_1 {
    // 交换机的名字
    public static final String EXCHANGE_NAME   = "DirectLogs";

    public static void main(String[] args) throws Exception {
        // 获取到 信道
        Channel channel = RabbitmqUtil.getChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 声明一个队列
        channel.queueDeclare("disk",false,false,false,null);

        channel.queueBind("disk",EXCHANGE_NAME,"error");
        // 接收消息
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println("new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
        };
        // 消费者取消消息时回调接口
        channel.basicConsume("disk",true,deliverCallback,consumerTag ->{});
    }
}
在这里插入代码片

生产者


public class Demo {
    // 交换机的名字
    public static final String EXCHANGE_NAME   = "DirectLogs";

    public static void main(String[] args) throws Exception {
        // 创建管道
        Channel channel = RabbitmqUtil.getChannel();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String next = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"error",null,next.getBytes());
            System.out.println("next = " + next);
        }

    }
}

认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_spring_05

Topics

之前类型的问题

上面的交换机 改进了日志记录系统 没有使用只能进行随意广播的fanout 交换机,而是使用了direct 交换机,从而有能实现有选择地接收日志。

尽管使用direct 交换机改进了我们的系统,但是他仍然存在局限性 比方说我们想接收的日志类型有 info.base 和 info.advantage ,某个队列只想要 info.base 的消息 那这个时候direct 就办不到了。 这个时候这个就不能满足我们的要求了。

Topic 的要求

发送到类型是topic 交换机的消息 routing_key 不能随便写,必须满足一定的要求 它必须是一个单词列表 用逗号分隔开,这些单词可以是任意单词 不能超过 255 个字节

PS (星号) * 可以代替一个单词
# (井号)可以替代零个或多个单词

代码

消费者一

public class Topic01 {
    // 交换机名字
    public static final String EXCHANGE_NAME ="topic_logs";
    // 开始接收消息
    public static void main(String[] args) throws Exception {
        // 创建链接的信道
        Channel channel = RabbitmqUtil.getChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        // 声明队列
        String queueName = "TopicQ1";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"*.orange.*");
        System.out.println(" 等待接收消息");
        // 函数式接口
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println(new String(message.getBody(),"Utf-8"));
            System.out.println("接收队列: " + queueName );
        };
        // 接收消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
    }
}

消费者二

public class Topic02 {
    // 交换机名字
    public static final String EXCHANGE_NAME ="topic_logs";
    // 开始接收消息
    public static void main(String[] args) throws Exception {
        // 创建链接的信道
        Channel channel = RabbitmqUtil.getChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        // 声明队列
        String queueName = "TopicQ2";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(queueName,EXCHANGE_NAME,"lazy.#");
        System.out.println(" 等待接收消息");
        // 函数式接口
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println(new String(message.getBody(),"Utf-8"));
            System.out.println("接收队列: " + queueName );
        };
        // 接收消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
    }
}

生产者

public class Topic03 {
    // 交换机名字
    public static final String EXCHANGE_NAME ="topic_logs";

    public static void main(String[] args) throws Exception {
        // 创建信道
        Channel channel = RabbitmqUtil.getChannel();
        // 设置发送的消息
        HashMap<String, String> map = new HashMap<>();
        map.put("quick.orange.rabbit","被q1q2 接收到");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            channel.basicPublish(EXCHANGE_NAME, key,null,value.getBytes("UTF-8"));
        }
    }
}

死信队列

概念

就是无法被消费的消息,字面意思就是 一般来说,producer 将消息投递broker 或者直接到queue 里了,consumer 从 queue 取出来消息进行消费 但某些时候由于特定的原因导致queue 中某些消息无法被消息,这样的消息如果没有后续的处理,就变成了死信,有死信自然就有了死信队列。
应该场景: 为了保证订单业务的消息数据不丢失,需要使用到 RABBITMQ 的死信队列机制,当消息消费发生异常时,将消息投入死信队列中 。比如说:用户在商场下单成功并点击去支付后在指定时间未支付时自动失效。

死信的来源

消息TTL 过期
队列达到最大长度(队列满了。无法在添加数据到mq 中)
消费被拒绝。

过期时间代码

public class dead01 {
    // 创建普通的交换机名称
    public static final String nomal_exchang ="NOMAL_EXCHANG";
    // 创建死信的交换机名称
    public static final String DEAD_EXCHANG ="DEAD_EXCHANG";
    // 创建死信的队列名称
    public static final String Nomal_queue ="NOMAL_QUEUE";
    // 创建普通的队列名称
    public static final String DEAD_queue ="DEAD_QUEUE";

    public static void main(String[] args) throws Exception{
        // 创建通道
        Channel channel = RabbitmqUtil.getChannel();
        // 声明死信和普通交换机 类型为 direct
        channel.exchangeDeclare(nomal_exchang, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANG, BuiltinExchangeType.DIRECT);

        // 声明普通队列

        HashMap<String, Object> map = new HashMap<>();
        // 正常队列设置死信交换机
      //  map.put("x-message-ttl",10000);
        map.put("x-dead-letter-exchange",DEAD_EXCHANG);
        map.put("x-dead-letter-routing-key","feng");

        channel.queueDeclare(Nomal_queue,false,false,false,map);
        channel.queueDeclare(DEAD_queue,false,false,false,null);
        channel.queueBind(Nomal_queue,nomal_exchang,"jioajioa");
        channel.queueBind(DEAD_queue,DEAD_EXCHANG,"feng");
        System.out.println("等待接收消息");
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println(new String(message.getBody(),"utf-8"));
        };
        channel.basicConsume(Nomal_queue,true,deliverCallback,consumerTag ->{});

    }
}



生产者


public class dead02 {
    // 普通交换机名称
    public static final String nomal_exchang ="nomal_exchang";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitmqUtil.getChannel();
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 1; i < 11; i++) {
            String message = "info" +i;
            channel.basicPublish(nomal_exchang,"feng",properties,message.getBytes());
        }
    }
}

效果 当我们的消费者1 死掉的时候 这个时候数据就会到我们的死信队列中去
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_消息传递_06

消费者2的代码

public class dead03 {
    // 队列的名称
    public static final String DEAD_queue ="DEAD_QUEUE";

    public static void main(String[] args) throws Exception {
        // 创建信道
        Channel channel = RabbitmqUtil.getChannel();
        System.out.println("channel = " + channel);
        DeliverCallback deliverCallback = (consumerTag,message) ->{
            System.out.println("message = " + new String(message.getBody(),"utf-8"));
        };
        channel.basicConsume(DEAD_queue,true,deliverCallback,consumerTag ->{});

    }
}

最大长度代码

修改消费者1 的代码
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_消息传递_07
三个参数认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_java_08
启动生产者 让普通的先假死一下
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_spring_09

普通消费者拒绝的

由于我们发送的消息都是info+i i是数字
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_spring_10

我们可以再消费者1 的代码里修改一下
认识RabbitMq 第二篇 (交换机,死信队列,延迟队列)_spring_11

延迟队列

概念

延迟队列,队列内部是有序的,最重要的特殊性就体现在它的延时属性上,延时队列中的元素是希望在指定时间到了以后或之前取出和处理,简单来说 延时队列就是用来存放需要在指定时间被处理的元素的队列

整合Springboot 来做延迟队列的代码

pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>

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

        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <!--	<scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
        <!-- rabbitmq依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

配置swagger

@Configuration
//加入Swagger 的注解  ,开启
@EnableSwagger2
public class Swaggerconfig {
    //    配置Swagger 的 Docket 的bean 实例
    @Bean
    public Docket docket() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
//        RequestHandlerSelectors 配置要扫描接口的方式
//                basePackage :指定要扫描的包
//                any() :扫描全部
//                none():不扫描
//                withClassAnnotation //扫描类上的注解,参数市一个注解的反射对象
//                withMethodAnnotation // 扫描方法上的注解
//                。paths()过滤什么路径
                .apis(RequestHandlerSelectors.basePackage("com.jj.demo.Controller"))
                .build()
                ;
    }

    //    配置Swagger 信息
    private ApiInfo apiInfo() {
//        作者信息
        Contact contact = new Contact("娇娇", "", "1782579163@qq.com");
        return new ApiInfo(
                "娇娇的Api 文档", "生而为人,务必善良", "1.0", "", contact, "", "", new ArrayList<>()
        );
    }

}


yml 文件

spring:
  rabbitmq:
    port: 5672
    host: localhost
    username: guest
    password: guest

队列TTL

配置类的代码

public class TTLrABBIT {
    // 创建交换机的名称
    public static final String A_EXCHANGE ="A";
    public static final String DEAD_EXCHANGE ="B";
    // 创建队列
    public static final String QUEUE_A="QA";
    public static final String QUEUE_B="QB";
    // 死信队列的名称
    public static final String DEAD_LETTER_QUEUE ="QD";
    @Bean("A_EXCHANGE")
    public DirectExchange A_EXCHANGE () {
        return new DirectExchange(A_EXCHANGE);
    }
    @Bean("DEAD_EXCHANGE")
    public DirectExchange DEAD_EXCHANGE () {
        return new DirectExchange(DEAD_EXCHANGE);
    }
    @Bean("QUEUE_A")
    public Queue queuea () {
        HashMap<String, Object> map = new HashMap<>(3);
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        map.put("x-dead-letter-routing-key","fengjiaojiao");
        map.put("x-message-ttl",10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(map).build();
    }
    @Bean("QUEUE_B")
    public Queue QUEUE_B () {
        HashMap<String, Object> map = new HashMap<>(3);
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        map.put("x-dead-letter-routing-key","jiaojiao");
        map.put("x-message-ttl",40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(map).build();
    }
    @Bean("DEAD_LETTER_QUEUE")
    public Queue DEAD_LETTER_QUEUE () {
        return QueueBuilder.durable(DEAD_LETTER_QUEUE).withArguments(null).build();
    }
    @Bean

    public Binding QUEUE_A_A_EXCHANGE (@Qualifier("QUEUE_A") Queue queueA,@Qualifier("A_EXCHANGE") DirectExchange A_EXCHANGE) {
        return BindingBuilder.bind(queueA).to(A_EXCHANGE).with("fengjiaojiao");
    }
    @Bean
    public Binding QUEUE_B_B_EXCHANGE (@Qualifier("QUEUE_B") Queue queueB,@Qualifier("A_EXCHANGE") DirectExchange A_EXCHANGE) {
        return BindingBuilder.bind(queueB).to(A_EXCHANGE).with("jiaojiao");
    }
    @Bean
    public Binding DEAD_LETTER_QUEUE_D_EXCHANGE (@Qualifier("DEAD_LETTER_QUEUE") Queue DEAD_LETTER_QUEUE,@Qualifier("DEAD_EXCHANGE") DirectExchange DEAD_EXCHANGE) {
        return BindingBuilder.bind(DEAD_LETTER_QUEUE).to(DEAD_EXCHANGE).with("D");
    }
}

生产者代码

@RestController
@Slf4j
@RequestMapping("/ttl")
public class TTLController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
     @GetMapping ("/sendMsg/{message}")
    public void sengMsg (@PathVariable String message) {
         log.info("当前时间:{},发送一条消息:{}给两个TTL 队列 ",new Date().toString(),message);
         System.out.println("message = " + message);
         rabbitTemplate.convertAndSend("A","fengjiaojiao","来自10s 的队列"+message);
         rabbitTemplate.convertAndSend("A","jiaojiao","来自10s 的队列"+message);
     }
}

消费者代码

@Component
@Slf4j
public class DeadTTLConsumer {
    // 接收消息
    @RabbitListener(queues = "QD")
    public void receiveD (Message message, Channel channel) throws Exception {
        String msg = new String(message.getBody());
        log.info("当前时间:{},收到死信队列的消息:{}",new Date().toString(),msg);

    }
}