DirectExchange直连交换机

已于 2023-08-29 17:30:32 修改
阅读量343 收藏
点赞数
分类专栏： rabbitMQ 文章标签： 网络 spring boot 后端 java rabbitmq
于 2023-08-25 13:16:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45326523/article/details/132492672
版权

目录

一、简介

二、使用步骤

三、demo

父pom文件

pom文件

配置文件

config

过期时间

消费者

生产者

测试

四、多个消费者获取生产者发送的所有消息

一、简介

直连型交换机，根据消息携带的路由键将消息投递给对应队列。

大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。

然后当一个消息携带着路由值为abc，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值abc去寻找绑定值也是X的队列。 

二、使用步骤

*
 * 步骤：
 * 1、交换机注入bean
 * 2、队列注入bean
 * 3、队列与交换机绑定
 * 注意:虽然交换机、队列、绑定关系都已注入bean中,但是rabbitMQ中还是没有创建的交换机和队列。
 *     那是因为消费者还未创建,当消费者创建并与队列绑定后就能在rabbitMQ服务中看到创建的交换机和队列;
 *     那么,若想在rabbitMQ服务中查看到创建的交换机和队列,还需要第4步,创建消费者
 * 4、创建消费者consumer

三、demo

 父pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
<!--        <version>2.2.5.RELEASE</version>-->
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.chensir</groupId>
    <artifactId>spring-boot-rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-rabbitmq</name>

    <properties>
        <java.version>8</java.version>
        <hutool.version>5.8.3</hutool.version>
        <lombok.version>1.18.24</lombok.version>
    </properties>

    <description>spring-boot-rabbitmq</description>

    <packaging>pom</packaging>

    <modules>
        <module>direct-exchange</module>
        <module>fanout-exchange</module>
        <module>topic-exchange</module>
        <module>game-exchange</module>
        <module>dead-letter-queue</module>
        <module>delay-queue</module>
        <module>delay-queue2</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


</project>

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.chensir</groupId>
        <artifactId>spring-boot-rabbitmq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>direct-exchange</artifactId>

    <dependencies>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

server.port=8081

logging.level.com.chensir=debug
#host
spring.rabbitmq.host=121.40.100.66
#spring.rabbitmq.host=121.199.39.162

#默认5672
spring.rabbitmq.port=5672
#用户名
spring.rabbitmq.username=guest
#密码
spring.rabbitmq.password=guest
#连接到代理时用的虚拟主机
spring.rabbitmq.virtual-host=/
#每个消费者每次可最大处理的nack消息数量 默认是250个 可在服务界面看到;意思是每批投递的数量
spring.rabbitmq.listener.simple.prefetch=1
#表示消息确认方式，其有三种配置方式，分别是none、manual(手动)和auto(自动)；默认auto
spring.rabbitmq.listener.simple.acknowledge-mode=auto
#是否开启自动重试 默认为false 不开启
spring.rabbitmq.listener.simple.retry.enabled=true
#最大重试次数
spring.rabbitmq.listener.simple.retry.max-attempts=5
#最大重试时间间隔
spring.rabbitmq.listener.simple.retry.max-interval=20000ms
#重试时间间隔
spring.rabbitmq.listener.simple.retry.initial-interval=2000ms
# 最大重试间隔*乘数
#应用于上一重试间隔的乘数 第一次(重试时间间隔)2s 4s 8s 16s 32s 此处32s>20s 以后都以20s为间隔 总的次数为最大重试次数
spring.rabbitmq.listener.simple.retry.multiplier=2
#决定被拒绝的消息是否重新入队；默认是true（与参数acknowledge-mode有关系）
spring.rabbitmq.listener.simple.default-requeue-rejected=false

config

在config中去注入交换机、队列、以及配置队列与交换机的绑定；

一个交换机可以有多个队列与之绑定；

一个队列可以多个消费者绑定消费;

下面为config注入bean的方式;还有种使用注解的方式(使用注解则不需要config配置,但是需要在每个消费者上使用注解配置,这样的缺点有不方便管理)

config注入

