RabbitMq架构设计原理

已于 2023-08-14 21:37:10 修改
阅读量1.1k 收藏 7
点赞数
文章标签： java-rabbitmq rabbitmq java
于 2023-04-14 16:00:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56265207/article/details/130155493
版权

文章目录

1、消息中间件

1.1、什么是消息中间件

消息中间件基于队列模型实现异步/同步传输数据

作用：

  • 支撑高并发
  • 异步解耦
  • 流量削峰
  • 降低耦合度

1.2、传统的HTTP请求有什么缺点

  • Http请求基于请求响应模型，高并发情况下，客户端发送大量的请求到服务器端可能导致服务器端请求堆积
  • Tomcat服务器处理每个请求都会有自己的独立的线程，如果超过最大线程数就会将该请求缓存到队列中，如果请求堆积过多的情况下，就会导致服务器崩溃。所以一般会在 nginx 入口处实现限流

在这里插入图片描述

  • Http请求处理业务逻辑比较耗时的情况下，就会导致客户端一直等待，阻塞等待过程中会导致客户端超时发生重试策略，可能会引发幂等性问题

接口是为Http协议的情况下，最好不要处理比较耗时的业务逻辑，耗时的业务逻辑应该交给多线程或者是MQ来处理

1.3、MQ的应用场景

  • 异步调用第三方服务发送短信

  • 处理一些比较耗时的操作

2、同步、多线程、以及MQ处理业务逻辑的区别

2.1、同步发送Http 请求

需求：客户端发送请求到服务器端，服务器端实现会员注册业务逻辑

1、插入会员数据需要1s

2、发送登录短信提醒 3s

3、发送新人优惠卷 3s

总共响应需要6s时间，可能会导致客户端阻塞6s，用户体验极其不好
在这里插入图片描述

2.2、多线程处理业务逻辑

插入会员数据之后单独开启一个线程异步处理发送短信和发送新人优惠卷业务

此时客户端只需要等待 1s

优点： 适合小项目实现异步

缺点： 多开线程会消耗服务器CPU资源

在这里插入图片描述

2.3、MQ实现业务逻辑

先向数据库中插入一条会员数据，然后向MQ中投递一个消息，MQ服务器再将消息推送给消费者异步解耦处理发送短信和发送优惠卷

在这里插入图片描述

Mq和多线程之间的区别

  • Mq可以实现异步解耦、流量削峰
  • 多线程也可以实现异步，但是消耗CPU资源，没有实现解耦

3、Mq消息中间件名词

  • Producer 生产者：投递消息到MQ服务器端

  • Consumer 消费者：从MQ服务器端获取消息处理业务逻辑

  • Broker MQ服务器端

  • Topic 主题：分类业务逻辑发送短信主题、发送优惠券主题

  • Queue 存放消息模型 队列 先进先出 后进后出原则 数组/链表

  • Message 生产者投递消息报文：json

4、简单实现Mq的思路

4.1、基于多线程队列简单实现Mq

思路：

  • 首先需要一个生产者线程将消息投递到Mq,这里用LinkedBlockingDeque<JSONObject>阻塞队列来模拟Mq
  • 然后需要一个消费者线程从Mq中拿到消息进行消费

代码：

public class ThreadMQ {

    private static LinkedBlockingDeque<JSONObject> msgs = new LinkedBlockingDeque<JSONObject>();

    public static void main(String[] args) {
        // 生产线程
        new Thread(()-> {
                try {
                    while (true) {
                        Thread.sleep(1000);
                        JSONObject data = new JSONObject();
                        data.put("userId", "123");
                        // 存入消息
                        msgs.offer(data);
                    }
                } catch (Exception e) {
                }
        }, "生产者").start();
        // 消费者线程
        new Thread(()-> {
                try {
                    while (true) {
                        JSONObject data = msgs.poll();
                        if (data != null) {
                            System.out.println(Thread.currentThread().getName() + "," + data);
                        }
                    }

                } catch (Exception e) {

                }

        }, "消费者").start();
    }
    /**
     * 运行结果:
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * 消费者,{"userId":"123"}
     * ...
     */
}

4.2、基于Netty实现Mq

思路：

1、生产者nettyClient端发送请求给MQ服务器端（nettyServer端）,MQ服务器端在将该消息内容发送给消费者

2、消费者nettyClient端与MQ服务器端（nettyServer端）保持长连接，MQ服务器端保存消费者连接

在这里插入图片描述

请求体格式：

body:{
    "msg":{
        "userId":"123456",
         "age":"23"
    },
    "type":"producer",  //类型
    "topic":""  //主题
}

生产者投递消息给MQ服务器端，MQ服务器端需要缓存该消息

如果mq服务器端宕机之后，消息如何保证不丢失

持久化机制

如果mq接收到生产者投递消息，如果消费者不在的情况下，该消息是否会丢失？

消息确认机制

