RabbitMQ入门

最新推荐文章于 2021-12-30 17:44:07 发布
原创 最新推荐文章于 2021-12-30 17:44:07 发布 · 353 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#RabbitMQ

1.简介

MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用非常广泛。

RabbitMQ官方地址:http://www.rabbitmq.com/

开发中消息队列通常有如下应用场景:

1、任务异步处理。

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理，提高了应用程序的响应时间。

2、应用程序解耦合

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

2.工作原理

下图是RabbitMQ的基本结构：

 

组成部分说明如下:

  • Broker:消息队列服务进程，此进程包括两个部分:Exchange和Queue

  • Exchange:消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过滤

  • Queue:消息队列，存储消息的队列，消息到达队列并转发给指定的消费方

  • Producer:消息生产者，即生产方客户端，生产方客户端将消息发送到MQ

  • Consumer:消息消费者，即消费方客户端，接收MQ转发的消息

消息发布接收流程:

-----发送消息-----

1、生产者和Broker建立TCP连接。

2、生产者和Broker建立通道。

3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。

4、Exchange将消息转发到指定的Queue(队列)

----接收消息-----

1、消费者和Broker建立TCP连接

2、消费者和Broker建立通道

3、消费者监听指定的Queue(队列)

4、当有消息到达Queue时Broker默认将消息推送给消费者。

5、消费者接收到消息。

3.mac安装RabbitMQ

https://www.jianshu.com/p/60c358235705

4.编写第一个hello world

（1）创建maven工程

test-rabbitmq-producer:生产者工程

test-rabbitmq-consumer:消费者工程

（2）导入pom依赖

  <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>4.0.3</version>
  </dependency>

（3）生产者

public class Producer01 {
    /**
     * 队列名称
     */
    private static final String QUEUE = "helloworld";
​
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = null;
        Channel channel = null;
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            //rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务
            factory.setVirtualHost("/");
            //创建与RabbitMQ服务的TCP连接
            connection = factory.newConnection();
            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
            channel = connection.createChannel();
            /**
             * 声明队列，如果Rabbit中没有此队列将自动创建
             *
             * param1:队列名称
             * param2:是否持久化
             * param3:队列是否独占此连接
             * param4:队列不再使用时是否自动删除此队列
             * param5:队列参数
             */
            channel.queueDeclare(QUEUE, true, false, false, null);
            String message = "helloworld小明:" + System.currentTimeMillis();
            /**
             * 消息发布方法
             *
             * param1:Exchange的名称，如果没有指定，则使用Default Exchange
             * param2:routingKey,消息的路由Key，是用于Exchange(交换机)将消息转发到指定的消息队列
             * param3:消息包含的属性
             * param4:消息体
             */
            /**
             * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或解除绑定
             * 默认的交换机，routingKey等于队列名称
             */
            channel.basicPublish("", QUEUE, null, message.getBytes());
            System.out.println("Send Message is:'" + message + "'");
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
}

（4）消费者

public class Consumer01 {
    private static final String QUEUE = "helloworld";
​
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        //设置RabbitMQ所在服务器的ip和端口
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE, true, false, false, null);
        //定义消费方法
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            /**
             * 消费者接收消息调用此方法
             *
             * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
             * @param envelope    消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
             *                    (收到消息失败后是否需要重新发送)
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                System.out.println("exchange:" + envelope.getExchange());
                //消息id，mq在channel中用来表示标识消费的id，可用于确认消息已接收
                System.out.println("deliveryTag:" + envelope.getDeliveryTag());
                //路由key
                System.out.println("routingKey:" + envelope.getRoutingKey());
                //消息
                System.out.println("receive message:" + new String(body, StandardCharsets.UTF_8));
            }
        };
        /**
         * 监听队列String queue, boolean autoAck,Consumer callback
         * 参数明细
         *  1、队列名称
         *  2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动回复
         *  3、消费消息的方法，消费者接收到消息后调用此方法
         * */
        channel.basicConsume(QUEUE, true, consumer);
    }
}

（5）测试

启动生产者，启动消费者。

消费者打印如下：

exchange:
deliveryTag:1
routingKey:helloworld
receive message:helloworld小明:1569484087557

5.工作模式

RabbitMQ有以下几种工作模式 :

  • Work queues

  • Publish/Subscribe

  • Routing

  • Topics

  • Header

  • RPC

（1）Work queues

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。

应用场景:对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

测试:

1、使用入门程序，启动多个消费者。

2、生产者发送多个消息。

