RabbitMQ总体结构、模式和集成代码

本文详细介绍了RabbitMQ中的六种消息模型,包括基本消息模型、Work模型、Fanout订阅模型、Direct路由模型和Topic主题模型等。并通过Spring Boot演示了如何实现这些模型。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

RabbitMQ总体结构

在这里插入图片描述
在这里插入图片描述
MQ概述
消息队列技术是分布式应用间交换信息的一种技术。

消息队列可驻留在内存或磁盘上,队列存储消息直到它们被应用程序读走。

通过消息队列,应用程序可独立地执行–它们不需要知道彼此的位置、或在继续执行前不需要等待接收程序接收此消息。

MQ主要作用是接受和转发消息。你可以想想在生活中的一种场景:当你把信件的投进邮筒,邮递员肯定最终会将信件送给收件人。我们可以把MQ比作 邮局和邮递员。

MQ和邮局的主要区别是,它不处理消息,但是,它会接受数据、存储消息数据、转发消息。

6种模式和集成代码(Springboot)

引用:https://blog.youkuaiyun.com/wz6178/article/details/92843468

RabbitMQ提供了6种消息模型,但是第6种其实是RPC,并不是MQ,因此不予学习。那么也就剩下5种。
在这里插入图片描述
1.基本消息模型:生产者–>队列–>一个消费者
2.work消息模型:生产者–>队列–>多个消费者共同消费
3.订阅模型-Fanout:广播,将消息交给所有绑定到交换机的队列,每个消费者都可以收到同一条消息
4.订阅模型-Direct:定向,把消息交给符合指定 rotingKey 的队列(路由模式)
5.订阅模型-Topic:通配符,把消息交给符合routing pattern(主题模式) 的队列
(3、4、5这三种都属于订阅模型,只不过进行路由的方式不同。)


pox.xml依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>1.5.2.RELEASE</version>
        </dependency>

一、简单队列(模式)

一个生产者对应一个消费者
在这里插入图片描述
生产者

 /*简单队列(模式)*/
 @Test
    public void contextLoads(){
        String msg = "这是一个简单队列模式";

        amqpTemplate.convertAndSend("spring.simple.queue", msg );

    }

消费者

@Component
public class SimpleListener {

    // 通过注解自动创建 spring.simple.queue 队列
    @RabbitListener(queuesToDeclare = @Queue("spring.simple.queue"))
    public void listen(String msg) {
        System.out.println("简单队列 接收到消息:" + msg);
    }
}

二、Work模式

一个生产者对应多个消费者
在这里插入图片描述
生产者

/*work 模式*/
    @Test
    public void work() throws InterruptedException {
        String msg = "这是一个work模式";
        for (int i = 0; i < 10; i++) {
            amqpTemplate.convertAndSend("spring.work.queue", msg + i);
        }
        Thread.sleep(5000);
    }

消费者

@Component
public class WorkListener {

    // 通过注解自动创建 spring.work.queue 队列
    @RabbitListener(queuesToDeclare = @Queue("spring.work.queue"))
    public void listen(String msg) {
        System.out.println("work模式 接收到消息:" + msg);
    }

    // 创建两个队列共同消费
    @RabbitListener(queuesToDeclare = @Queue("spring.work.queue"))
    public void listen2(String msg) {
        System.out.println("work模式二 接收到消息:" + msg);
    }
}

三、订阅模型-Fanout

订阅模型-Fanout也成为广播模式,流程如下
1.可以有多个消费者
2.每个消费者有自己的队列
3. 每个队列都要绑定到Exchange(交换机)
4. 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定。
5. 交换机把消息发送给绑定过的所有队列
6. 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
在这里插入图片描述

生产者

 /*订阅模型-Fanout*/
    @Test
    public void fanout() throws InterruptedException {
        String msg = "订阅模式";
        for (int i = 0; i < 10; i++) {
            // 这里注意细节,第二个参数需要写,否则第一个参数就变成routingKey了
            amqpTemplate.convertAndSend("spring.fanout.exchange", "", msg + i);
        }
        Thread.sleep(5000);
    }

消费者


@Component
public class FanoutListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.fanout.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.fanout.exchange",
                    ignoreDeclarationExceptions = "true",
                    type = ExchangeTypes.FANOUT
            )
    ))
    public void listen(String msg) {
        System.out.println("订阅模式1 接收到消息:" + msg);
    }

    // 队列2(第二个人),同样能接收到消息
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.fanout2.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.fanout.exchange",
                    ignoreDeclarationExceptions = "true",
                    type = ExchangeTypes.FANOUT
            )
    ))
    public void listen2(String msg) {
        System.out.println("订阅模式2 接收到消息:" + msg);
    }
}

