RabbitMQ使用场景及案例（七）

已于 2022-04-02 09:06:34 修改
阅读量1k 收藏 9
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq java
于 2021-10-10 22:42:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41979002/article/details/120692985
版权

一、场景介绍

可用于解耦、削峰、异步

异步处理 - 相比于传统的串行、并行方式，提高了系统吞吐量。
应用解耦 - 系统间通过消息通信，不用关心其他系统的处理。
流量削锋 - 可以通过消息队列长度控制请求量；可以缓解短时间内的高并发请 求。
日志处理 - 解决大量日志传输。
消息通讯 - 消息队列一般都内置了高效的通信机制，因此也可以用在纯的消息通 讯。比如实现点对点消息队列，或者聊天室等。

1.1 串行方式

串行方式：将订单信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端
在这里插入图片描述

public void makeOrder(){
    // 1 :保存订单 
    orderService.saveOrder();
    // 2： 发送短信服务
    messageService.sendSMS("order");//1-2 s
    // 3： 发送email服务
    emailService.sendEmail("order");//1-2 s
    // 4： 发送APP服务
    appService.sendApp("order");    
}

存在问题：
1：每完成一个订单，耗时时间长
2：若3、4步执行失败，造成事务回滚导致下单失败，得不偿失
3：非核心业务代码过多造成冗余

1.2 并行方式

并行方式：将订单信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间
在这里插入图片描述

public void makeOrder(){
    // 1 :保存订单 
    orderService.saveOrder();
   // 相关发送
   relationMessage();
}
public void relationMessage(){
    // 异步
     theadpool.submit(new Callable<Object>{
         public Object call(){
             // 2： 发送短信服务  
             messageService.sendSMS("order");
         }
     })
    // 异步
     theadpool.submit(new Callable<Object>{
         public Object call(){
              // 3： 发送email服务
            emailService.sendEmail("order");
         }
     })
      // 异步
     theadpool.submit(new Callable<Object>{
         public Object call(){
             // 4： 发送短信服务
             appService.sendApp("order");
         }
     })
      // 异步
         theadpool.submit(new Callable<Object>{
         public Object call(){
             // 4： 发送短信服务
             appService.sendApp("order");
         }
     })
}

存在问题：
1：耦合度高
2：需要自己写线程池自己维护成本太高
3：出现了消息可能会丢失，需要你自己做消息补偿
4：如何保证消息的可靠性你自己写
5：如果服务器承载不了，你需要自己去写高可用

1.3 异步消息队列的方式

在这里插入图片描述

public void makeOrder(){
    // 1 :保存订单 
    orderService.saveOrder();   
    rabbitTemplate.convertSend("ex","2","消息内容");
}

好处
1：完全解耦，用MQ建立桥接
2：有独立的线程池和运行模型
3：出现了消息可能会丢失，MQ有持久化功能
4：如何保证消息的可靠性，死信队列和消息转移的等
5：如果服务器承载不了，你需要自己去写高可用，HA镜像模型高可用。
按照以上约定，用户的响应时间相当于是订单信息写入数据库的时间，也就是50毫秒。注册邮件，发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。因此架构改变后，系统的吞吐量提高到每秒20 QPS。比串行提高了3倍，比并行提高了两倍

1.4 小结

使用消息中间件可以做到：
1、高内聚，低耦合
在这里插入图片描述
2、流量的削峰
在这里插入图片描述
3、分布式事务的可靠消费和可靠生产
4、索引、缓存、静态化处理的数据同步
5、流量监控
6、日志监控（ELK）
7、下单、订单分发、抢票

二、fanout模式案例演示

2.1 fanout模式图解

在这里插入图片描述

2.2 目标

在这里插入图片描述

2.3 生产者具体实现

2.3.1 创建生产者工程

在这里插入图片描述

2.3.2 pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springboot-rabbitmq-fanout-producer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

2.3.3 application.yml

# 服务端口
server:
  port: 8080
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: 192.168.229.128
    port: 5672

2.3.4 定义订单的生产者

package com.service;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
/**
 * @author: 学相伴-飞哥
 * @description: OrderService
 * @Date : 2021/3/4
 */
@Component
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrderFanout(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "fanout_order_exchange";
        String routeKey = "";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderNumer);
    }
 
}