package com.chensir.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * 步骤：
 * 1、交换机注入bean
 * 2、队列注入bean
 * 3、队列与交换机绑定
 * 注意:虽然交换机、队列、绑定关系都已注入bean中,但是rabbitMQ中还是没有创建的交换机和队列。
 * 那是因为消费者还未创建,当消费者创建并与队列绑定后就能在rabbitMQ服务中看到创建的交换机和队列;
 * 那么,若想在rabbitMQ服务中查看到创建的交换机和队列,还需要第4步,创建消费者
 * 4、创建消费者consumer
 */
@Configuration
public class RabbitConfig {

    //交换机
    public static final String EXCHANGE_KEY = "DirectExchange-01";

    //队列
    public static final String QUEUE_KEY_01 = "DirectQueue-01";
    public static final String QUEUE_KEY_02 = "DirectQueue-02";
    public static final String QUEUE_KEY_03 = "DirectQueue-03";

    //routing
    public static final String ROUTING_KEY_01 = "Direct-RoutingKey-01";
    public static final String ROUTING_KEY_02 = "Direct-RoutingKey-02";
    public static final String ROUTING_KEY_03 = "Direct-RoutingKey-03";



    //解决对象类型乱码  默认的对象类型时base64
//    @Bean
//    public Jackson2JsonMessageConverter messageConverter() {
//        return new Jackson2JsonMessageConverter();
//    }

    /**
     * 直连交换机 一个交换机可绑定多个队列
     */
    @Bean
    public DirectExchange directExchange() {
        // name:交换机名称 durable:是否持久化 autoDelete:是否自动删除(没人用时是否自动删除)
        DirectExchange directExchange = new DirectExchange(EXCHANGE_KEY, true, false);
        return directExchange;
    }

    /**
     * 队列 一个队列可多个消费者使用
     *
     * @return
     */
    @Bean
    public Queue directQueue() {
        //autoDelete() 队列自动删除,当消费者不存在,队列自动删除;注意,这个并不常用!容易丢失消息(队列本来就是存放消息的,自动删除就没意义了)
//        Queue queue = QueueBuilder.durable("DirectQueue-01").autoDelete().build();
        //durable 持久化;持久化到server硬盘中; 使用这个后每次本地服务(项目)重启 rabbitMQ服务上会自动创建此队列
        Queue queue = QueueBuilder.durable(QUEUE_KEY_01).build();
        return queue;
    }

    /**
     * 队列2
     * @return
     */
    @Bean
    public Queue directQueue2() {
        Queue queue = QueueBuilder.durable(QUEUE_KEY_02).build();
        return queue;
    }

    /**
     * 队列 测试接收user对象
     * @return
     */
    @Bean
    public Queue directQueueUser() {
        Queue queue = QueueBuilder.durable(QUEUE_KEY_03).build();
        return queue;
    }

    /**
     * 绑定队列与交换机
     *
     * @return
     */
    @Bean
    public Binding binding() {
        //绑定directQueue这个队列给 directExchange 这个交换机
        Binding binding = BindingBuilder.bind(directQueue()).to(directExchange()).with(ROUTING_KEY_01);
        return binding;
    }

    /**
     * 也与交换机DirectExchange-01 绑定;一个交换机可以绑定多个队列
     *
     * @return
     */
    @Bean
    public Binding binding2() {
        Binding binding = BindingBuilder.bind(directQueue2()).to(directExchange()).with(ROUTING_KEY_02);
        return binding;
    }

    /**
     * 也与交换机DirectExchange-01 绑定;一个交换机可以绑定多个队列
     * 测试user对象
     *
     * @return
     */
    @Bean
    public Binding bindingQueueUser() {
        Binding binding = BindingBuilder.bind(directQueueUser()).to(directExchange()).with(ROUTING_KEY_03);
        return binding;
    }
}

过期时间

 使用ttl对‘队列’进行设置过期时间；若10s内消息未被消费则自动删除；(队列中消息均会被删除)不建议使用

 在生产者中对消息设置过期时间

注意：一般过期时间会结合者死信队列使用,当消息过期时将消息打到死信队列中

使用注解

 使用注解需要在消费者上使用注解并把交换机、队列、key值配置上去即可;

使用了注解方式就不需要在config中配置了。

  @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "DirectQueue-01",durable = "true",autoDelete = "false"),
            exchange = @Exchange(value = "DirectExchange-01",type = ExchangeTypes.DIRECT),
            key = "Direct-RoutingKey-01"
    ))
