rabbitmq官方的六种工作模式

1.RabbitMq
1.1介绍
RabbitMQ是一个消息代理：它接受并转发消息。你可以把它当成一个邮局：当你想邮寄信件的时候，你会把信件放在投递箱中，并确信邮递员最终会将信件送到收件人的手里。在这个例子中，RabbitMQ就相当与投递箱、邮局和邮递员。

AMQP协议中的核心思想就是生产者和消费者隔离，生产者从不直接将消息发送给队列。生产者通常不知道是否一个消息会被发送到队列中，只是将消息发送到一个交换机。先由Exchange来接收，然后Exchange按照特定的策略转发到Queue进行存储。同理，消费者也是如此。Exchange 就类似于一个交换机，转发各个消息分发到相应的队列中。

1.2六种工作模式
官网介绍：https://www.rabbitmq.com/getstarted.html

这里简单介绍下六种工作模式的主要特点：

简单模式：一个生产者，一个消费者

work模式：一个生产者，多个消费者，每个消费者获取到的消息唯一。

订阅模式：一个生产者发送的消息会被多个消费者获取。

路由模式：发送消息到交换机并且要指定路由key ，消费者将队列绑定到交换机时需要指定路由key

topic模式：将路由键和某模式进行匹配，此时队列需要绑定在一个模式上，“#”匹配一个词或多个词，“*”只匹配一个词。

1.2.0
准备：

安装rabbitmq，并启动

引入pom文件：

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>3.4.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.7</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
</dependency>

<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.4.0.RELEASE</version>
</dependency>
</dependencies>
编写连接工具类：

package com.sakura.util;

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

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class ConnectionUtil {
public static Connection getConnection() throws IOException {
//连接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
//连接5672端口注意15672为工具界面端口 25672为集群端口
factory.setPort(5672);
factory.setVirtualHost("/jxd");
factory.setUsername("jxd");
factory.setPassword("123");
//获取连接
Connection connection = factory.newConnection();

return connection;

}
}
这里说一下配置虚拟主机和用户名密码

为什么会有虚拟主机：

当我们在创建用户时，会指定用户能访问一个虚拟机，并且该用户只能访问该虚拟机下的队列和交换机，如果没有指定，默认的是”/”;一个rabbitmq服务器上可以运行多个vhost，以便于适用不同的业务需要，这样做既可以满足权限配置的要求，也可以避免不同业务之间队列、交换机的命名冲突问题，因为不同vhost之间是隔离的。

设置权限：

1.2.1简单模式
生产者：

package com.sakura.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Sender {
private final static String QUEUE_NAME = "simple_queue";

public static void main(String[] args) throws IOException {
//创建连接
Connection connection = ConnectionUtil.getConnection();
//创建通道
Channel channel = connection.createChannel();
//声明队列
/**
* 队列名
* 是否持久化
* 是否排外即只允许该channel访问该队列一般等于true的话用于一个队列只能有一个消费者来消费的场景
* 是否自动删除消费完删除
* 其他属性
*
*/
channel.queueDeclare(QUEUE_NAME, false, false, false, null);

//消息内容
/**
* 交换机
* 队列名
* 其他属性路由
* 消息body
*/
String message = "错的不是我，是这个世界~";
channel.basicPublish("", QUEUE_NAME,null,message.getBytes());
System.out.println("[x]Sent '"+message + "'");

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

}
}

消费者：

package com.sakura.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver {
private final static String QUEUE_NAME = "simple_queue";

public static void main(String[] args) throws IOException, InterruptedException {
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();

channel.queueDeclare(QUEUE_NAME, false, false, false, null);
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, true, consumer);

while(true){
//该方法会阻塞
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received '"+message+"'");

}
}
}

1.2.1work模式
生产者：

package com.sakura.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Sender {
private final static String QUEUE_NAME = "queue_work";

public static void main(String[] args) throws IOException, InterruptedException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.queueDeclare(QUEUE_NAME, false, false, false, null);
for(int i = 0; i < 100; i++){
String message = "冬马小三" + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("[x] Sent '"+message + "'");
Thread.sleep(i*10);
}

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

消费者：

package com.sakura.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver1 {
private final static String QUEUE_NAME = "queue_work";

public static void main(String[] args) throws IOException, InterruptedException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

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

QueueingConsumer consumer = new QueueingConsumer(channel);
//关于手工确认待之后有时间研究下
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received1 '"+message+"'");
Thread.sleep(10);
//返回确认状态
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

}
}
package com.sakura.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver2 {
private final static String QUEUE_NAME = "queue_work";

public static void main(String[] args) throws IOException, InterruptedException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

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

QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received2 '"+message+"'");
Thread.sleep(1000);
//返回确认状态
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

}
}