答案是不会丢失，消息确认机制必须要消费者消费成功该消息之后，再通知Mq 服务器端删除该消息

  • Mq 服务器端将该消息推送消费者
  • 消费者此时已经和Mq 服务器保持长连接
  • 消费者主动拉取消息

Mq如何实现抗高并发思想

Mq消费者根据自身能力情况 ，拉取mq服务器端消息消费。默认的情况下是取出一条消息

缺点：存在延迟的问题

需要考虑mq消费者提高速率的问题：消费者实现集群、消费者批量获取消息即可。

Demo：

Mq 服务器端：

public class MayiktNettyMQServer {
    public void bind(int port) throws Exception {
        /**
         * Netty 抽象出两组线程池BossGroup和WorkerGroup
         * BossGroup专门负责接收客户端的连接, WorkerGroup专门负责网络的读写。
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap bootstrap = new ServerBootstrap();
        try {
            bootstrap.group(bossGroup, workerGroup)
                    // 设定NioServerSocketChannel 为服务器端
                    .channel(NioServerSocketChannel.class)
                    //BACKLOG用于构造服务端套接字ServerSocket对象，标识当服务器请求处理线程全满时，
                    //用于临时存放已完成三次握手的请求的队列的最大长度。如果未设置或所设置的值小于1，Java将使用默认值50。
                    .option(ChannelOption.SO_BACKLOG, 100)
                    // 服务器端监听数据回调Handler
                    .childHandler(new MayiktNettyMQServer.ChildChannelHandler());
            //绑定端口, 同步等待成功;
            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("当前服务器端启动成功...");
            //等待服务端监听端口关闭
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //优雅关闭 线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
        @Override
        protected void initChannel(SocketChannel ch) throws Exception {
            // 设置异步回调监听
            ch.pipeline().addLast(new MayiktNettyMQServer.MayiktServerHandler());
        }
    }
    //主业务逻辑
    public static void main(String[] args) throws Exception {
        int port = 9008;
        new MayiktNettyMQServer().bind(port);
    }
    private static final String type_consumer = "consumer";
    private static final String type_producer = "producer";
    private static LinkedBlockingDeque<String> msgs = new LinkedBlockingDeque<>();
    private static ArrayList<ChannelHandlerContext> ctxs = new ArrayList<>();

    // 生产者投递消息的：topicName
    public class MayiktServerHandler extends SimpleChannelInboundHandler<Object> {

        /**
         * 服务器接收客户端请求
         *
         * @param ctx
         * @param data
         * @throws Exception
         */
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, Object data)
                throws Exception {
            JSONObject clientMsg = getData(data);
            String type = clientMsg.getString("type");
            switch (type) {
                case type_producer:
                    producer(clientMsg);
                    break;
                case type_consumer:
                    consumer(ctx);
                    break;
            }
        }

        /**
         * 消费者
         * @param ctx
         */
        private void consumer(ChannelHandlerContext ctx) {
            // 保存消费者连接
            ctxs.add(ctx);
            // 主动拉取mq服务器端缓存中没有被消费的消息
            String data = msgs.poll();
            if (StringUtils.isEmpty(data)) {
                return;
            }
            // 将该消息发送给消费者
            byte[] req = data.getBytes();
            ByteBuf firstMSG = Unpooled.buffer(req.length);
            firstMSG.writeBytes(req);
            ctx.writeAndFlush(firstMSG);
        }

        /**
         * 生产者
         * @param clientMsg
         */
        private void producer(JSONObject clientMsg) {
            // 缓存生产者投递 消息
            String msg = clientMsg.getString("msg");
            msgs.offer(msg);

            //需要将该消息推送消费者
            ctxs.forEach((ctx) -> {
                // 将该消息发送给消费者
                String data = msgs.poll();
                if (data == null) {
                    return;
                }
                byte[] req = data.getBytes();
                ByteBuf firstMSG = Unpooled.buffer(req.length);
                firstMSG.writeBytes(req);
                ctx.writeAndFlush(firstMSG);
            });
        }

        private JSONObject getData(Object data) throws UnsupportedEncodingException {
            ByteBuf buf = (ByteBuf) data;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            return JSONObject.parseObject(body);
        }


        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.flush();
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {

            ctx.close();
        }
    }
}

客户端消费者端：