2.3.5 配置类-绑定关系

package com.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Author : JCccc
 * @CreateTime : 2019/9/3
 * @Description :
 **/
@Configuration
public class FanoutRabbitConfig {

    //创建队列
    @Bean
    public Queue fanoutEmailQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("email.fanout.queue", true);
    }
    @Bean
    public Queue fanoutSmsQueue() {
        return new Queue("sms.fanout.queue", true);
    }
    @Bean
    public Queue fanoutWeixinQueue() {
        return new Queue("weixin.fanout.queue", true);
    }


    //创建交换机
    @Bean
    public FanoutExchange fanoutOrderExchange() {
        return new FanoutExchange("fanout_order_exchange", true, false);
    }


    //绑定关系
    @Bean
    public Binding fanoutEmailBinding() {
        return BindingBuilder.bind(fanoutEmailQueue()).to(fanoutOrderExchange());
    }
    @Bean
    public Binding fanoutSmsBinding() {
        return BindingBuilder.bind(fanoutSmsQueue()).to(fanoutOrderExchange());
    }
    @Bean
    public Binding fanoutWeixinBinding() {
        return BindingBuilder.bind(fanoutWeixinQueue()).to(fanoutOrderExchange());
    }
}

2.3.5 创建生产者测试类

package com.test;

import com.service.OrderService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutProducerApplicationTests {

    @Autowired
    OrderService orderService;

    @Test
    public void contextLoads() throws Exception {
        orderService.makeOrderFanout("1", "1", 12);
    }
}

2.4 消费者具体实现

2.4.1 创建消费者工程

在这里插入图片描述

2.4.2 引入同样pom的依赖

2.4.3 application.yml

# 服务端口
server:
  port: 8081
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: 192.168.229.128
    port: 5672

2.4.4 创建三个消费者

FanoutEmailService：

package com.service.fanout;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"email.fanout.queue"})
@Component
public class FanoutEmailService {
    // @RabbitHandler 代表此方法是一个消息接收的方法。该不要有返回值
    @RabbitHandler
    public void messagerevice(String message){
        // 此处省略发邮件的逻辑
        System.out.println("email-------------->" + message);
    }
}

FanoutSMSService：

package com.service.fanout;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"sms.fanout.queue"})
@Component
public class FanoutSMSService {
    @RabbitHandler
    public void messagerevice(String message){
        System.out.println("sms-------------->" + message);
    }
}

FanoutWeixinService：

package com.service.fanout;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"weixin.fanout.queue"})
@Component
public class FanoutWeixinService {

    @RabbitHandler
    public void messagerevice(String message){
        System.out.println("weixin-------------->" + message);
    }
}

2.4.5 消费者的主启动类

package com;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FanoutConsumer {

    public static void main(String[] args) {
        SpringApplication.run(FanoutConsumer.class, args);
    }
}

2.5 测试流程

1、先启动生产者（因为配置类定义在生产者一端，所以若先启动消费者会出现找不到队列的报错信息；解决方案：可以将配置类复制一份到消费者端）
2、启动消费者
3、查看消息是否成功消费

2.6 测试结果

本案例采用的是发布-订阅模式，因此三个消费者都消费了消息，并执行了自己的相关代码。

三、Direct模式案例演示

3.1 Direct模式图解

在这里插入图片描述

3.2 生产者具体实现

这里只介绍关键步骤，其他步骤参考fanout模式

3.2.1 创建Direct的配置类

package com.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Author : JCccc
 * @CreateTime : 2019/9/3
 * @Description :
 **/
@Configuration
public class DirectRabbitConfig {

    //创建队列
    @Bean
    public Queue directEmailQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("email.direct.queue", true);
    }
    @Bean
    public Queue directSmsQueue() {
        return new Queue("sms.direct.queue", true);
    }
    @Bean
    public Queue directWeixinQueue() {
        return new Queue("weixin.direct.queue", true);
    }


    //创建交换机
    @Bean
    public DirectExchange directOrderExchange() {
        return new DirectExchange("direct_order_exchange", true, false);
    }


    //绑定关系
    @Bean
    public Binding directEmailBinding() {
        return BindingBuilder.bind(directEmailQueue()).to(directOrderExchange()).with("email");
    }
    @Bean
    public Binding directSmsBinding() {
        return BindingBuilder.bind(directSmsQueue()).to(directOrderExchange()).with("sms");
    }
    @Bean
    public Binding directWeixinBinding() {
        return BindingBuilder.bind(directWeixinQueue()).to(directOrderExchange()).with("weixin");
    }
}