（2）Publish/subscribe

发布订阅模式:

1、每个消费者监听自己的队列

2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

案例：

用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法 。

生产者

public class Producer02_publish {
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
​
    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            //创建一个与MQ的连接
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
            connection = factory.newConnection();
            channel = connection.createChannel();
            //声明交换机 (String exchange, BuiltinExchangeType type)
            /**
             *参数明细
             * 1、交换机名称
             * 2、交换机类型
             *      fanout: 发布订阅的工作模式 publish/scribe
             *      direct: 路由的工作模式
             *      topic: 通配符的工作模式
             *      headers: headers的工作模式
             * */
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
            //声明队列 (String queue,boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
            /**
             * 参数明细:
             * 1、队列名称
             * 2、是否持久化
             * 3、是否独占此队列
             * 4、队列不用是否自动删除
             * 5、参数
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
            channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
            //交换机和队列绑定 (String queue, String exchange, String routingKey)
            /**
             *参数明细
             * 1、队列名称
             * 2、交换机名称
             * 3、路由key
             * */
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");
            channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_FANOUT_INFORM, "");
            //发送消息
            for (int i = 0; i < 5; i++) {
                String message = "inform to user" + i;
                //向交换机发送消息 (String exchange, String routingKey, BasicProperties props,byte[] body)
                /**
                 息将发到此队列
                 * 参数明细
                 * 1、交换机名称，不指令使用默认交换机名称 Default Exchange
                 * 2、routingKey(路由key)，根据key名称将消息转发到具体的队列，这里填写队列名称表示消息将发送到此队列
                 * 3、消息属性
                 * 4、消息内容
                 * */
                channel.basicPublish(EXCHANGE_FANOUT_INFORM, "", null, message.getBytes());
                System.out.println("Send Message is:'" + message + "'");
            }
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        } finally {
            if (channel != null) {
                try {
                    channel.close();
                } catch (IOException | TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

邮件发送消费者

public class Consumer02_subscribe_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
​
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
​
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
​
        channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
​
        channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");
​
        //定义消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, StandardCharsets.UTF_8);
                System.out.println(message);
            }
        };
​
        //监听队列
        channel.basicConsume(QUEUE_INFORM_EMAIL, true, defaultConsumer);
    }
}

短信发送消费者参考上边的代码。

测试

使用生产者发送若干条消息，每条消息都转发到各个队列，每个消费者都接收到了消息。

思考：publish/subscribe与work queues有什么区别

区别:

1)work queues不用定义交换机，而publish/subscribe需要定义交换机。

2)publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认交换机)。

3)publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机 。

相同点: 所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。

思考：实质工作用什么 publish/subscribe还是work queues

建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换机。

（3）Routing

路由模式:

1、每个消费者监听自己的队列，并且设置routingkey。

2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。

（4）Topics

路由模式:

1、每个消费者监听自己的队列，并且设置带统配符的routingkey。

2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。

案例:

根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种通知类型都接收的则两种通知都有效。

生产者

public class Producer04_topics {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
    private static final String ROUTINGKEY_EMAIL="inform.#.email.#";
    private static final String ROUTINGKEY_SMS="inform.#.sms.#";
    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
​
        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
​
            //声明队列，如果队列在mq 中没有则要创建
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
​
            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
​
            //进行交换机和队列绑定
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
​
            //发送消息
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send email inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send sms inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send sms and email inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms.email",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            //先关闭通道
            try {
                channel.close();
            } catch (IOException | TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
​

sms消费者

public class Consumer04_topics_sms {
    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
​
    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
​
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
​
        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
​
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_TOPICS_INFORM, ROUTINGKEY_SMS);
​
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, StandardCharsets.UTF_8);
                System.out.println("receive message:" + message);
            }
        };
​
        //监听队列
        channel.basicConsume(QUEUE_INFORM_SMS, true, defaultConsumer);
​
    }
}

测试

使用生产者发送若干条消息，每条消息都转发到各个队列，每个消费者都接收到了消息。

sms消费者消费内容如下:

receive message:send sms inform message to user
receive message:send sms inform message to user
receive message:send sms inform message to user
receive message:send sms inform message to user
receive message:send sms inform message to user
receive message:send sms and email inform message to user
receive message:send sms and email inform message to user
receive message:send sms and email inform message to user
receive message:send sms and email inform message to user
receive message:send sms and email inform message to user

（5）header模式

header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value(键值对)匹配队列。

生产者