public class MayiktNettyMQConsumer {
    public void connect(int port, String host) throws Exception {
        //配置客户端NIO 线程组
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap client = new Bootstrap();
        try {
            client.group(group)
                    // 设置为Netty客户端
                    .channel(NioSocketChannel.class)
                    /**
                     * ChannelOption.TCP_NODELAY参数对应于套接字选项中的TCP_NODELAY,该参数的使用与Nagle算法有关。
                     * Nagle算法是将小的数据包组装为更大的帧然后进行发送，而不是输入一次发送一次，因此在数据包不足的时候会等待其他数据的到来，组装成大的数据包进行发送，虽然该算法有效提高了网络的有效负载，但是却造成了延时。
                     * 而该参数的作用就是禁止使用Nagle算法，使用于小数据即时传输。和TCP_NODELAY相对应的是TCP_CORK，该选项是需要等到发送的数据量最大的时候，一次性发送数据，适用于文件传输。
                     */
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new MayiktNettyMQConsumer.NettyClientHandler());
                        }
                    });

            //绑定端口, 异步连接操作
            ChannelFuture future = client.connect(host, port).sync();
            //等待客户端连接端口关闭
            future.channel().closeFuture().sync();
        } finally {
            //优雅关闭 线程组
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        int port = 9008;
        MayiktNettyMQConsumer client = new MayiktNettyMQConsumer();
        try {
            client.connect(port, "127.0.0.1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public class NettyClientHandler extends ChannelInboundHandlerAdapter {


        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {

            JSONObject data = new JSONObject();
            data.put("type", "consumer");
            // 生产发送数据
            byte[] req = data.toJSONString().getBytes();
            ByteBuf firstMSG = Unpooled.buffer(req.length);
            firstMSG.writeBytes(req);
            ctx.writeAndFlush(firstMSG);
        }

        /**
         * 客户端读取到服务器端数据
         *
         * @param ctx
         * @param msg
         * @throws Exception
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("消费者客户端接收到服务器端请求:" + body);
        }

        // tcp属于双向传输

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            ctx.close();
        }
    }
}

客户端生产者端：

public class MayiktNettyMQProducer {
    public void connect(int port, String host) throws Exception {
        //配置客户端NIO 线程组
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap client = new Bootstrap();
        try {
            client.group(group)
                    // 设置为Netty客户端
                    .channel(NioSocketChannel.class)
                    /**
                     * ChannelOption.TCP_NODELAY参数对应于套接字选项中的TCP_NODELAY,该参数的使用与Nagle算法有关。
                     * Nagle算法是将小的数据包组装为更大的帧然后进行发送，而不是输入一次发送一次，因此在数据包不足的时候会等待其他数据的到来，组装成大的数据包进行发送，虽然该算法有效提高了网络的有效负载，但是却造成了延时。
                     * 而该参数的作用就是禁止使用Nagle算法，使用于小数据即时传输。和TCP_NODELAY相对应的是TCP_CORK，该选项是需要等到发送的数据量最大的时候，一次性发送数据，适用于文件传输。
                     */
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new MayiktNettyMQProducer.NettyClientHandler());
                        }
                    });

            //绑定端口, 异步连接操作
            ChannelFuture future = client.connect(host, port).sync();
            //等待客户端连接端口关闭
            future.channel().closeFuture().sync();
        } finally {
            //优雅关闭 线程组
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        int port = 9008;
        MayiktNettyMQProducer client = new MayiktNettyMQProducer();
        try {
            client.connect(port, "127.0.0.1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public class NettyClientHandler extends ChannelInboundHandlerAdapter {


        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {

            JSONObject data = new JSONObject();
            data.put("type", "producer");
            JSONObject msg = new JSONObject();
            msg.put("userId", "123456");
            msg.put("age", "23");
            data.put("msg", msg);
            // 生产发送数据
            byte[] req = data.toJSONString().getBytes();
            ByteBuf firstMSG = Unpooled.buffer(req.length);
            firstMSG.writeBytes(req);
            ctx.writeAndFlush(firstMSG);
        }

        /**
         * 客户端读取到服务器端数据
         *
         * @param ctx
         * @param msg
         * @throws Exception
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("客户端接收到服务器端请求:" + body);
        }

        // tcp属于双向传输

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            ctx.close();
        }
    }
}

5、主流Mq区别对比

特性ActiveMQRabbitMQRocketMQkafka
开发语言javaerlangjavascala
单机吞吐量万级万级10万级10万级
时效性ms级us级ms级ms级以内
可用性高（主从架构）高（主从架构）非常高（分布式架构）非常高（分布式架构）
功能特性成熟的产品，在很多公司得到应用；有较多的文档；各种协议支持较好基于erlang开发，所以并发能力很强，性能极其好，延时很低管理界面较丰富MQ功能比较完备，扩展性佳只支持主要的MQ功能，像一些消息查询，消息回溯等功能没有提供，毕竟是为大数据准备的，在大数据领域应用广。

简单来说：小型的微服务应用可以选择使用RabbitMq，大型应用、数据量大的情况下就可以选择使用 RocketMq 或者 Kafka

6、RabbitMq

6.1、RabbitMq简单介绍

RabbitMq是实现了高级消息队列协议（AMQP）的开源消息代理软件，也称为面向对象的中间件

官网：https://www.rabbitmq.com/

在这里插入图片描述

1、点对点的队列（简单队列）

2、工作（公平性）队列模式

3、发布订阅模式

在这里插入图片描述

4、路由模式

5、通配符模式

6、RPC

6.2、RabbitMQ环境的基本安装

笔者觉得使用docker安装超级方便，所以介绍下Linux 中如何安装

1、拉取镜像

docker pull rabbitmq:3-management

2、运行MQ容器

docker run \
 -e RABBITMQ_DEFAULT_USER=itcast \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management

3、docker ps 查看镜像是否运行

4、然后就可以访问啦

6.3、Rabbitmq管理平台中心

RabbitMQ 管理平台地址 http://127.0.0.1:15672

默认账号:guest/guest 用户可以自己创建新的账号

像mysql有数据库的概念并且可以指定用户对库和表等操作的权限。那RabbitMQ呢？

RabbitMQ也有类似的权限管理。在RabbitMQ中可以虚拟消息服务器VirtualHost，每个VirtualHost相当月一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通

默认的端口 15672：rabbitmq管理平台端口号 http协议

默认的端口 5672： rabbitmq消息中间内部通讯的端口

默认的端口 25672： rabbitmq集群的端口号

6.4、RabbitMQ常见名词

  • Virtual Hosts：实现资源的隔离和权限的控制

  • 队列 ：存放我们消息

  • Exchange ：分派我们消息在那个队列存放起来 类似于nginx

6.5、快速入门RabbitMQ简单队列

首先需要在RabbitMQ平台创建Virtual Hosts 和队列

  • Virtual Hosts ：/meiteVirtualHosts

  • 队列：mayikt

创建连接：

public class RabbitMQConnection {

    /**
     * 创建连接
     *
     * @return
     * @throws IOException
     * @throws TimeoutException
     */
    public static Connection getConnection() throws IOException, TimeoutException {
        //1.创建connectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2.配置Host
        connectionFactory.setHost("192.168.181.103");
        //3.设置Port
        connectionFactory.setPort(5672);
        //4.设置账户和密码
        connectionFactory.setUsername("itcast");
        connectionFactory.setPassword("123321");
        //5.设置VirtualHost
        connectionFactory.setVirtualHost("/meiteVirtualHosts");
        return connectionFactory.newConnection();
    }
}

编写生产者代码：

public class Producer {
    private static final String QUEUE_NAME = "mayikt";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建一个新连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.设置channel
        Channel channel = connection.createChannel();
        //3.发送消息
        String msg = "哈哈哈";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        System.out.println("消息投递成功");
        channel.close();
        connection.close();
    }
}

编写消费者代码：

public class Consumer {
    private static final String QUEUE_NAME = "mayikt";

    public static void main(String[] args) throws IOException, TimeoutException, IOException, TimeoutException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
                // 消费者完成 消费该消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 3.监听队列
        channel.basicConsume(QUEUE_NAME, false, defaultConsumer);

    }
}