channel.basicQos启
The following basic (Java) example will receive a maximum of 10 unacknowledged messages at once:

依据官网看。是指通道channel每次能够接收的消费者最大值 https://www.rabbitmq.com/consumer-prefetch.html

若将该行代码注释，则channel无限制，消息将很快发送完毕，只不过消息阻塞在队列中

1.2.3订阅模式
1.2.4路由模式
生产者：

package com.sakura.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
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 {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.exchangeDeclare(EXCHANGE_NAME,EXCHANGE_TYPE);

String message = "那一定是蓝色";
channel.basicPublish(EXCHANGE_NAME,"key2", null, message.getBytes());
System.out.println("[x] Sent '"+message+"'");

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

消费者：

package com.sakura.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
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, InterruptedException {
// 获取到连接以及mq通道
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.queueDeclare(QUEUE_NAME, false,false,false,null);
channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"key");
channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"key2");

channel.basicQos(1);

QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received1 "+message);
Thread.sleep(10);

channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

}
}

package com.sakura.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver2 {
private final static String QUEUE_NAME = "queue_routing2";
private final static String EXCHANGE_NAME = "exchange_direct";

channel.queueDeclare(QUEUE_NAME, false,false,false,null);
channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"key2");

channel.basicQos(1);

QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received2 "+message);
Thread.sleep(10);

channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

}
}
路由模式下，一个队列可以绑定多个路由

1.2.5topic模式
生产者：

package com.sakura.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
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 {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE);

//消息内容
String message = "如果真爱有颜色";
channel.basicPublish(EXCHANGE_NAME,"key.1",null,message.getBytes());
System.out.println("[x] Sent '"+message+"'");

//关通道关连接
channel.close();
connection.close();
}
}

消费者：

