RabbitMQ 通俗易懂 简单开发(一）

最新推荐文章于 2024-06-23 16:58:01 发布
最新推荐文章于 2024-06-23 16:58:01 发布
阅读量714 收藏 3
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44489021/article/details/115455655
版权
本文详细解读了AMQP协议，包括生产者和消费者流转流程，并重点介绍了RabbitMQ的简单模式、工作模式、发布订阅模式、路由模式和主题模式，实例演示了每种模式的应用场景与实现步骤。

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

目录

一.AMQP 协议

（rabbitmq 遵循AMQP协议）

  • 一. AMQP全称: Advanced Message Queuing Protocol(高级消息队列协议)。是应
    用层协议的一个开发标准，为面向消息的中间件设计。

  • 二. AMQP生产者流转过程
    在这里插入图片描述

  • 三.AMQP消费者流转协议
    在这里插入图片描述

二.RabbitMq 核心组成部分

在这里插入图片描述

面试：mq消息 可以存在没有交换机的队列里吗？
        不可以,虽然可以不指定交换机，但也会默认给你一个交换机。

一.核心概念:
核心概念:

Server : 又称Brokgr ,接受客户端的连接，实现AMQP实体服务。安装rabbitmq-server

Connection :连接，应用程序与Broker的网络连接TCP/IP/三次握手和四次挥手

Channel:网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道，客户端可以建立对各Channel，每个Channel代表一个会话任务。

Message :消息:服务与应用程序之间传送的数据，由Properties和body组成，Properties可是对消息进行修饰，比如消息的优先级，延迟等高级特性，Body则就是消息体的内容。

Virtual Host虚拟地址，用于进行逻辑隔离，最上层的消息路由，一个虚拟主机理由可以有若千个Exhange和Queueu，同一个虚拟主机里面不能有相同名字的Exchange

Exchange:交换机，接受消息，根据路由键发送消息到绑定的队列。(==不具备消息存储的能力==)

Bindings : Exchange和Queue之间的虚拟连接，binding中可以保护多个routing key.

Routing key :是一个路由规则，虚拟机可以用它来确定如何路由一个特定消息。

Queue :队列:也成为Message Queue,消息队列，保存消息并将它们转发给消费者。

三.RabbitMq运行流程

在这里插入图片描述

四.RabbitMq 的几种模式理解

一.简单模式
原理：生产者将消息交给默认的交换机，
交换机获取消息后交给绑定这个生产者的队列
（投递规则为队列名称和routing key 相同的队列），
监听当前队列的消费者获取信息并执行消费逻辑。
在这里插入图片描述
场景：有一个oa系统，用户通过接收手机验证码进行注册，页面上点击获取验证码后，将验证码放到消息队列，然后短信服务从队列中获取到验证码，并发送给用户。
实现：
生产者：

public class Producter {

    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();
        // 4. 通过channel发布消息
        /**
         * 四个参数：
         * 第一个参数是交换机的名称
         * 第二个参数是路由键
         * 第三个参数标识消息的一些额外的属性
         * 第四个是消息的具体的内容
         */
        String message = "字节";
        for(int i = 0;i < 5;i ++){

            channel.basicPublish("","byte001",null,message.getBytes());
        }
        // 5. 释放资源，释放channel 和 链接对象

        channel.close();
        connection.close();
    }
}

消费者：

public class Consumer {

    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        // 4. 创建出消息队列
        /**
         * 第一个参数是消息队列的名称
         * 第二个参数表示消息是否持久化
         * 第三个参数标识消息队列是否被channel独占
         * 第四个参数标识是否自动删除消息队列，当消息队列没有绑定交换机后是否自动删除
         * 第五个是消息队列扩展参数
         */
        String queueName = "byte001";
        channel.queueDeclare(queueName, true, false, false, null);

        // 5. 创建消费者,对消息进行处理
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("获取到的消息："+s);
            }
        };
        // 6. 通过channel消费者和消息队列关联
        /**
         * 第一个参数是消息队列的名字
         * 第二个参数是否自动签收（即消费消息后告知服务器已被消费）
         * 第三个参数是消费者
         */
        channel.basicConsume(queueName, true, consumer);
    }
}

二、工作模式
原理：生产者将消息交给交换机，交换机交给绑定的队列，队列有多个消费者监听，一条消息只能由一个消费者消费，这样就形成了资源竞争，谁的资源空闲大，争抢到的可能性就大。
在这里插入图片描述
场景:有一个电商平台，有两个订单服务，用户下单的时候，任意一个订单服务消费用户的下单请求生成订单即可。不用两个订单服务同时消费用户的下单请求。
实现：
生产者：