3.2.2 订单生产者

package com.service;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
/**
 * @author: 学相伴-飞哥
 * @description: OrderService
 * @Date : 2021/3/4
 */
@Component
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrderFanout(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "fanout_order_exchange";
        String routeKey = "";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderNumer);
    }

    public void makeOrderDirect(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "direct_order_exchange";
        rabbitTemplate.convertAndSend(exchangeName, "email", orderNumer);
        rabbitTemplate.convertAndSend(exchangeName, "sms", orderNumer);
    }
 
}

3.2.3 生产者测试类

package com.test;

import com.service.OrderService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutProducerApplicationTests {

    @Autowired
    OrderService orderService;

    @Test
    public void contextLoads() throws Exception {
        orderService.makeOrderFanout("1", "1", 12);
    }

    @Test
    public void contextLoads2() throws Exception {
        orderService.makeOrderDirect("1", "1", 12);
    }

    
}

3.3 消费者具体实现

3.3.1 创建三个消费者

在这里插入图片描述

DirectEmailService：

package com.service.direct;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"email.direct.queue"})
@Component
public class DirectEmailService {
    // @RabbitHandler 代表此方法是一个消息接收的方法。该不要有返回值
    @RabbitHandler
    public void messagerevice(String message){
        // 此处省略发邮件的逻辑
        System.out.println("email-------------->" + message);
    }
}

DirectSMSService：

package com.service.direct;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"sms.direct.queue"})
@Component
public class DirectSMSService {
    @RabbitHandler
    public void messagerevice(String message){
        System.out.println("sms-------------->" + message);
    }
}

DirectWeixinService：

package com.service.direct;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

// bindings其实就是用来确定队列和交换机绑定关系
@RabbitListener(queues = {"weixin.direct.queue"})
@Component
public class DirectWeixinService {

    @RabbitHandler
    public void messagerevice(String message){
        System.out.println("weixin-------------->" + message);
    }
}

3.4 测试结果

本案例采用的是匹配路由key模式，因此只有符合匹配路由的消费者能消费到消息。

即email和sms队列有消息，weixin队列内无消息。

四、topic模式案例演示

4.1 topic模式图解

在这里插入图片描述

4.2 特别说明

这个说明下，前面两个案例都是采用配置类的方式实现交换机和队列的创建和绑定，因此特地用此案例来演示一下注解方式实现。

4.3 生产者具体实现

由于采用注解方式，不需要创建配置类，因此只需要创建订单生产者和测试类即可

4.3.1 订单生产者

package com.service;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
/**
 * @author: 学相伴-飞哥
 * @description: OrderService
 * @Date : 2021/3/4
 */
@Component
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrderFanout(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "fanout_order_exchange";
        String routeKey = "";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderNumer);
    }

    public void makeOrderDirect(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "direct_order_exchange";
        rabbitTemplate.convertAndSend(exchangeName, "email", orderNumer);
        rabbitTemplate.convertAndSend(exchangeName, "sms", orderNumer);
    }

    public void makeOrderTopic(String userId, String productId, int num) {
        // 1： 模拟用户下单
        String orderNumer = UUID.randomUUID().toString();

        // 2: 下单完成以后
        System.out.println("用户 " + userId + ",订单编号是：" + orderNumer);

        // 发送订单信息给RabbitMQ
        String exchangeName = "topic_order_exchange";
        //#0或多，*1或多
        //#.email.#
        //#.sms.*
        //weixin.#
        String routingKey = "sms.email";
        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderNumer);
    }
}

4.3.2 生产者测试类

package com.test;

import com.service.OrderService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutProducerApplicationTests {

    @Autowired
    OrderService orderService;

    @Test
    public void contextLoads() throws Exception {
        orderService.makeOrderFanout("1", "1", 12);
    }

    @Test
    public void contextLoads2() throws Exception {
        orderService.makeOrderDirect("1", "1", 12);
    }

    @Test
    public void contextLoads3() throws Exception {
        orderService.makeOrderTopic("1", "1", 12);
    }
}