package com.sakura.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver1 {
private final static String QUEUE_NAME = "queue_topic";
private final static String EXCHANGE_NAME = "exchange_topic";
private final static String EXCHANGE_TYPE = "topic";

public static void main(String[] args) throws IOException, InterruptedException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.queueDeclare(QUEUE_NAME, false, false,false, null);
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key.*");

channel.basicQos(1);

QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received1 '"+message + "'");
Thread.sleep(10);

channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

package com.sakura.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.sakura.util.ConnectionUtil;

import java.io.IOException;

/**
* Created by apple on 2018/9/4.
*/
public class Receiver2 {
private final static String QUEUE_NAME = "queue_topic2";
private final static String EXCHANGE_NAME = "exchange_topic";
private final static String EXCHANGE_TYPE = "topic";

public static void main(String[] args) throws IOException, InterruptedException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();

channel.queueDeclare(QUEUE_NAME, false, false,false, null);
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.*");

channel.basicQos(1);

QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(QUEUE_NAME, false, consumer);

while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
System.out.println("[x] Received2 '"+message + "'");
Thread.sleep(10);

channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

项目地址：https://gitee.com/ecoSakuraSou/spring-rabbitmq
---------------------
作者：爱真白真是太好了
来源：CSDN
原文：https://blog.csdn.net/qq_33040219/article/details/82383127
版权声明：本文为博主原创文章，转载请附上博文链接！

rabbitmq官方的六种工作模式的更多相关文章

RabbitMQ从零到集群高可用(.NetCore5.0) - RabbitMQ简介和六种工作模式详解
一.RabbitMQ简介是一个开源的消息代理和队列服务器,用来通过普通协议在完全不同的应用之间共享数据,RabbitMQ是使用Erlang(高并发语言)语言来编写的,并且RabbitMQ是基于AMQ ...
SpringBoot整合RabbitMQ实现六种工作模式
RabbitMQ主要有六种种工作模式,本文整合SpringBoot分别介绍工作模式的实现. 前提概念生产者消息生产者或者发送者,使用P表示: 队列消息从生产端发送到消费端,一定要通过队列转发,使 ...
RabbitMQ的六种工作模式
一.基于erlang语言: 是一种支持高并发的语言 RabbitMQ的六种工作模式: 1.1 simple简单模式消息产生着§将消息放入队列消息的消费者(consumer) 监听(while) 消 ...
RabbitMQ的六种工作模式总结
最近学习RabbitMQ的使用方式,记录下来,方便以后使用,也方便和大家共享,相互交流. RabbitMQ的六种工作模式: 1.Work queues2.Publish/subscribe3.Rout ...
RabbitMQ六种工作模式有哪些？怎样用SpringBoot整合RabbitMQ
目录一.RabbitMQ入门程序二.Work queues 工作模式三.Publish / Subscribe 发布/订阅模式四.Routing 路由模式五.Topics 六.Header ...
rabbitmq的五种工作模式
abbitmq的五种工作模式
消息队列rabbitmq的五种工作模式（go语言版本）
前言:如果你对rabbitmq基本概念都不懂,可以移步此篇博文查阅消息队列RabbitMQ 一.单发单收二.工作队列Work Queue 三.发布/订阅 Publish/Subscribe 四.路由 ...
RabbitMQ的几种工作模式
maven: <dependencies>  <dependency> <groupId>com.rabbit ...
RabbitMQ工作模式
------------恢复内容开始------------ RabbitMQ基本概念: Producer:生产者(消息的提供者) Consumer:消费者(消息的使用者) Message:消息(程序 ...

随机推荐

[ Laravel 5.5 文档 ] 快速入门 —— 目录结构篇
简介 Laravel 默认的目录结构试图为不管是大型应用还是小型应用提供一个良好的起点.当然,你也可以按照自己的喜好重新组织应用的目录结构,因为 Laravel 对于指定类在何处被加载没有任何限制 — ...
js 判断数组中是否有重复值
function arrHasvalue(arr) { var nary = arr.sort(); for (var i = 0; i < arr.length; i++) { if (nar ...
[IB]Integration Broker 是如何处理传入的请求（Part 2）
让我们讨论一下集成代理如何处理传入的请求.可以先阅读(理解PeopleSoft集成代理 Part1). 当PeopleSoft集成代理接收传入请求时,会发生一系列事件. 当侦听连接器(Listenin ...
矢量图面层和线层相交得到相交后的线层文件（gis相交）
目的:将arcgis里的面层和线层相交(重叠)部分的线单独生成一个shp文件,用于道路路网密度计算等. 注意:进行相交运算后生成的是线要素文件,相当于把面线相交部分的线单独拿了出来. 操作例子:将图示 ...
7.Odoo产品分析 (二) – 商业板块(3) –CRM(1)
查看Odoo产品分析系列--目录 CMR:Customer Relationship Management.企业为提高核心竞争力,利用相应的信息技术以及互联网技术协调企业与顾客间在销售.营销和服务上的 ...
使用Redis作为分布式锁的一些注意点
Redis实现分布式锁最近看分布式锁的过程中看到一篇不错的文章,特地的加工一番自己的理解: Redis分布式锁实现的三个核心要素: 1.加锁最简单的方法是使用setnx命令.key是锁的唯一标识, ...
<自动化测试方案_5>第五章、代码单元自动化测试
第五章.代码单元自动化测试代码单元测试需要根据编程语言,选择单元测试框架,然后访问类方法,函数.代码单元测试做自动化,相比API.UI自动化做起来更加麻烦,建议放到待API自动化测试.UI自动化测试 ...
记CSS格式化上下文
fomatting context 引言主要讲解的是BFC上下文本文是查看史上最全面.最透彻的BFC原理剖析的笔记所以不会详解BFC, 只是记录学习心得, 以及重要规则避免原文失效简介 F ...
PostgreSQL 多级分区
CREATE TABLE range_list (a int,b timestamp) PARTITION BY RANGE (b); CREATE TABLE range_pa1 PARTITION ...
JaveScript 中的正则表达式
1.语法: var expression = /pattern/flags ; pattern: 任何简单或复杂的正则表达式. flags: 可以是 g,i,m 或它们的组合. ...

rabbitmq官方的六种工作模式

rabbitmq官方的六种工作模式的更多相关文章

随机推荐

热门专题