RabbitMQ 几种消息队列的简单实现

最新推荐文章于 2024-09-29 16:44:51 发布
最新推荐文章于 2024-09-29 16:44:51 发布
阅读量139 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42583701/article/details/116562616
版权

简单模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Sender {

    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        // queue：队列名
        // durable：是否持久化
        // exclusive：是否排外 即只允许该channel访问该队列 一般等于true的话用于一个队列只能有一个消费者来消费的场景
        // autoDelete：是否自动删除 消费完删除
        // arguments：其他属性
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //消息内容
        String message = "simplest mode message";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("[x]Sent '" + message + "'");

        //最后关闭通关和连接
        channel.close();
        connection.close();

    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver {

    private final static String QUEUE_NAME = "simplest_queue";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        // 获取连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}

工作队列模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receiver1 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 同一时刻服务器只会发送一条消息给消费者
        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });

    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver2 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 同一时刻服务器只会发送一条消息给消费者
        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });

    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Sender {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for (int i = 0; i < 100; i++) {
            String message = "work mode message" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("[x] Sent '" + message + "'");
            Thread.sleep(i * 10);
        }

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

发布订阅模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class Receive1 {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 订阅消息的回调函数
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        // 消费者，有消息时出发订阅回调函数
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class Receive2 {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 订阅消息的回调函数
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received2 '" + message + "'");
        };

        // 消费者，有消息时出发订阅回调函数
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Sender {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        String message = "publish subscribe message";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");

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

路由模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver1 {

    private final static String QUEUE_NAME = "queue_routing";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 指定路由的key，接收key和key2
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key2");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }

}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver2 {

    private final static String QUEUE_NAME = "queue_routing2";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 仅接收key2
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key2");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });


    }
}
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Sender {

    private final static String EXCHANGE_NAME = "exchange_direct";
    private final static String EXCHANGE_TYPE = "direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 交换机声明
        channel.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE);

        // 只有routingKey相同的才会消费
        String message = "routing mode message";
        channel.basicPublish(EXCHANGE_NAME, "key2", null, message.getBytes());
        System.out.println("[x] Sent '" + message + "'");
// channel.basicPublish(EXCHANGE_NAME, "key", null, message.getBytes());
// System.out.println("[x] Sent '" + message + "'");

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

主题模式

public class Receiver1 {

    private final static String QUEUE_NAME = "queue_topic";
    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 可以接收key.1
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key.*");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}
public class Receiver1 {

    private final static String QUEUE_NAME = "queue_topic";
    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 可以接收key.1
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key.*");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}


public class Sender {

    private final static String EXCHANGE_NAME = "exchange_topic";
    private final static String EXCHANGE_TYPE = "topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE);

        String message = "topics model message with key.1";
        channel.basicPublish(EXCHANGE_NAME, "key.1", null, message.getBytes());
        System.out.println("[x] Sent '" + message + "'");
        String message2 = "topics model message with key.1.2";
        channel.basicPublish(EXCHANGE_NAME, "key.1.2", null, message2.getBytes());
        System.out.println("[x] Sent '" + message2 + "'");

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

具体的消息队列模式可以根据实际的使用场景进行选择

参考自 http://rabbitmq.mr-ping.com/

weixin_42583701
关注
C#调用RabbitMQ实现消息队列
猫敷雪
05-23 4381
文章目录前言消息队列准备工作安装rabbitmq-serverRabbitMQ应用KibaRabbitMQSendKibaRabbitMQReceived服务器端应用安装Erlang环境安装RabbitMQ添加用户和权限RabbitMQ的简单指令参考文献 前言 前几天在做日志收集，用到了RabbitMQ，它作为一种中间件，需要对其进行下载，安装，和配置。 消息队列 什么是消息队列？，我们这样想一下，用户访问网站，最终是要将数据以HTTP的协议的方式，通过网络传输到主机的某个端口上的。 那么，接收数据的方式是
MQ消息队列简单的发送和接受示例
09-18
适合新手入门学习MQ消息队列，并通过最基本的方式实现p2p模式的消息传递，让新手了解mq最底层的实现方式，方便理解过程。
使用RabbitMQ实现一个简单的消息队列
qq_33759361的博客
06-21 336
实现一个简单模式 首先需要把RabbitMQ跑起来 rabbitmq-server.bat 2. 实现一个生产者模式 import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) # 声明一个管道 channel = connection.channel() # 声明queue，这个队列在RabbitMQ中生成，发送方和接收方使用同一个队列 channel.queue_dec
RabbitMQ 消息队列：生产者与消费者实现详解
最新发布
hs_1024的博客
09-29 996
在分布式系统中，消息队列（Message Queue, MQ）是一种重要的组件，用于解耦系统、异步处理任务以及实现系统间的通信。RabbitMQ 是一个流行的开源消息代理软件，它实现了高级消息队列协议（AMQP）。在本文中，我们将通过 Java 示例来演示如何使用 RabbitMQ 的生产者和消费者模型。
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 3011
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
笔记:RabbitMQ简单介绍和实现一个简单的消息队列
shuoge_fage的博客
11-09 471
笔记:RabbitMQ简单介绍和实现一个简单的消息队列 一.RabbitMQ简单介绍 1.什么是MQ？ MQ(消息队列)全称为Message Queue,是一种应用程序对应用程序或者对模块的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。 2.RabbitMQ的消息确认机制 默认情况下，如果消息已经被某个消费者正确的接受到了，那么该消...
RabbitMQ 的五种消息队列
weixin_53106424的博客
06-05 1306
1.简单模式   一个生产者发送消息到一个队列，一个消费者从队列中取消息 RabbitMQ 工具类 public class MQUtils { public static final String QUEUE01 ="queue01"; public static final String QUEUE02 ="queue02"; public static final String EXCHANGE01="exchange01"; public static fin
基于rabbitMQ实现的消息队列（MQ）
10-09
消息队列（MQ）是一种中间件技术，用于在分布式系统中解耦生产者和消费者，通过缓存消息来提高系统的可...通过学习和使用提供的源代码，开发者可以更好地理解如何在Java项目中集成和利用RabbitMQ实现消息队列的功能。
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
RabbitMQ 延迟队列及消息延迟推送实现详解是指在 RabbitMQ 中实现消息延迟推送的功能，即在指定的时间后推送消息到目标队列中。这种机制在实际应用中非常有价值，如在淘宝七天自动确认收货、12306 购票支付确认页面...
Python RabbitMQ消息队列实现rpc
09-20
RabbitMQ是一种流行的消息中间件，它允许分布式系统中的组件通过消息传递进行通信。RPC模式在Python中通过RabbitMQ实现，可以使得客户端能够发送请求到服务端，并等待服务端处理后的响应。 首先，我们需要了解...
RabbitMQ的5种消息队列
YIYIYI
08-16 3688
RabbitMQ的5种消息队列
RabbitMQ消息队列五种队列
情怀中的释然~
02-23 441
RabbitMQ消息队列五种队列 • 简单队列 • Work模式 1个生产者对应n个消费者 一个消息只能被一个消费者消费 • 发布/订阅模式 1个生产者对应n个消费者 每个消费者有自己的队列 生产者没有将消息直接发送到队列，而是发送到了交换机 每个队列都要绑定到交换机 生产者发送的消息，经过交换机，到达队列，实现，一个消息被多个消费者获取的目的 注：一个消费者队列可以有多个消费者实例，只有其中一...
RabbitMQ消息队列实现流程
跨境电商
03-03 2519
首先通过ConnectionFactory配置消息队列服务端信息，mq server端涉及的配置信息主要有server端的地址、端口号、虚拟主机(安装完有个默认的是”/”)、用户名、密码(刚安装完有个默认的用户，用户名和密码都是guest)笔者的项目是用SpringBoot搭的，获取ConnectionFactory的方式为 @Bean public ConnectionFactory
MQ消息队列搭建命令及方法
weixin_34221112的博客
06-13 1745
　　MQ 是一款稳定、安全又可靠的消息传递中间件。它使用消息和队列来支持应用程序、系统、服务和文件之间的信息交换。它可以简化和加速多个平台中不同应用程序和业务数据的集成。支持各种 API 和语言，并可以在本地、云和混合云中部署。 建立消息队列方法 1.在linux服务器192.168.0.151上新建两个队列管理器QM1： mqm@mq:~> crtmqm QM1 2.启动QM1 mq...
自拟实现消息队列（MQ）基于Rabbit MQ（含概念和源码）巨详细！！！！！含思维导图
Cheer_RIO的博客
09-25 1777
MQ是消息队列（Message Queue）的缩写，是一种应用程序对应用程序的通信方法。应用程序通过写和检索出入列队的针对应用程序的数据(消息)来通信，而无需专用连接来链接它们。在这里我手搓了一个MQ是属于基础，但是对于理解MQ一定是一篇好文章
（一）「消息队列」之 RabbitMQ 入门
YMGogre的博客
06-07 1463
想要实现两个应用程序之间的通信，我们可以借助“消息队列”技术。本文将介绍使用 C# 语言在 .NET 下实现 RabbitMQ 消息队列；当然无论是哪种编程语言或框架，要使用消息队列，都需要完成以下两个基本步骤：①下载并安装相应的消息队列服务器软件，并根据需要进行配置；②在您的应用程序代码中引入相应的消息队列客户端库，并使用客户端库提供的API来建立与消息队列服务器的连接并进行通信；这些步骤对于大多数消息队列中间件都是适用的。
消息队列mq的原理及实现方法
热门推荐
一个蜀黍的博客
03-28 2万+
消息队列技术是分布式应用间交换信息的一种技术。消息队列可驻留在内存或磁盘上,队列存储消息直到它们被应用程序读走。通过消息队列，应用程序可独立地执行--它们不需要知道彼此的位置、或在继续执行前不需要等待接收程序接收此消息。 消息中间件概述消息队列技术是分布式应用间交换信息的一种技术。消息队列可驻留在内存或磁盘上,队列存储消息直到它们被应用程序读走。通过消息队列，应用程序可独立地执行--它们不需要知道...
消息队列（MQ）介绍
liitdar的博客
08-30 5098
本文主要介绍消息队列（Message Queue，即MQ）的相关知识。
RabbitMQ有几种队列
08-21
以下是常见的几种： 1. **直通队列 (Direct Exchange)**：这种交换机是最简单的，消息直接绑定到指定的路由键上，所有绑定到该键的队列都将接收到消息。 2. **主题队列 (Fanout Exchange)**：所有的绑定队列都会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值