public class Producter {

    public static final String QUEUE_NAME = "byte002";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        // 申明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 4. 通过channel发布消息
        /**
         * 四个参数：
         * 第一个参数是交换机的名称
         * 第二个参数是路由键
         * 第三个参数标识消息的一些额外的属性
         * 第四个是消息的具体的内容
         */
        String message = "字节";
        for(int i = 0;i < 100;i ++){

            channel.basicPublish("",QUEUE_NAME,null,(message+i).getBytes());
        }
        // 5. 释放资源，释放channel 和 链接对象

        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer {

    public static final String QUEUE_NAME = "byte002";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        // 4. 创建出消息队列
        /**
         * 第一个参数是消息队列的名称
         * 第二个参数表示消息是否持久化
         * 第三个参数标识消息队列是否被channel独占
         * 第四个参数标识是否自动删除消息队列，当消息队列没有绑定交换机后是否自动删除
         * 第五个是消息队列扩展参数
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1); // 告诉服务器，在我们没有确认当前消息时不要给我们发送新的消息
        // 5. 创建消费者,对消息进行处理
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者1收到的内容："+s);
                try {
                    Thread.sleep(10); // 模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(),false); // 参数2false为确认收到消息，true为拒绝收到消息
            }
        };
        // 6. 通过channel消费者和消息队列关联
        /**
         * 第一个参数是消息队列的名字
         * 第二个参数是否自动签收（即消费消息后告知服务器已被消费）
         * 第三个参数是消费者
         */
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

消费者2：

public class Consumer2 {

    public static final String QUEUE_NAME = "byte002";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        // 4. 创建出消息队列
        /**
         * 第一个参数是消息队列的名称
         * 第二个参数表示消息是否持久化
         * 第三个参数标识消息队列是否被channel独占
         * 第四个参数标识是否自动删除消息队列，当消息队列没有绑定交换机后是否自动删除
         * 第五个是消息队列扩展参数
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1); // 告诉服务器，在我们没有确认当前消息时不要给我们发送新的消息
        // 5. 创建消费者,对消息进行处理
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者2收到的内容："+s);
                try {
                    Thread.sleep(500); // 模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(),false); // 参数2false为确认收到消息，true为拒绝收到消息
            }
        };
        // 6. 通过channel消费者和消息队列关联
        /**
         * 第一个参数是消息队列的名字
         * 第二个参数是否自动签收（即消费消息后告知服务器已被消费）
         * 第三个参数是消费者
         */
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

保证资源竞争的代码就是这一行channel.basicQos(1);如果不加这一行，我们会发现两个消费者是轮询消费消息的。
三、发布订阅模式
原理：生产者将消息扔给交换机，交换机类型是fanout，不同的队列注册到交换机上，不同的消费注册在不同的队列上。所有消费者都会收到消息。
在这里插入图片描述
场景：有一个商城，我们新添加一个商品后，可能同时需要去更新缓存和数据库
实现：
生产者：

public class Producter {

    // 定义交换机的名字
    public static final String EXCHANGE_NAME="byte003";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();
        // 定义一个交换机，类型是fanout
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        // 因为消息先发到交换机，交换机没有保存功能，所以如果没有消费者，消息会丢失
        channel.basicPublish(EXCHANGE_NAME,"",null,"发布订阅模式的消息".getBytes());

        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer1 {
    public static final String EXCHANGE_NAME="byte003";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue003";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者1："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}

消费者2：

public class Consumer2 {
    public static final String EXCHANGE_NAME="byte003";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue004";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者2："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}

需要注意的一点就是交换机没有保存功能，如果没有消费者，则消息会丢失。
四、路由模式

原理：生产者将消息发送给交换机，消息携带具体的routingkey。交换机类型是direct，接收到消息中的routingkey，比对与之绑定的队列的routingkey，分发到不同的队列上。
在这里插入图片描述
场景：还是一样，有一个商城，新添加了一个商品，实时性不是很高，只需要添加到数据库即可，不用刷新缓存。
实现：
生产者：

public class Producter {

    // 定义交换机的名字
    public static final String EXCHANGE_NAME="byte004";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();
        // 定义一个交换机，类型是direct
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");

        // 因为消息先发到交换机，交换机没有保存功能，所以如果没有消费者，消息会丢失
        channel.basicPublish(EXCHANGE_NAME,"key1",null,"发布路由模式的消息".getBytes());

        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer1 {
    public static final String EXCHANGE_NAME="byte004";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue005";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        /**
         * 参数3是routingkey，只有和它一样的routingkey的消息才会被当前消费者收到
         */
        channel.queueBind(queueName,EXCHANGE_NAME,"key1");
        // 如果要接收多个routingkey的消息，在执行一次上面的代码即可，如下
        channel.queueBind(queueName,EXCHANGE_NAME,"key2");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者1："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}

消费者2：

public class Consumer2 {
    public static final String EXCHANGE_NAME="byte004";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue006";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"key2");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者2："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}

五、主题模式
原理：路由模式的一种，路由功能添加了模糊匹配。星号（*）代表1个单词，#号（#）代表一个或多个单词。具体可参考路由模式。
在这里插入图片描述
场景：还是一样，有一个商城，新添加了一个商品，实时性不是很高，只需要添加到数据库即可，数据库包含了主数据库mysql1和从数据库mysql2的内容，不用刷新缓存。
实现
生产者：

public class Producter {

    // 定义交换机的名字
    public static final String EXCHANGE_NAME="byte004";
    public static void main(String[] args) throws Exception {

        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();
        // 定义一个交换机，类型是topic
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");

        // 因为消息先发到交换机，交换机没有保存功能，所以如果没有消费者，消息会丢失
        channel.basicPublish(EXCHANGE_NAME,"key.1.2",null,"发布路由模式的消息".getBytes());

        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer1 {
    public static final String EXCHANGE_NAME="byte004";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue005";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        /**
         * 参数3是routingkey，只有和它一样的routingkey的消息才会被当前消费者收到
         */
        channel.queueBind(queueName,EXCHANGE_NAME,"key.*");
        // 如果要接收多个routingkey的消息，在执行一次上面的代码即可，如下
        channel.queueBind(queueName,EXCHANGE_NAME,"abc.#");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者1："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}

消费者2：

public class Consumer2 {
    public static final String EXCHANGE_NAME="byte004";

    public static void main(String[] args) throws Exception {


        // 1. 创建出链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");

        // 2. 通过链接工厂创建链接对象
        Connection connection = factory.newConnection();

        // 3. 通过链接对象创建出channel
        Channel channel = connection.createChannel();

        String queueName = "queue006";
        channel.queueDeclare(queueName,false,false,false,null);

        // 绑定队列到交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"key.#");
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * consumerTag 用来标识.可以再监听队列时候设置
             * envelope 信封,通过envelope可以通过这个获取到很多东西
             * properties 额外的消息属性
             * body:消息体
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");
                System.out.println("消费者2："+s);
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);
    }
}
Da.ge
关注
大聪明教你学Java | 面试管：谈谈如何解决 RabbitMQ 消息丢失与消息积压
不肯过江东丶
08-03 596
目前企业中最常用到的消息队列就是 RabbitMQ（主要是因为它在中小企业普及更早，经受的考验也更久，带来了一大批“回头客”），所以掌握 RabbitMQ 的相关技能就显得是比较重要了。我们在使用 RabbitMQ 的过程中比较常见的问题就是消息丢失、消息积压等等，所以此类问题也就成为了面试官们老生常谈的问题了... 今天就和大家分享一下我在工作过程中解决 RabbitMQ 消息丢失与消息积压的一点经验心得。...
rabbitMQ简单开发
shenzhen_zsw的专栏
04-05 181
rabbitMQ简单开发 maven引入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.3.0</version> &lt...
RabbitMq开发入门
10-18
RabbitMq开发入门
【RabbitMQ】开发
学习 - 总结 - 分享 - Francis
09-10 602
&nbsp; 连接 RabbitMQ ConnectionFactory factory = new ConnectionFactory(); factory.setUsername(USERNAME); factory.setPassword(PASSWORD); factory.setVirtualHost(virtualHost); facotry.setHost(IP_ADRESS);...
《RabbitMQ实战指南》---- RabbitMQ客户端开发
jushisi的博客
02-24 412
1、基本使用Demo <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client --> <dependency> <groupid>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>4.2.1</version> </dependency&g
RabbitMQ的快速开发使用
qq_72512690的博客
06-23 1172
追求可用性：Kafka、 RocketMQ 、RabbitMQ追求可靠性：RabbitMQ、RocketMQ追求吞吐能力：RocketMQ、Kafka追求消息低延迟：RabbitMQ、Kafka据统计，目前国内消息队列使用最多的还是RabbitMQ，再加上其各方面都比较均衡，稳定性也好。RabbitMQ支持多种协议。而Spring boot框架对AMQP协议进行了封装，使用Spring AMQP的依赖调用里面的API即可实现快速使用RabbitMQ进行开发。
RocketMQ工作模式
桀骜浮沉的博客
03-12 1422
RocketMQ工作模式 1.多master（常用方式，上万并发） 2.多master多slave（几十万，几百万并发） 1>异步复制（一个master收到消息后就算成功，然后异步复制到其他master） master宕机会有少量消息丢失 2>同步双写（所有master都收到消息才算成功） ...
【RabbitMQ】RabbitMQ快速入门 通俗易懂 初学者入门
少年你真的要止步于此嘛
11-30 1797
【推荐】RabbitMQ快速入门 1小时上手学会RabbitMQ
通俗易懂，十分钟让你了解并上手 Docker
战斧的博客
04-25 7633
开了云原生专栏很久，但一直没怎么更新，今天就来更新一篇Docker的。主要面向新人，争取十分钟让完全新手了解Docker的作用、原理以及基本的操作
springcloud通俗易懂
最新发布
03-22
### Spring Cloud 的入门级通俗讲解 Spring Cloud 是一组基于 Spring Framework 的开源项目，旨在帮助开发者快速构建...以上代码片段展示了如何创建一个简单的 Spring Boot 应用程序，并启用服务发现功能。 --- ###
RabbitMQ详细介绍：一种高可用、数据安全的消息通信中间件
首先，RabbitMQ具有通俗易懂的配置项，它本身依赖于Erlang语言，并不是Java语言，因此只要在电脑上安装好Erlang语言的环境，就可以轻松使用RabbitMQ。其次，RabbitMQ能够与Spring Boot框架很好地结合，这使得在开发...
rabbitMQ开发案例
12-17
RabbitMQ消息中间件
rabbitMQ JAVA开发 demo文件
12-22
rabbitMQ JAVA开发 demo文件 rabbitMQ JAVA开发 demo文件
RabbitMQ 开发指南
weixin_42824596的博客
06-20 1265
每个Channel都拥有自己独立的线程，最常用的做法是一个Channel对应一个消费者，也就意味着消费者彼此之间没有关联，也可以在Channel中维持多个消费者，但是，如果Channel中一个消费者一直在运行，那其他消费者的callback会被耽搁。getReason可以获取Cause相关的信息。上面创建了一个持久化的、非自动删除的、绑定类型为direct的交换器，同时也创建了一个非持久化的、排他的、自动删除的队列（队列名称由RabbitMQ自动生成），这里的交换器和队列都没有设置特殊的参数。
RabbitMQ开发总结.20200219
qq1010234991的博客
02-20 451
RabbitMQ开发20200219总结 URI的规范的百分比编码 背景 解决过程 RabbitMQ如何保证消息的可靠性传递，要是消息丢失如何处理 方法 改进 比较 MQ中丢失 步骤 消费端丢失 定时任务 RabbitMQ使用URI方式设置资源 背景 解决方法 参考链接 Rabb...
rabbitmq 企业开发实战-simple
小海聊智造
08-28 342
rabbitmq 企业开发实战 第一章 rabbitmq 企业开发实战之简单模式 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录rabbitmq 企业开发实战应用场景一、简单（点对点）模式 simple二、代码演示1.定义队列2.定义消息生产者2.定义消费者测试演示 应用场景 应用场景：用户通过接收手机验证码进行注册，页面上点击获取验证码后，将验证码放到消息队列，然后短信服务从队列中获取到验证码，并发送给用户 一、简单（点对点）模式 simple 二、代码演示 1.
基于java语言使用RabbitMQ开发过程记录
zimo_1993的博客
11-01 825
此处不再一一粘贴代码，只记录开发学习过程中遇到的一些问题和解决办法，还有一些理论知识，留着以后面试的时候不啦不啦~~ 刚才使用简单队列实现了生产者和消费者模式（基于旧 的API和新的API两种方式） 简单队列 一个生产者对应一个消费者，耦合性高，无法实现让多个消费者共同消费一个生产者，而且若想修改队列名称，就得全部修改。 实际场景中，生产者生产消息很快，一般都是插入一条数据之类的；而消...
RabbitMQ开发详解
demon7552003的小本本
11-04 589
目录 开发步骤 引入client 生产者 消费者 应用场景 简单队列 工作队列 发布/订阅 路由模式 topic模式 rpc模式 发布确认 开发步骤 引入client <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-cli...
RabbitMq入门级教程之完全掌握5种开发方案
chuxie2576的博客
08-22 263
1、安装 windows安装rabbitmq mac安装rabbitmq需要注意的是，mac安装rabbitmq，启动的时候命令前，需要加sudo，不然会报错误 2、rabbitmq 开发概念词 2.1 Producer（生产者） 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Da.ge

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

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

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

打赏作者

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

抵扣说明：

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

余额充值