//    @RabbitListener(queues = {"DirectQueue-01","DirectQueue-02"})
    public void process2(Message message) {
        System.out.println(message);
        String test = new String(message.getBody());
        System.out.println("消费2消费了"+test);
    }

消费者

package com.chensir.consumer;

import cn.hutool.core.codec.Base32;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.chensir.config.RabbitConfig;
import com.chensir.model.User;


import lombok.extern.slf4j.Slf4j;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * 消费者
 */

@Component
@Slf4j
public class DirectConsumer {

//   注解示例
//    /**
//     * 使用注解方式 使消费者与交换机、队列绑定;使用了注解就无需在config中进行配置
//     * @param message
//     */
//    @RabbitHandler
//    @RabbitListener(bindings = @QueueBinding(
//            value = @Queue(value = "DirectQueue-01",durable = "true",autoDelete = "false"),
//            exchange = @Exchange(value = "DirectExchange-01",type = ExchangeTypes.DIRECT),
//            key = "Direct-RoutingKey-01"
//    ))
    @RabbitListener(queues = {"DirectQueue-01","DirectQueue-02"})
//    public void process2(Message message) {
//        System.out.println(message);
//        String test = new String(message.getBody());
//        System.out.println("消费2消费了"+test);
    }


    /**
     * 消费者process 消费DirectQueue-01队列;可多个消费之消费同一个队列
     *
     * @param message
     */
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.QUEUE_KEY_01)
//    @RabbitListener(queues = {"DirectQueue-01","DirectQueue-02"})
    public void process(String message) {
        System.out.println("消费1消费了" + message);
    }

    /**
     * 消费者process2 也消费DirectQueue-01队列;与消费者process验证多个消费者消费同一个队列
     * <p>
     * 通过验证发现,多个消费者消费同一个队列 会均摊队列中的消息;比如队列中有编号为1-10 10个队列
     * 那么,消费者1 可能消费编号为:1、3、5、7、9的消息, 消费者2 可能消费编号为:2、4、6、8、10
     *
     * @param message
     */
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.QUEUE_KEY_01)
    public void process2(Message message) {
        System.out.println(message);
        String test = new String(message.getBody());
        System.out.println("消费2消费了" + test);
    }

    /**
     * 消费者3去消费队列DirectQueue-02队列
     *
     * @param message
     */
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.QUEUE_KEY_02)
    public void process3(Message message) {
        System.out.println(message);
        String test = new String(message.getBody());
        System.out.println("消费3消费了" + test);
    }

    /**
     * 消费user类型 方式一
     *
     * @param message
     */
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.QUEUE_KEY_03)
    public void consumerUser(Message message) {
        String test = new String(message.getBody());
        System.out.println(test);

    }

    /**
     * 消费user类型 方式二
     *
     * @param message
     */
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.QUEUE_KEY_03)
    public void consumerUser2(String message) {

        User user = JSONUtil.toBean(message, User.class);
        String name = user.getName();
        System.out.println(user);
        System.out.println(name);
    }

}

生产者

package com.chensir.provider;

import cn.hutool.json.JSONUtil;
import com.chensir.config.RabbitConfig;
import com.chensir.model.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

/**
 * 生产者
 */
@Component
@Slf4j
public class DirectProvider {

    @Resource
    private RabbitTemplate rabbitTemplate;

    /**
     * 生产者-简单的发送消息 示例
     */
//    public void send0() {
//
//        // 往DirectExchange-01交换机中发送消息,交换机的密钥为Direct-RoutingKey-01
        rabbitTemplate.send("DirectExchange-01", "Direct-RoutingKey-01", "hello,rabbitMQ");
//        rabbitTemplate.convertAndSend("DirectExchange-01", "Direct-RoutingKey-01", "hello,rabbitMQ");
//    }

    /**
     * 生产者1,往routing1中(也就是队列1)投递消息
     */
    public void send1() {
        for (int i = 1; i < 11; i++) {

            rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_KEY, RabbitConfig.ROUTING_KEY_01, "生产者1-" + i);
        }

    }

    /**
     * 生产者2,往routing2中(也就是队列2)投递消息
     */
    public void send2() {
        for (int i = 1; i < 11; i++) {

            rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_KEY, RabbitConfig.ROUTING_KEY_02, "生产者2-" + i);
        }
    }

    /**
     * 生产者 发送一个对象
     */
    public void sendUser() {
        User user = User.builder()
                .id(1)
                .name("陈sir")
                .sex("男")
                .build();
        String s = JSONUtil.toJsonStr(user);

        Map<String,String> stringMap =new HashMap<>();
        stringMap.put("key","ss");

        rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_KEY, RabbitConfig.ROUTING_KEY_03, s);
    }

}