4.4 消费者具体实现

4.4.1 创建三个消费者

TopicEmailService：

package com.service.topic;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 使用注解的方式来创建绑定交换机和队列,若没有则会创建
 */
@RabbitListener(bindings =@QueueBinding(
        value = @Queue(value = "email.topic.queue",autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "#.email.#"
))
@Component
public class TopicEmailService {
    // @RabbitHandler 代表此方法是一个消息接收的方法。该不要有返回值
    @RabbitHandler
    public void messagerevice(String message){
        // 此处省略发邮件的逻辑
        System.out.println("emailtopic-------------->" + message);
    }
}

TopicSMSService：

package com.service.topic;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

@RabbitListener(bindings =@QueueBinding(
        value = @Queue(value = "sms.topic.queue",autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "#.sms.*"
))
@Component
public class TopicSMSService {
    // @RabbitHandler 代表此方法是一个消息接收的方法。该不要有返回值
    @RabbitHandler
    public void messagerevice(String message){
        // 此处省略发邮件的逻辑
        System.out.println("smstopic-------------->" + message);
    }
}

TopicWeixinService：

package com.service.topic;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

@RabbitListener(bindings =@QueueBinding(
        value = @Queue(value = "weixin.topic.queue",autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "weixin.#"
))
@Component
public class TopicWeixinService {
    @RabbitHandler
    public void messagerevice(String message){
        System.out.println("weixintopic-------------->" + message);
    }
}

4.4.2 简单介绍消费者

由上述代码可以见，交换机和队列的创建和绑定都在消费者这一端实现了，通过注解的方式。

4.5 测试结果

也能实现模糊匹配路由key。

五、总结

1、交换机和队列的创建和绑定配置类，应该定义在消费者还是生产者那边？
2、使用配置类方式还是使用注解方式好？

本人意见：
1：可以在两端都添加好配置，生产者一端可随意，但消费者一端必须添加，因为大多数情况，我们都是先启动消费者的。但还是视情况而定。
2：推荐使用配置类方式，因为配置类方式逻辑比较清晰，代码内聚方便管理，而且后续对消息和队列设置TTL属性时也较为方便和直观。

沉泽·
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rabbit MQ 的使用实例
pengweismile的专栏
05-08 1473
1. 创建一个User , Allen 2. 创建一个Virtual Host 3. 为User设置访问Virtual hosts权限 4. 使用Allen 这个user创建一个Queue 名字为Allen_Msg_Queue。 注意需要退出当前登录然后用Allen这个用户登录进去创建 5. 使用procedcer 往这个queue上面发送msg public class Producer { public static void main(.
rabbitMQ（四）应用场景
A_droid的博客
11-02 208
一，服务解耦 两个高耦合的服务，通过消息中间件的使用，从而变成低耦合。 例子：订单系统需要和库存系统配合实现业务。 订单系统的业务需要使用到库存系统的服务，但是，当使用库存系统出现错误，或者库存系统某一段时间内，不可用，那么随之造成的结果是，订单系统也变成不可用了。 引入消息队列后： 订单系统把订单信息发送到消息队列里边，即可给客户反馈下单操作完成，不需要等待库存系统的响应。同样的，库存系统只需要负责从消息队里里边取出信息即可，如果在处理过程中发生错误了，只需要再通知客户即可。当客户.
rabbitmq完整例子
08-13
rabbitmq完整例子，包含客户端、服务端例子。里面集中了各种案例详解
RabbitMQ 七种队列模式应用场景案例分析（通俗易懂）
Java知音
04-06 593
作者：我思知我在blog.csdn.net/qq_32828253/article/details/110450249七种模式介绍与应用场景简单模式（Hello World）做最简单的事情...
RabbitMQ —— 理解及应用场景
最新发布
小蜜蜂vs码农
06-22 2048
RabbitMQ —— 理解及应用场景
4、RabbitMQ---六大模式之简单队列模式
weixin_45608577的博客
07-19 256
本节我们将用 Java 编写两个程序。发送单个消息的生产者和接收消息并打印 出来的消费者。 1、创建一个maven工程并且添加依赖 <!--指定 jdk 编译版本--> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId>
消息中间件（二）MQ使用场景
热门推荐
jcpp9527的博客
08-29 1万+
一、消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ 二、消息队列应用场景 以下介绍消息队列在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景。     ...
RabbitMQ应用场景与实例
JinXYan的博客
05-25 5479
Publisher：是Message的生产者，Publisher这个Clients产生了一些Message。 Consumer：Message的消费者，Publisher产生的Message，最终要到达Consumer这个Clients，进行消费。 Exchange： 指定消息按什么规则，路由到哪个Queue，Message消息先要到达Exchange，在Server中承担着从Produce接...
rabbitMQ代码案例
07-04
1. **可编辑-商谈PPT.pptx**：这可能是一个关于RabbitMQ商业应用的演示文稿，详细介绍了RabbitMQ在业务场景中的使用策略和最佳实践，对于理解RabbitMQ如何助力企业提升效率和灵活性具有指导意义。 2. **rabbitMQ**：...
RabbitMQ 典型应用场景实战
猿码天地
03-02 8647
一、实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 二、RabbitMQ 官网拜读 首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一定的收获，地址可见：RabbitMQ 官网 阅读该手册过程中，我们可以得知 RabbitMQ 其实核心就
rabbitMQ的使用场景和代码案例
06-01
以下是一些RabbitMQ的使用场景和代码案例： 1. 应用解耦：将消息发送到RabbitMQ消息队列中，其他应用程序可以根据需要接收这些消息，从而实现应用解耦。 2. 异步处理：将任务放入RabbitMQ消息队列中，异步处理任务...
rabbitmq实战中的案例-rabbitmq-study.zip
11-07
下面，我们将深入探讨RabbitMQ的核心概念、功能及其在实际应用中的使用场景。 首先，理解RabbitMQ的基本工作原理至关重要。RabbitMQ是一个中间件，它充当生产者和消费者之间的桥梁。生产者将消息发送到RabbitMQ...
RabbitMQ的基本使用，进行实例案例的消息队列
SAME_LOVE的博客
01-19 2529
RabbitMQ是一种开源的消息代理和队列服务器，用于通过简单和可扩展的方式在分布式系统中传递消息。它实现了高级消息队列协议（AMQP）。服务之间最常见的通信方式是直接调用彼此来通信,消息从一端发出后立即就可以达到另一端,称为即时消息通讯(同步通信)消息从某一端发出后,首先进入一个容器进行临时存储,当达到某种条件后,再由这个容器发送 给另一端,称为延迟消息通讯(异步通信)一个提供统一消息服务的应用层标准高级消息队列协议,是一个通用的应用层协议。
RabbitMq简单使用案例
wh2574021892的博客
04-28 481
1.打开rabbitMq后台管理网址 2.在此处创建队列 3.创建交换机 type此处我们选择direct即可,具体type释义请看 rabbitMq交换机type 4.创建交换机与队列的绑定策略 注:上述操作也可以通过代码在项目里完成配置 那么到此为止简单的后台策略是创建完成了，下面我们回到项目中。 5.在配置文件中填写配置信息 在类中将rabbitMq的操作类注入进来 简单的发送案例 ...
RabbitMQ 简使用案例
梓鸿
11-25 302
第一步导入依赖 ： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>3.4.1</version>...
RabbitMQ使用案例
qq_40068304的博客
12-29 3075
一.简单模式(队列-->交换机) yml配置: server: port: 8088 spring: rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest publisher-confirm-type: correlated #消息确认方式,通过 correlated 来确认(将来的消息中才会带 correlation_id,只有通过 correlation_
RabbitMQ简单使用案例
weixin_45229007的博客
09-28 695
RabbitMQ 2、批量确认模式，与单个相比，可以极大地提高吞吐量。但缺点很明显，当有故障时，无法定位那个消息出问题了。这种方案仍然是同步的。1、单个确认模式 效率很慢。效率最好,性价比最高，最常用。
RabbitMQ——Hello World
前尘忆梦的博客
04-25 656
文章目录1、RabbitMQ四个核心概念1.1、四大核心概念1.2、各个名词介绍1.3、安装2、Hello World2.1、依赖2.2、消息生产者 1、RabbitMQ四个核心概念 RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。 RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。 1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值