四、订阅模型-Direct (路由模式)

在Fanout模式中,一条消息,会被所有订阅的队列都消费。但是,在某些场景下,我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。给特定的消费者消费
在Direct模型下:

1.队列与交换机的绑定,不能是任意绑定了,而是要指定一个RoutingKey(路由key)
2.消息的发送方在 向 Exchange发送消息时,也必须指定消息的 RoutingKey。
3.Exchange不再把消息交给每一个绑定的队列,而是根据消息的Routing Key进行判断,只有队列的 Routingkey与消息的 Routing key完全一致,才会接收到消息
在这里插入图片描述

生产者

/*订阅模型-Direct (路由模式)*/
    @Test
    public void direct() throws InterruptedException {
        String msg = "路由模式";
        for (int i = 0; i < 10; i++) {
            amqpTemplate.convertAndSend("spring.direct.exchange", "direct", msg + i);
        }
        Thread.sleep(5000);
    }

消费者

@Component
public class DirectListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.direct.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.direct.exchange",
                    ignoreDeclarationExceptions = "true"
            ),
            key = {"direct"}
    ))
    public void listen(String msg) {
        System.out.println("路由模式1 接收到消息:" + msg);
    }

    // 队列2(第二个人),key值不同,接收不到消息
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.direct2.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.direct.exchange",
                    ignoreDeclarationExceptions = "true"
            ),
            key = {"direct-test"}
    ))
    public void listen2(String msg) {
        System.out.println("路由模式2 接收到消息:" + msg);
    }
}

五、订阅模型-Topic (主题模式)

Topic类型的Exchange与Direct相比,都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符!

Routingkey 一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: user.insert
在这里插入图片描述
在这里插入图片描述

生产者

  /* 订阅模型-Topic (主题模式)*/
    @Test
    public void topic() throws InterruptedException {
        amqpTemplate.convertAndSend("spring.topic.exchange", "person.insert", "增加人员");
        amqpTemplate.convertAndSend("spring.topic.exchange", "person.delete", "删除人员");
        amqpTemplate.convertAndSend("spring.topic.exchange", "money.insert", "加钱");
        amqpTemplate.convertAndSend("spring.topic.exchange", "money.delete", "减钱");
        Thread.sleep(5000);
    }

消费者

@Component
public class TopicListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.topic.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.topic.exchange",
                    ignoreDeclarationExceptions = "true",
                    type = ExchangeTypes.TOPIC
            ),
            key = {"person.*"}
    ))
    public void listen(String msg) {
        System.out.println("person 接收到消息:" + msg);
    }

    // 通配规则不同,接收不到消息
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "spring.topic.queue", durable = "true"),
            exchange = @Exchange(
                    value = "spring.topic.exchange",
                    ignoreDeclarationExceptions = "true",
                    type = ExchangeTypes.TOPIC
            ),
            key = {"money.*"}
    ))
    public void listen2(String msg) {
        System.out.println("money Student 接收到消息:" + msg);
    }
}

死信队列

消费者

//在队列设置超时时间
 @RabbitListener(bindings = {
            @QueueBinding(value = @Queue(value = "liveQueue", arguments =
                    {@Argument(name = "x-dead-letter-exchange", value = "deadExchange"),
                            @Argument(name = "x-dead-letter-routing-key", value = "deadKey")
                            , @Argument(name = "x-message-ttl",value = "10000",type = "java.lang.Integer")
                           // ,@Argument(name = "x-max-length",value = "5",type = "java.lang.Integer")队列最大长度
                    }),//可以指定多种属性
                    exchange = @Exchange(value = "liveExchange"),
                    key = {"info", "error", "warning"}
            )
    })
    @RabbitHandler
    public void onMessage(Message message, Channel channel) throws Exception {
        long consumerTag = message.getMessageProperties().getDeliveryTag();
        System.out.println("收到消息");
        System.out.println(new String(message.getBody()));
        channel.basicNack(consumerTag, false, false);//拒绝消息,让消息进入死信交换机

    }


死信消费者

  @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue(value = "deadQueue"),
                    exchange = @Exchange(value = "deadExchange"),
                    key = "deadKey"
            )
    })
    public void receive2(Message message, Channel channel) throws IOException {
        System.out.println("我是一条死信:"+message);
        long consumerTag = message.getMessageProperties().getDeliveryTag();
      //  channel.basicAck(consumerTag,true);
    }

生产者

 	@Test
    public void dummy6(){
        MessagePostProcessor postProcessor = new MessagePostProcessor() {
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("4000");//在这里也可以设置超时时间,也可以设置x-message-ttl
                return message;
            }
        };
		this.rabbitTemplate.convertAndSend("liveExchange","info","我是一条消息",postProcessor);
    }