public class Producer05_header {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_HEADERS_INFORM = "exchange_headers_inform";

    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();

            //声明队列，如果队列在mq 中没有则要创建
            channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
            channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);

            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS);

            //进行交换机和队列绑定
            Map<String, Object> headers_email = new Hashtable<String, Object>();
            headers_email.put("inform_type", "email");
            Map<String, Object> headers_sms = new Hashtable<String, Object>();
            headers_sms.put("inform_type", "sms");
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_HEADERS_INFORM, "", headers_email);
            channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_HEADERS_INFORM, "", headers_sms);


            String message = "email inform to user";
            Map<String, Object> headers = new Hashtable<String, Object>();
            headers.put("inform_type", "email");//匹配email通知消费者绑定的header
//            headers.put("inform_type", "sms");// 匹配sms通知消费者绑定的header
            AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();
            properties.headers(headers);
            //Email通知
            channel.basicPublish(EXCHANGE_HEADERS_INFORM, "", properties.build(), message.getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            //先关闭通道
            try {
                channel.close();
            } catch (IOException | TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

public class Consumer05_header {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_HEADERS_INFORM = "exchange_headers_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);

        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS);
        //进行交换机和队列绑定
        Map<String, Object> headers_email = new Hashtable<String, Object>();
        headers_email.put("inform_type", "email");
        channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_HEADERS_INFORM, "", headers_email);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, StandardCharsets.UTF_8);
                System.out.println("receive message:" + message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_EMAIL, true, defaultConsumer);

    }
}

（6）RPC

 

RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下:

1、客户端即是生产者又是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列

2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果

3、服务端将RPC方法的结果发送到RPC响应队列

4、客户端(RPC调用方)监听RPC响应队列，接收到RPC调用结果