启动生产者并投递两次消息：

在这里插入图片描述

此时mq控制台：

在这里插入图片描述

然后启动消费者：

在这里插入图片描述

再看mq 控制台：

在这里插入图片描述

消息被成功消费

6.6、RabbitMQ如何保证消息不丢失

Mq如何保证消息不丢失：

1、 生产者角色

  • 确保生产者投递消息到MQ服务器端成功。

2、 消费者角色

在rabbitmq情况下：

  • 必须要将消息消费成功之后，才会将该消息从mq服务器端中移除。

在kafka中的情况下：

  • 不管是消费成功还是消费失败，该消息都不会立即从mq服务器端移除。

3、 Mq服务器端 在默认的情况下 都会对队列中的消息实现持久化，持久化硬盘。

使用消息确认机制+持久化

A.消费者确认收到消息机制

channel.basicConsume(QUEUE_NAME, false, defaultConsumer);

注：第二个参数值为false代表关闭RabbitMQ的自动应答机制，改为手动应答。

在处理完消息时，返回应答状态。

channel.basicAck(envelope.getDeliveryTag(), false);

B.生产者确认投递消息成功 使用Confirm机制 或者事务消息

在这里插入图片描述

在这里插入图片描述

C.RabbitMQ默认创建是持久化的

在这里插入图片描述

代码中设置 durable为 true

参数名称详解：

  • durable是否持久化 : durable为持久化、 Transient 不持久化

  • autoDelete 是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

Demo

生产者：

public class Producer {
    private static final String QUEUE_NAME = "mayikt";

    public static void main(String[] args) {
        try {
            //1.创建一个新连接
            Connection connection = RabbitMQConnection.getConnection();
            //2.设置channel
            Channel channel = connection.createChannel();
            //3.发送消息
            String msg = "哈哈哈";
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            boolean result = channel.waitForConfirms();
            if (result) {
                System.out.println("消息投递成功");
            } else {
                System.out.println("消息投递失败");
            }
            channel.close();
            connection.close();
        } catch (Exception e) {

        }
    }
}

消费者：

public class Consumer {
    private static final String QUEUE_NAME = "mayikt";