<think>好的,我需要帮助用户了解项目的整体代码结构实现细节。首先,用户提到的引用内容涉及Python对象、MVC架构微服务实践。结合这些信息,我应该构建一个综合性的代码架构说明,涵盖分层设计、关键模块实现细节。 首先,考虑分层架构。用户提到了MVC的不同理解,可能需要结合常见的分层模式,比如表示层、业务逻辑层数据访问层。同时,微服务的部分可能需要涉及服务拆分通信机制。引用[2]中的两种MVC流程可以结合起来,说明用户操作如何通过不同层次传递。 接下来是模块划分。用户可能需要了解模块的职责,比如用户模块、订单模块等,以及它们如何交互。此外,引用[1]提到的Python对象结构,可能需要在数据模型部分详细说明,比如使用ORM框架定义数据表结构。 技术栈部分需要明确使用的框架工具,比如Django或Flask,数据库选择MySQL或MongoDB,以及前端技术如Vue.js。同时,微服务相关的技术如DockerKubernetes也应提及,引用[3]中提到的微服务实践平衡理论的部分可以作为支撑。 实现细节方面,要包括配置管理、路由设计、业务逻辑处理、数据持久化API文档生成。例如,使用Flask的蓝图进行路由管理,结合SQLAlchemy实现ORM,这些都需要具体示例代码。同时,单元测试集成测试的部分可以引用[1]中的对象概念,说明如何测试各个模块。 最后,注意事项部分需要强调模块化、配置中心、监控文档的重要性,这些都是确保项目可维护性的关键。同时,根据用户提供的引用,合理插入引用标识,确保引用自然。 检查是否有遗漏,比如是否覆盖了用户可能关心的性能优化、扩展性等方面。确保回答结构清晰,分点明确,代码示例正确,并且引用恰当。</think># 项目总体代码架构及实现细节 以下以典型企业级Web项目为例,结合分层架构与模块化设计思想说明: --- ## 一、分层架构设计 ### 1. 表示层(Presentation Layer) - **前端框架**:采用Vue.js/React实现组件化开发,通过RESTful API与后端交互 - **路由管理**:使用Vue Router/React Router实现SPA路由跳转 - **状态管理**:Vuex/Redux管理全局状态 > *用户操作触发View层事件后,通过Controller处理逻辑并更新Model[^2]* ### 2. 业务逻辑层(Service Layer) ```python # 示例:订单服务类 class OrderService: def __init__(self, order_repository): self.repo = order_repository # 依赖注入仓储对象[^1] def create_order(self, user_id, items): # 验证库存、计算金额等业务逻辑 new_order = Order(user_id=user_id, items=items) return self.repo.save(new_order) ``` ### 3. 数据访问层(Data Access Layer) - **ORM框架**:使用SQLAlchemy/Django ORM实现对象关系映射 - **数据库连接池**:通过连接池管理MySQL/PostgreSQL连接 ```python # 示例:使用SQLAlchemy定义数据模型 class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) username = Column(String(50), unique=True) ``` --- ## 二、核心模块划分 | 模块名称 | 职责说明 | 关键技术点 | |---------------|--------------------------|-------------------------| | 用户模块 | 身份验证/权限管理 | JWT/OAuth2.0 | | 商品模块 | 商品信息管理 | ElasticSearch检索 | | 订单模块 | 交易流程控制 | 分布式事务(Seata) | | 支付模块 | 第三方支付对接 | 微信/支付宝SDK封装 | --- ## 三、技术栈选型 ### 1. 后端框架 - **Python**: Django/Flask + RESTful API设计 - **微服务架构**: 使用gRPC进行服务间通信[^3] ### 2. 基础设施 ```mermaid graph TD A[API Gateway] --> B[用户服务] A --> C[商品服务] A --> D[订单服务] B --> E[MySQL集群] C --> F[Redis缓存] D --> G[消息队列] ``` --- ## 四、关键实现细节 ### 1. 配置中心化 - 使用Nacos/Apollo管理多环境配置 - 敏感信息通过Vault加密存储 ### 2. 异常处理机制 ```python # 全局异常拦截器示例 @app.errorhandler(APIException) def handle_exception(e): return jsonify( code=e.code, msg=e.msg, data=e.data ), HTTP_STATUS_CODES.get(e.code, 500) ``` ### 3. 性能优化 - 数据库读写分离 - 热点数据Redis缓存 - 异步任务队列(Celery/RabbitMQ) --- ## 五、代码规范 1. 遵循PEP8/Pylint规范 2. 接口文档自动生成(Swagger/Redoc) 3. 单元测试覆盖率>80% ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值