测试

 

四、多个消费者获取生产者发送的所有消息

 若使用多个消费者去和一个队列绑定,当生产者发送2个消息,则消费者会均摊; 比如一个生产者发送2个消息,而有两个消费者都绑定了同一个队列,此时消费者1和消费者2 会一人消费队列中的一个消息;不会说队列中的2个消息，消费者1和消费者2都能拿到并消费;

若想让多个消费者都能消费到消息，可以起两个队列,队列名不同,但此时交换机还是一个，队列起2个routingkey可以使用一个；

或者使用广播交换机

RabbitMQ系列--Direct Exchange
撸码社区的博客
08-03 571
RabbitMQ工作流程 左边是生产者，右边是消费者，中间红框内是RabbitMQ服务器，其中包括交换机以及消息队列 消费者发送消息给RabbitMQ服务器，交换机接收到消息，然后根据不同的交换机规则投递给消息队列，消费者订阅消息进行消费 RabbitMQ交换机类型 作用：接收消息，按照路由规则将消息路由到一个或者多个队列。如果路由不到，或者返回给生产者，或者直接丢弃。RabbitMQ常用的交换器常用类型有direct、topic、fanout三种，其他的由于性能不好等原因几乎用不到，后续主要介绍这
rabbitmq-direct exchange（直接交换器）
hsgao_water的博客
10-11 377
Direct exchange 直接交换器模式，其路由算法非常简单，一条消息只发送到完全匹配的队列。 我们使用以下几个实例来说明： 实例1 在这个直接交换器实例中，我们绑定了两个队列到交换器中，第一个队列使用绑定键orange，第二个队列使用black和green绑定键。 在这个实例中，路由键为“orange”的消息将被分发到队列Q1，路由键为”black”和“green”将被发到队...
RabbitMQ：交换机（direct exchange）
kaven
02-10 1926
Java初识RabbitMQ一交换机（direct exchange） 首先看看AMQP协议，对RabbitMQ的架构会更了解。 深入理解AMQP协议 创建一个Maven项目，根据自己服务器RabbitMQ的版本导入相应的包。 <dependency> <groupId>com.rabbitmq</groupId> <artifactId...
RabbitMQ安装使用（直接交换direct exchange）
08-10
NULL 博文链接：https://yuwenlin.iteye.com/blog/2204966
（一）安装RabbitMQ&概念&命令使用&快速起步
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
03-17 265
一个图： 交换机和Exchange 连接管道， 交换机定义： 直接交换机通过绑定绑定一个队列，带入那个必须完全匹配，发消息的时候，原来的时候 完全匹配，直接交换机器， 主题交换机： 最先的匹配上，topic交换机：绑定的视乎---tuling,key.*----队列 或者是井号，多个单词，发送消息的时候，带入的那个key和原来的绑定的 key完全匹配，路由队列的...
【RabbitMQ】直连交换机_扇形交换机_主题交换机
最新发布
wosixiaokeai的博客
08-06 1039
虽然主题交换机提供了灵活的路由策略，但在处理大量消息时可能会引入一定的性能开销。因此，在设计消息传递系统时，需要综合考虑性能需求和业务需求之间的平衡。：合理的路由键设计对于实现有效的消息路由至关重要。：在使用通配符时，需要注意它们的匹配规则。：将队列与主题交换机进行绑定，并指定绑定键。：生产者发送消息到主题交换机，并指定一个路由键。：使用RabbitMQ的API或管理界面声明一个主题交换机。：声明一个或多个队列，用于接收消息。的消息，该消息将被路由到所有绑定键与。结尾的路由键的消息。
RabbitMQ之直连交换机（Direct exchange）
qq_42212926的博客
04-04 1173
直连交换机 上一篇博客中讲解了扇形交换机，但是由于扇形交换机属于广播类型的交换机，如果我们需要一对一这种类型的发送接收消息，使用扇形交换机就不太合适，可以使用直连交换机。 直连交换机 直连交换机生产者代码 public class DirectLogs { //交换机的名称 public static final String EXCHANGE_NAME = "direct_logs"; public static void main(String[] args) throws E
交换机讲解，直连交换机，扇形交换机
m0_60375943的博客
02-25 2115
一，交换机 在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费 路由键（Routingkey） 生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则 绑定键（Bindingkey) 通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列 二，交换机类型 直接交换机：Direct exchange 直接交换机的路.
中间件系列五 RabbitMQ之Direct exchange（直连交换机）和路由
热门推荐
不积跬步无以至千里; 不积小流无以成江海
01-25 1万+
概述上篇文章，我们通过Fanout exchange（扇型交换机）实现生产者发送一个消息，这个消息同时被传送给所有队列。但是有时我们不希望所有的消息都被所有队列接收，我们希望可以指定类型为a的消息只能被队列A接收，类型为b的消息只能被队列B,C接收。扇型交换机只能无脑地广播消息给所有的消费者，实质是广播给所有关联的队列。 为了实现这个功能，一种是建立多个交换机，这种方式简单暴力但是不灵活。本节我们
SpringBoot整合RabbitMQ direct交换机、fanout交换机、topic交换机
熊孩子的博客
04-26 1340
SpringBoot整合RabbitMQ direct交换机、fanout交换机、topic交换机
RabbitMQ 在 Spring Boot 进阶之交换器 Direct Exchange
Anur IjuoKaruKas的博客
04-26 2085
上篇文章中我们只看到了的生产者的消息发送与消费者的消息消费，实际上它隐藏了rabbitMQ中一个重要的环节。 上篇文章中，我们在生产者中直接定义了消息送达队列的名字 @Component public class Sender { @Autowired private AmqpTemplate rabbitTemplate; public void send()...
RabbitMQ之Direct（直连）Exchange解读
一个菜鸡的博客
10-07 938
在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费路由键（Routingkey）生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则绑定键（Bindingkey)通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列Direct（直连）Exchange。
RabbitMq的交换机(Exchange)
qq_44424498的博客
01-03 850
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------>消费者 ...
SpringBoot集成rabbitMq 具体的编程操作 Direct Exchange
江枫暮雪的博客
06-21 253
SpringBoot集成rabbitMq 具体的编程操作
交换机的使用
AWildCat的博客
03-30 2062
交换机的使用 rabbitmq02 #主模块 rabbitmq-provider #生产者 rabbitmq-consumer #消费者 0.给子模块添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sprin...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4985
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
（1）关于RabbitMq 的 Direct Exchange 直连型交换机
分享日常bug
09-27 1315
在这个界面里面我们可以做些什么？可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。以上这些管理界面的操作在这篇暂时不做扩展描述，我想着重介绍后面实例里会使用到的。根据消息携带的路由键将消息投递给对应队列。大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时交换机就会根据这个路由值X去寻找绑定值也是X的队列。
rabbitmq 设计的概念介绍
每天积累一点，一年后你会发现，自己变化很大
08-18 1572
RabbitMQ是流行的开源消息队列系统，用erlang语言开发。我曾经对这门语言挺有兴趣，学过一段时间，后来没坚持。RabbitMQ是 AMQP（高级消息队列协议）的标准实现。如果不熟悉AMQP，直接看RabbitMQ的文档会比较困难。不过它也只有几个关键概念，这里简单介绍。 RabbitMQ的结构图如下： 概念说明： Broker：简单来说就是消息队列服务器实体。
使用Scapy向Mininet交换机注入流量 实验记录
weixin_34303897的博客
01-24 894
使用Scapy向Mininet交换机注入流量 实验记录 用Python脚本及Scapy库写了一个简单的流量生成脚本，并打算使用该脚本往Mininet中的OpenvSwitch交换机注入流量。拓扑图如下： h1(10.0.0.1) :h1-eth0 &lt;=&gt; s1-eth1: s1 :s1-eth2 &lt;=&gt; h2-eth0: h2(10.0.0.2) 生成流量的目的IP：nw_...
rabbitmq直连交换机
09-09
RabbitMQ是一个开源的消息中间件，它支持多种消息传递模式，包括直连交换机（Direct Exchange）。直连交换机是最简单的交换机类型之一，它根据消息的路由键（Routing Key）将消息发送到与该路由键完全匹配的绑定队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值