    public static void main(String[] args) throws IOException, TimeoutException, IOException, TimeoutException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
                // 消费者完成 消费者通知给mq服务器端删除该消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 3.监听队列
        channel.basicConsume(QUEUE_NAME, false, defaultConsumer);
    }
}

6.7、RabitMQ工作队列模型

默认的传统队列是均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。

在这里插入图片描述

采用工作队列：

在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。

channel.basicQos(1);

6.8、RabbitMQ交换机

  • Direct exchange（直连交换机）

  • Fanout exchange（扇型交换机）

  • Topic exchange（主题交换机）

  • Headers exchange（头交换机）

再来理解下相关概念：

/Virtual Hosts 区分不同的团队

队列 存放消息

交换机 路由消息存放在那个队列中 类似于nginx

路由key 分发规则

6.8.1、fanout交换机

生产者发送一条消息，经过交换机转发到多个不同的队列，多个不同的队列就有多个不同的消费者。

在这里插入图片描述

在这里插入图片描述

原理：

  1. 需要创建两个队列 ，每个队列对应一个消费者；

  2. 队列需要绑定交换机；

  3. 生产者投递消息到交换机中，交换机再将消息分配给两个队列中都存放起来；

  4. 消费者从队列中获取这个消息。

Demo

生产者代码：

public class ProducerFanout {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true);
        String msg = "每特教育";
        channel.basicPublish(EXCHANGE_NAME, "", null, msg.getBytes());
        channel.close();
        connection.close();
    }

}

邮件消费者代码：

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "fanout_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

短信消费者：

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "fanout_email_sms";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

6.8.2、Direct路由模式

当交换机类型为direct类型时，根据队列绑定的路由键转发到具体的队列中存放消息

在这里插入图片描述

Demo

生产者代码：

public class ProducerDirect {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
        String msg = "每特教育";
        channel.basicPublish(EXCHANGE_NAME, "email", null, msg.getBytes());
        channel.close();
        connection.close();
    }

}

邮件消费者：

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "direct_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "email");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

短信消费者：

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "direct_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "sms");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

6.8.3、Topic 主题模式

当交换机类型为topic类型时，根据队列绑定的路由键模糊转发到具体的队列中存放。

在这里插入图片描述

Demo

生产者：路由key 是 mayikt.sms

public class ProducerTopic {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "topic", true);
        String msg = "每特教育";
        channel.basicPublish(EXCHANGE_NAME, "mayikt.sms", null, msg.getBytes());
        channel.close();
        connection.close();
    }

}

邮件消费者：路由key 是 mayikt.* ，与生产者可以匹配上，成功消费到消息

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "topic_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "mayikt.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

短信消费者：路由key 是meite.* 与生产者不能匹配， 消费不到消息

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "topic_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "meite.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);

    }
}

7、SpringBoot整合RabbitMq

1、导入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>
<dependencies>

    <!-- springboot-web组件 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 添加springboot对amqp的支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <!--fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>

2、配置类

@Component
public class RabbitMQConfig {
    /**
     * 定义交换机
     */
    private String EXCHANGE_SPRINGBOOT_NAME = "/mayikt_ex";


    /**
     * 短信队列
     */
    private String FANOUT_SMS_QUEUE = "fanout_sms_queue";
    /**
     * 邮件队列
     */
    private String FANOUT_EMAIL_QUEUE = "fanout_email_queue";

    /**
     * 配置smsQueue
     *
     * @return
     */
    @Bean
    public Queue smsQueue() {
        return new Queue(FANOUT_SMS_QUEUE);
    }

    /**
     * 配置emailQueue
     *
     * @return
     */
    @Bean
    public Queue emailQueue() {
        return new Queue(FANOUT_EMAIL_QUEUE);
    }

    /**
     * 配置fanoutExchange
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(EXCHANGE_SPRINGBOOT_NAME);
    }

    // 绑定交换机 sms
    @Bean
    public Binding bindingSmsFanoutExchange(Queue smsQueue, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(smsQueue).to(fanoutExchange);
    }

    // 绑定交换机 email
    @Bean
    public Binding bindingEmailFanoutExchange(Queue emailQueue, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(emailQueue).to(fanoutExchange);
    }
}

3、配置文件

spring:
  rabbitmq:
    ####连接地址
    host: 192.168.181.103
    ####端口号
    port: 5672
    ####账号
    username: itcase
    ####密码
    password: 123321
    ### 地址
    virtual-host: /meiteVirtualHosts

4、生产者

@RestController
public class FanoutProducer {

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * 发送消息
     *
     * @return
     */
    @RequestMapping("/sendMsg")
    public String sendMsg(String msg) {
        /**
         * 1.交换机名称
         * 2.路由key名称
         * 3.发送内容
         */
        amqpTemplate.convertAndSend("/mayikt_ex", "", msg);
        return "success";
    }
}

5、消费者