RabbitMQ 入门指南：安装、基础结构、消息模型与入门案例
m0_53117341的博客
09-09 1538
本篇文章，我们将一步步指导如何在 CentOS 系统上安装 RabbitMQ ，这是基于 Erlang 语言开发的强大开源消息中间件。我们会从下载和安装开始，然后深入到 RabbitMQ 的核心概念，包括通道、交换机、队列和虚拟主机。此外，我们还会通过简单的入门案例，展示如何在 RabbitMQ 中发送和接收消息。涉及到代码的部分 , 我们已经提供给大家 demo 版本 , 下载之后按照教程模拟即可 .
RabbitMQ入门视频
最新发布
04-05
在“RabbitMQ入门视频”中，你将学习到以下关键知识点： 1. **AMQP协议**：首先，了解AMQP协议的基础知识是非常重要的。AMQP定义了一种标准的、面向消息的中间件协议，支持多种语言和平台。它提供了一种可靠的消息...
rabbitmq
wuzhan的专栏
05-18 386
1. 异步，将消息写入消息队列，非必要的业务逻辑以异步的方式运行，加快响应速度; 2. 削峰，并发量大的时候，所有的请求直接怼到数据库，造成数据库连接异常; 所以消息队列实际是一种非常复杂的架构，你引入它有很多好处，但是也得针对它带来的坏处做各种额外的技术方案和架构来规避掉，做好之后，你会发现，妈呀，系统复杂度提升了一个数量级，也许是复杂了 10 倍。但是关键时刻，用，还是得用的。 ActiveMQ: 没法确认ActiveMQ可以支撑互联网公司的高并发、高负载以及高吞吐的复杂场景，在国内互联网公司落地较少
RabbitMQ学习
jdk819的博客
08-04 273
参考大神文档：https://blog.youkuaiyun.com/kavito/article/details/91403659?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162795376016780265433132%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=162795376016780265433132&amp...
Spring Boot 搭配 RabbitMQ 使用（简单模式，工作模式，订阅模式，路由模式，主题模式）
First_llh的博客
12-30 2701
第一步导入依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.7.3</version> </dependency> 1.简单模式连接（1个消费者获取一个队列）： 发布者代码： import com.rabbitmq.client..
RabbitMQ的一些配置
Jade-Tiger的博客
07-27 500
application.properties配置文件的配置（消费者的配置）： #连接地址 v2.spring.rabbitmq.host=11.110.1.11 #连接端口 v2.spring.rabbitmq.port=5672 v2.spring.rabbitmq.username=用户名 v2.spring.rabbitmq.password=密码 #连接到rabbitMQ的vhost v2.spring.rabbitmq.virtual-host=123546 v2.spring.main.a
rabbitMq入门
08-08
【标题】：“rabbitMQ入门” 在IT行业中，消息队列是一种常见的中间件技术，用于解耦应用程序组件，提高系统的可扩展性和可靠性。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中。本篇文章将带...
精选资源
Rabbitmq入门到精通.doc
08-21
【RabbitMQ 入门到精通】：RabbitMQ 是一款流行的消息中间件，它基于 AMQP（Advanced Message Queuing Protocol）协议实现，用于在分布式系统中高效地传输消息，从而实现异步处理、解耦和流量控制。本教程旨在帮助...
RabbitMQ工作模式之Work queues和Publish/Subscribe
03-18 527
RabbitMQ有以下几种工作模式 ：    1、Work queues    2、Publish/Subscribe 发布订阅模式    3、Routing    4、Topics    5、Header    ...
RabbitMQ3.7 研究-工作模式之Publish/subscribe
传智燕青
12-19 518
目录3 RabbitMQ3.7 工作模式3.1 Work queues3.2 Publish/subscribe3.2.1生产者3.2.1.1 发布订阅模式介绍3.2.1.2 生产者代码3.2.2 消费者3.2.2.1 消费者代码3.2.2.2 测试3.2.2.3 小结 3 RabbitMQ3.7 工作模式 RabbitMQ3.7 有以下几种工作模式 ： 1、Work queues 2、Publi...
RabbitMQ 的这些骚操作你知道吗？
程序猿DD
06-22 1785
RabbitMQ的Java客户端统一使用com.rabbitmq.client作为顶级包名。其中，最核心的类主要有：ConnectionFactory、Connection、Channe...
python系列之 RabbitMQ -- Publish/Subscribe
蓝精灵
03-21 5101
前面的部分我们创建了一个工作队列（work queue）. 设想是每个任务都能分发到一个worker，这一部分我们将会做一些完全不同的事情 -- 我们将会分发一个消息到多个消费方（consumer），这中模式被誉为发布/订阅（publish/subscribe） 为了阐明这种模式,我们将要创建一个简单的日志系统，由两部分程序组成 -- 第一部分将要发布日志消息，第二部分接收并打印 在我们的日志
RabbitMQ入门学习笔记（二）工作模式
MineCodelife的博客
07-14 467
RabbitMQ有以下几种工作模式 ：1、Work queues2、Publish/Subscribe3、Routing4、Topics5、Header6、RPC 下面一一介绍测试：1、使用上篇的入门程序，启动多个消费者。2、生产者发送多个消息。结果：1、一条消息只会被一个消费者接收；2、rabbit采用轮询的方式将消息是平均发送给消费者的；3、消费者在处理完某条消息后，才会收到下一条消息 案例：...
RabbitMQ
fayeyiwang的专栏
06-13 1047
转载出处http://blog.youkuaiyun.com/evankaka 一、rabbitMQ简介 1.1、rabbitMQ的优点（适用范围） 1. 基于erlang语言开发具有高可用高并发的优点，适合集群服务器。 2. 健壮、稳定、易用、跨平台、支持多种语言、文档齐全。 3. 有消息确认机制和持久化机制，可靠性高。 4. 开源 其他MQ的优势： 1. A
java连接RabbitMQ遇到的坑
weixin_42840266的博客
01-10 1479
java客户端连接远程主机上的 rabbitmq 代码： ConnectionFactory factory = new ConnectionFactory(); factory.setUsername("admin"); factory.setPassword("123456"); factory.setVirtualHost("/"); factory.setHost("host"); //远程主机地址 factory.setPort(5672); Connection conn = factory
RabbitMQ工作模式
笑看人生的博客
08-21 2422
RabbitMQ有以下几种常用工作模式 1、Work queues 2、Publish/Subscribe 3、Routing 4、Topics 5、Header 6、RPC 1.1 Work queues work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。 应用场景：对于人物过重或人物较多情况使用工作队列可以提高任务处理的速度。 ...
RabbitMq入门--六种工作模式(四)
zwj1030711290的优快云
06-08 338
生产者操作流程如下： 1）创建连接 2）创建通道 3）声明队列 4）发送消息 消费者操作流程如下： 1）创建连接 2）创建通道 3）声明队列 4）监听队列 5）接收消息 6）ack回复 ...
rabbitmq入门
07-27
\[3\] RabbitMQ入门指南文章 希望这些信息对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [超详细的RabbitMQ入门](https://blog.youkuaiyun.com/Rok728/article/details/123106242)[target="_blank" data-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值