@Slf4j
@Component
@RabbitListener(queues = "fanout_email_queue")
public class FanoutEmailConsumer {

    @RabbitHandler
    public void process(String msg) {
        log.info(">>邮件消费者消息msg:{}<<", msg);
    }
}

@Slf4j
@Component
@RabbitListener(queues = "fanout_sms_queue")
public class FanoutSmsConsumer {

    @RabbitHandler
    public void process(String msg) {
        log.info(">>短信消费者消息msg:{}<<", msg);
    }
}

8、Mq如何获取消费结果

应该根据业务来定

消费者消费成功的结果：

  1. 能够在数据库中成功插入一条数据

  2. Rocketmq自带全局消息id，能够根据该全局消息获取消费结果

原理：

  • 生产者投递消息到mq服务器，mq服务器端在这时候返回一个全局的消息id，
  • 消费者消费该消息成功之后，消费者会给mq服务器端发送通知标记该消息消费成。
  • 生产者获取到该消息全局id，每隔2s时间调用mq服务器端接口 查询该消息是否有被消费成功。

异步返回一个全局id，前端使用ajax定时主动查询；

在rocketmq中，根据自带消息id查询是否消费成功

9、RabbitMQ死信队列

思维导图：

在这里插入图片描述

9.1、死信队列产生的背景

RabbitMQ死信队列俗称，备胎队列；

消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等

9.2、产生死信队列的原因

  • 消息投递到MQ中存放 消息已经过期 消费者没有及时的获取消息，

    消息如果存放到mq服务器中过期之后，会转移到备胎死信队列存放。

  • 队列达到最大的长度 （队列容器已经满了）

  • 消费者消费多次消息失败，就会转移存放到死信队列中

在这里插入图片描述

9.3、死信队列的架构原理

死信队列和普通队列区别不是很大

普通队列与死信队列都有自己独立的交换机和路由key、队列和消费者。

区别：

  1. 生产者投递消息先投递到普通交换机中，普通交换机再将该消息投到普通队列中缓存起来，普通队列对应有自己的独立普通消费者。

  2. 如果生产者投递消息到普通队列中，普通队列发现该消息一直没有被消费者消费的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机对应有自己独立的 死信队列 对应 独立死信消费者。

9.4、死信队列应用场景

  • 30分钟订单超时设计

  • Redis过期key

死信延迟队列实现：

  • 创建一个普通队列, 没有对应的消费者消费消息，在30分钟过后

    就会将该消息转移到死信备胎消费者实现消费。

  • 死信备胎消费者会根据该订单号码查询是否已经支付过，如果没有支付的情况下

    则会开始回滚库存操作。

10、RabbitMQ消息幂等问题

思维导图：

在这里插入图片描述

10.1、RabbitMQ消息自动重试机制

当消费者处理执行业务代码的时候，如果抛出异常的情况下,在这时候mq会自动触发重试机制，默认的情况下rabbitmq是无限次数的重试。

应该对RabbitMQ重试次数实现限制，比如最多重试5次，每次间隔3s；重试多次还是失败的情况下，存放到死信队列或者存放到数据库表中记录后期人工补偿

在什么情况下消费者需要实现重试策略？

  • 消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试？

    该情况下需要实现重试策略，网络延迟只是暂时调用不通，重试多次有可能会调用通。

  • 消费者获取消息后，因为代码问题抛出数据异常，是否需要重试？

    该情况下是不需要实现重试策略，就算重试多次，最终还是失败的。
    可以将日志存放起来，后期通过定时任务或者人工补偿形式。

如果是重试多次还是失败消息，需要重新发布消费者版本实现消费, 那么就可以使用死信队列。

Mq在重试的过程中，有可能会引发消费者重复消费的问题

Mq消费者需要解决

  • 幂等性问题 : 保证数据唯一

解决方式：

生产者在投递消息的时候，生成一个全局唯一id，放在消息中。

  • 消费者获取到该消息，可以根据该全局唯一id 实现去重复。

  • 全局唯一id 根据业务来定 比如订单号作为全局的唯一id

实际上还是需要在数据库层面解决数据防重复。

  • 业务逻辑是在做insert操作时 使用唯一主键约束

  • 业务逻辑是在做update操作 使用乐观锁

10.2、如何合理选择消息重试

  • 消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试 ？

  • 消费者获取消息后，应该代码问题抛出数据异常，是否需要重试？

总结：如果消费者处理消息时，因为代码原因抛出异常是需要从新发布版本才能解决的，那么就不需要重试，重试也解决不了该问题的。存放到死信队列或者是数据库表记录、后期人工实现补偿。

10.3、消费者重试过程中，如何避免幂等性问题

  • 重试的过程中，为了避免业务逻辑重复执行，建议根据全局id提前查询，如果存在

    的情况下，就无需再继续重试。

  • 重试的次数最好有一定间隔次数，在数据库底层保证数据唯一性，比如加上唯一id

King Gigi.
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
基于SpringCloud微服务架构社交系统的设计与实现
04-16
内容概要：该系统整体分为四大部分：数据处理、消息管理、社交管理、后台管理。数据处理主要包括数据爬取、智能分类两个模块。消息管理模块主要包括消息通知、即时通信两个模块。社交模块主要包括文章、问答、招聘、活动、吐槽等模块。采用 Docker 容器化部署方案， 融合了 Deeplearning4j 智能分类框架、Webmagic 爬虫框架、RabbitMQ、Jenkins 持续集成、IM 等技术。达到了预期的目的，具有实际的应用 适合人群：具备一定编程基础，工作1-3年的研发人员 能学到什么：①SpringCloud微服务框架、DL4J智能分类框架、Webmagic爬虫框架、RabbitMQ、Jenkins持续集成、IM、等是怎么在系统中体现的；②数据爬取、数据智能分类、消息通知微服务、即时通讯微服务、问答微服务、活动微服务、吐槽微服务、招聘微服务、头条微服务、交友微服务都是如何设计和实现的。 阅读建议：此资源以开发SpringCloud微服务架构社交系统学习其原理和内核，不仅是代码编写实现也更注重内容上的需求分析和方案设计，所以在学习的过程要结合这些内容一起来实践，并调试对应的代码。
基于Hadoop与RabbitMQ的人脸识别算法测试平台的设计与实现.docx
11-07
【原创学士学位毕业论文，未入库可过查重】万字原创，基于Hadoop架构类的学位毕业论文，适合本科专科毕业生使用。 内容概要： 本论文以Hadoop架构为基础，深入研究了其在大数据处理和分析方面的应用。通过对Hadoop的原理和相关技术的分析，探讨了其在数据存储、计算和处理等方面的优势和局限性。同时，通过实际案例研究，展示了Hadoop在实际场景中的应用和效果。 适用人群： 本论文适合计算机科学与技术、软件工程等相关专业的本科专科毕业生，以及对大数据处理和分析感兴趣的学习者。 使用场景及目标： 本论文旨在帮助读者深入了解Hadoop架构的原理和应用，以及在大数据处理和分析方面的优势。读者可以通过学习本论文，掌握Hadoop的基本概念、工作原理和核心组件，了解其在实际场景中的应用，并能够根据需求进行相应的配置和优化。 其他说明： 本论文采用了系统化的研究方法，包括文献综述、理论分析和实证研究等，以确保论文的科学性和可靠性。同时，为了保证论文的原创性，采用了严格的查重措施，确保未入库，可通过查重系统。 关键词：Hadoop架构、大数据处理、分布式计算、数据存储、数据分析
RabbitMQ架构设计原理
最新发布
m0_63432840的博客
05-16 911
消息中间件基于队列模型实现异步/同步传输数据作用：可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。
RabbitMQ架构详解
刘皇叔说Java的博客
03-08 1635
RabbitMQ是⼀个高可用的消息中间件，支持多种协议和集群扩展。并且支持消息持久化和镜像队列，适用于对消息可靠性较高的场合官网https://www.rabbitmq.com/getstarted.html。
RabbitMQ 架构原理
qq_33816292的博客
07-10 964
1.RabbitMQ 架构原理 由于 RabbitMQ 实现了 AMQP 协议，所以 RabbitMQ 的工作模型也是基于 AMQP 的。理解这张图片至关重要。 1.1 Broker 中介 我们要使用 RabbitMQ 来收发消息，必须要安装一个 RabbitMQ 的服务，可以安 装在 Windows 上面也可以安装在 Linux 上面，默认是 5672 的端口。这台 RabbitMQ 的服务器我们把它叫做 Broker，中文翻译是代理/中介，因为 MQ 服务器帮助我们做 的事情就是存储、转发消息。 1.2
RabbitMQ的基本架构与实现原理
李嘉图呀李嘉图的博客
12-16 3024
RabbitMQ整体逻辑架构 1.RabbitMQ Exchange类型 常用的交换器类型分为：Direct、Topic、Fanout、Header 四种。 Fanout fanout类型的交换器会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中，如图： Direct direct类型的交换器会把发送到该交换器的消息路由到BindingKey 与 RoutingKey完全匹配的队列中，如图： Topic topic类型的交换器在direct的匹配规则上进行了拓展，...
事务的理解
努力和遗憾，哪个更让你痛苦？
03-21 447
事务是恢复和并发控制的基本单位。 事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 隔离性（isolation）
MQ 的基本原理
z_ssyy的博客
05-04 2463
对于 MQ 来说，不管是 RocketMQ、Kafka 还是其他消息队列，下面我们以这个本质作为根，一起由浅入深地聊聊 MQ。01 从 MQ 的本质说起将 MQ 掰开了揉碎了来看，都是「一发一存一消费」，再直白点就是一个「转发器」。生产者先将消息投递一个叫做「队列」的容器中，然后再从这个容器中取出消息，最后再转发给消费者，仅此而已。上面这个图便是消息队列最原始的模型，它包含了两个关键词：消息和队列。
RabbitMQ的架构模型
m0_69234258的博客
11-14 1734
RabbitMQ整体上是生产者与消费者模型，主要负责接收、存储、转发消息。
RabbitMQ的原理和使用
02-24
本文来自于cnblogs，文章从应用场景架构介绍，包括使用过程，怎么实现等相关内容。AMQP，即AdvancedMessageQueuingProtocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件...
高可用网站架构设计与实现.rar
11-25
《高可用网站架构设计与实现》是一份深入探讨如何构建稳定、可靠且高效网站架构的综合资料。这份压缩包包含了详细的设计文档、开题报告以及相关的PPT演示文稿，旨在为IT专业人士提供一个全面的学习资源，同时也适用...
kettle rabbitmq 插件开发
10-26
开发者需要熟悉 Kettle 的 API 和插件架构，以便创建能够与 RabbitMQ 通信的组件。 4. **RabbitMQ 配置**：设置 Kettle 与 RabbitMQ 的连接，包括创建连接配置，如主机名、端口、用户名和密码等。 5. **发送数据到...
大型分布式网站架构设计与实践
07-04
书中会讲解RabbitMQ、Kafka等消息中间件的工作原理和使用技巧。 6. **服务化与API设计**：随着业务复杂性的增加，服务化成为必然趋势。书中会讲述RESTful API的设计原则、服务治理和服务发现机制，如Eureka和Consul...
RocketMQ底层设计与原理
KIMTOU的博客
09-21 3605
RocketMQ的消息模型 消息模型 Message Model RocketMQ主要由 Producer、Broker、Consumer 三部分组成，其中Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器，**每个 Broker 可以存储多个Topic的消息，每个Topic的消息也可以分片存储于不同的 Broker。**Message Queue 用于存储消息的物理地址，每个Topic中的消息地址存储于多个 Messag
MQ原理、使用场景、IBM WebSphere MQ介绍及spring集成配置
热门推荐
格色情调的博客
10-31 2万+
一、MQ简介及特点         MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过写和检索出入列队的针对应用程序的数据（消息）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过队列来通信。队列的使用除去了接收和
RabbitMQ的整体架构是怎么样的？
zhangjiaming_zjm的博客
03-04 630
每个VHost拥有自己的交换器，队列，绑定和权限配置，不同的VHost之间的资源相互独立，互不干扰。RabbitMQ是一个开源的消息中间件，用于在应用程序之间传递消息。Exchange（交换器）:交换器是消息的接收和路由中心,它接收来自生成者的消息，并将消息路由到一个或多个与之绑定的队列（Queue）中。Queue （队列）：队列是消息的存储和消费的，它保存着未被消费的信息，等待消费者从队列中获取并处理消息.Binding （绑定）:绑定是交换器和队列之间的关联关系，它定义了交换器将消息路由到哪些队列中。
RabbitMQ消息队列实战（1）—— RabbitMQ的体系
Hyman的博客
01-16 1303
中间经历过数个阶段的发展，一直到2004年，AMQP（Advanced Message Queuing Protcol）协议开发完成，这是一款具有开放标准的通信协议，它允许任何人都可以执行这一标准，编码标准的任何人都可以和任何AMQP供应商提供的MQ服务器进行交互。本文主要介绍RabbitMQ的逻辑体系结构，先是简单介绍其整个体系架构以及相关名词的介绍，然后介绍RabbitMQ三种消息路由的方式（因第四种Header模式基本不会使用，这里不包括在内），最后介绍其典型的应用场景。接下来，我们分别进行介绍。
RabbitMQ集群架构模型与原理解析
qq_39750835的博客
08-18 337
1.RabbitMQ四种集群架构 （1）主备模式 a. 主备模式+HaProxy配置 （2）远程模式 远距离通信和复制，可以实现双活的一种模式，简称Shovel模式。远程模式在现在用的不是很多，它的可靠性不好，并且配置起来也很麻烦。 所谓Shovel就是我们可以把消息进行不同数据中心的复制工作，可以跨地域的让两个mq集群互联。 RabbitMQ早期版本提供的多活存储，主要做数据异地的容灾，可以提升性能。比如当单节点处理不过来，可以把数据转发到下游的集群。 Shovel架构模型 ..
微服务的异步通信技术RabbitMQ
懒羊羊的博客
02-27 5815
SpringAMQP的学习与掌握
RabbitMQ课程1
08-08
"RabbitMQ课程1 - 阮文，2015-07-14" 在本文中，我们将深入探讨RabbitMQ，这是一个广泛使用的开源消息代理和队列...通过深入理解RabbitMQ的工作原理和AMQP机制，开发者可以更好地利用这一工具来优化他们的系统设计。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

King Gigi.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值