关于RabbitMQ

最新推荐文章于 2024-05-18 12:29:01 发布

Hello！joy先生

最新推荐文章于 2024-05-18 12:29:01 发布

阅读量183

点赞数

文章标签： rabbitmq

本文链接：https://blog.csdn.net/weixin_45341429/article/details/124151017

版权

关于RabbitMQ

##RabbitMQ的基本概念

RabbitMQ是一种消息中间件,用来处理客户端的异步消息,服务端将要发送的消息放到对列池中,客户端可以根据RabbitMQ配置的转发机制来接收消息,RabbitMQ依据指定的转发规则进行消息的转发,缓冲和持久化操作,主要用在多服务器间和单服务器的子系统间进行交互通信,是分布式系统标准配置.

RabbitMQ的使用场景

服务解耦

假设现在有B,C,D三个业务调用同一个业务A,这时因为业务量较小,可能不会有什么问题,但是随着业务的增加,可能会变成几千的业务都需要A这个业务那就可能会遇到很多问题,比如其中的一个业务挂掉了怎么办,A服务的代码变更频繁怎么办…这就是因为业务之间耦合性太高,此时我们需要一个中间人来帮我们缓解这种压力,这就用到RabbitMQ了.

在这里插入图片描述

有了RabbitMQ,A业务就只负责将消息发送给RabbitMQ,其他业务需要A再由RabbitMQ异步发送给其他业务,A本身不在关心消息是否被实时的接收.

在这里插入图片描述

流量削峰

假设一个平台,平时访问量是300/秒,那么一台服务器足够了,如果青苔突然火了,访问量增加了十倍,服务器苦不堪言啊,老板又没钱买服务器咋整,只能先用RabbitMQ做削峰处理,把请求先放到消息队列中,排队等待被处理,给应用一个缓冲的时间,慢慢处理,不至于使服务崩溃.
在这里插入图片描述

异步调用

其实我们每天点外卖的场景就是一个异步调用,就这么说吧,中午12点点餐高峰期,当你把钱付完以后,你觉得外卖小哥会立马收到你的消息吗?并不会,因为下单量很大,需要等待很长时间才能找到匹配的小哥,那谁去进行等待呢?肯定不是我们,我们只管付钱就完事了,其实我们付钱之后,我们的这条订单消息就被放到了消息队列里,只要有空闲的小哥,那么这条消息才被接收到,这样就是一个异步调用.由消息队列帮我们等待小哥的出现.

RabbitMQ六中工作模式

简单模式（Simple / HelloWorld 单生产单消费）

RabbitMQ是一个消息中间件,就像生活中的邮局或者寄快递是一样的,我们写好信之后,就交给邮局处理,这封信什么时候能送到,我们不用关心,由邮局处理即可.

发送消息的程序是生产者,就是写信的人

对列代表的就是邮箱,多个生产者可以向同一个对列发送消息,多个消费者也可以接收同一个对列的消息.

消费者等待从对列接收消息,收信的人

简单模式只有一个消费者.

在这里插入图片描述

添加依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.tedu</groupId>
	<artifactId>rabbitmq</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>com.rabbitmq</groupId>
			<artifactId>amqp-client</artifactId>
			<version>5.4.3</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.8.0-alpha2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.8.0-alpha2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

生产者发送消息

package rabbitmq.simple;

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

public class Test1 {
	public static void main(String[] args) throws Exception {
		//创建连接工厂,并设置连接信息
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);//可选,5672是默认端口
		f.setUsername("admin");
		f.setPassword("admin");

		/*
		 * 与rabbitmq服务器建立连接,
		 * rabbitmq服务器端使用的是nio,会复用tcp连接,
		 * 并开辟多个信道与客户端通信
		 * 以减轻服务器端建立连接的开销
		 */
		Connection c = f.newConnection();
		//建立信道
		Channel ch = c.createChannel();

		/*
		 * 声明队列,会在rabbitmq中创建一个队列
		 * 如果已经创建过该队列，就不能再使用其他参数来创建
		 * 
		 * 参数含义:
		 *   -queue: 队列名称
		 *   -durable: 队列持久化,true表示RabbitMQ重启后队列仍存在
		 *   -exclusive: 排他,true表示限制仅当前连接可用
		 *   -autoDelete: 当最后一个消费者断开后,是否删除队列
		 *   -arguments: 其他参数
		 */
		ch.queueDeclare("helloworld", false,false,false,null);

		/*
		 * 发布消息
		 * 这里把消息向默认交换机发送.
		 * 默认交换机隐含与所有队列绑定,routing key即为队列名称
		 * 
		 * 参数含义:
		 * 	-exchange: 交换机名称,空串表示默认交换机"(AMQP default)",不能用 null 
		 * 	-routingKey: 对于默认交换机,路由键就是目标队列名称
		 * 	-props: 其他参数,例如头信息
		 * 	-body: 消息内容byte[]数组
		 */
		ch.basicPublish("", "helloworld", null, "Hello world!".getBytes());

		System.out.println("消息已发送");
		c.close();
	}
}

可以将建立连接写一个工具类,用的时候直接调用即可

消费者接收消息

package rabbitmq.simple;

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

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

public class Test2 {
	public static void main(String[] args) throws Exception {
		//连接工厂
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		//建立连接
		Connection c = f.newConnection();
		//建立信道
		Channel ch = c.createChannel();
		//声明队列,如果该队列已经创建过,则不会重复创建
		ch.queueDeclare("helloworld",false,false,false,null);
		System.out.println("等待接收数据");
		
		//收到消息后用来处理消息的回调对象
		DeliverCallback callback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				String msg = new String(message.getBody(), "UTF-8");
				System.out.println("收到: "+msg);
			}
		};
		
		//消费者取消时的回调对象
		CancelCallback cancel = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		ch.basicConsume("helloworld", true, callback, cancel);
	}
}

工作模式(Work单发送多接收 )

一个生产者多个消费者

多个消费者从同一个对列接收消息

负载均衡:采用轮询模式发送给所有消费者

合理分发消息:

手动ACK:消息回执,向服务器发送一条通知,告诉服务器一条消息已经处理完成,服务器可以通过ACK,知道消费者是空闲还是繁忙

QOS=1:每次抓取消息的数量,消息处理完成之前不会抓取新消息,手动ACK下生效

消息持久化:在服务器端,持久保存消息,避免因服务器宕机造成消息丢失

队列持久化: c.queueDeclare(“队列名”,true,…)

消息持久化:c.basicPublish(“”,队列名,MessageProperties.PERSISTENT_TEXT_PLAN,消息)

在这里插入图片描述

工作对列即任务队列,主要思想是避免立即执行资源密集型任务,并且必须等待它完成.相反,我们将任务安排在稍后完成,我们将任务封装为消息,并将其发送到消息队列,后台运行的进程最终会获取并执行任务,当有多个消费者时,任务将在他们之间分发.

使用任务队列,可以并行工作,如果工作任务太多,我们可以多添加工作进程.

生产者发送消息

这里我们模拟一个耗时任务,每个"."耗时1秒钟,比如"hello…"就会耗时3秒钟

package rabbitmq.workqueue;

import java.util.Scanner;

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

public class Test1 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);
		f.setUsername("admin");
		f.setPassword("admin");
		
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		//参数:queue,durable,exclusive,autoDelete,arguments
		ch.queueDeclare("helloworld", false,false,false,null);

		while (true) {
		    //控制台输入的消息发送到rabbitmq
			System.out.print("输入消息: ");
			String msg = new Scanner(System.in).nextLine();
			//如果输入的是"exit"则结束生产者进程
			if ("exit".equals(msg)) {
				break;
			}
			//参数:exchage,routingKey,props,body
			ch.basicPublish("", "helloworld", null, msg.getBytes());
			System.out.println("消息已发送: "+msg);
		}

		c.close();
	}
}

消费者接收消息

package rabbitmq.workqueue;

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

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

public class Test2 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		ch.queueDeclare("helloworld",false,false,false,null);
		System.out.println("等待接收数据");
		
		//收到消息后用来处理消息的回调对象
		DeliverCallback callback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				String msg = new String(message.getBody(), "UTF-8");
				System.out.println("收到: "+msg);

				//遍历字符串中的字符,每个点使进程暂停一秒
				for (int i = 0; i < msg.length(); i++) {
					if (msg.charAt(i)=='.') {
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
						}
					}
				}
				System.out.println("处理结束");
			}
		};
		
		//消费者取消时的回调对象
		CancelCallback cancel = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		ch.basicConsume("helloworld", true, callback, cancel);
	}
}

本次测试起一个生产者两个消费者

生产者发送多条消息1,2,3,4,5

消费者1接收到:1,3,5

消费者2接收到:2,4

rabbitmq会将消息轮询且平均发送给消费者

####消息确认

如果一个消费者在接收到消息后,在没有处理完这条消息时就挂掉了,这时会发生什么?

就以上代码来说,rabbitmq将消息发送给消费者后,就会将此消息立即删除,那么消费者此时挂掉了,就会丢失还未处理完的消息.

为了保证消息不丢失,rabbitmq支持消息确认(回执),当一个消费者接收到消息并处理完毕后,消费者会发送一个ack给rabbitmq服务器,告诉他消息已经处理完毕,可以删除消息了

如果一个消费者没有返回消息就挂掉了,那么rabbitmq就会知道这个消息没有被处理完,rabbitmq会重新将此消息放入队列中,如果有空闲的消费者,那么就会把这条消息传递给其他消费者,这样就确保了消息不会丢失

这里不存咋消息超时,即使消费者挂掉,重新分配消费者话费很多时间也不回有超时.

手动确认是默认开启的

//autoAck设置为false,则需要手动确认发送回执
ch.basicConsume("helloworld", false, callback, cancel);

####合理分发消息

rabbitmq会一次分发多个消息给消费者,即使有的消费者都在拼命的处理,很繁忙,有的消费者闲的不行,rabbitmq全然不知,还是不停的在发消息,这样资源分配不均,效率大大降低,这时我们可以使用 ==basicQos(1)==方法,这告诉rabbitmq,一次只向消费者发送一条消息,在返回确认回执前,不要再次发送新消息,而是把消息发送给空闲的消费者.

####消息持久化

当rabbitmq关闭时,任然会丢失消息,除非明确要求他不要丢失消息

可以把队列和消息都设置为可持久化(durable)

队列持久化

//第二个参数是持久化参数durable
ch.queueDeclare("helloworld", true, false, false, null);

消息持久化

//定义一个新的队列,名为 task_queue
//第二个参数是持久化参数 durable
ch.queueDeclare("task_queue", true, false, false, null);

//第三个参数设置消息持久化
ch.basicPublish("", "task_queue",
            MessageProperties.PERSISTENT_TEXT_PLAIN,
            msg.getBytes());

发布订阅模式(Fanout)

将消息群发给所有消费者,同一条消息,所有消费者都能接收到

方式:fanout类型交换机

生产者:1.定义fanout交换机. 2.向交换机发送消息

消费者:1.定义fanout交换机.2.定义自己独占的随机对列. 3.绑定 4.正常从随机对列接收数据

在这里插入图片描述

我们向多个消费者传递同一条消息,这种模式叫做发布/订阅模式

我们通过构建一个简单的日志系统,该系统由两部分组成:一部分是发出日志消息,另一部分接收消息

在系统中,每个运行的的副本都会接收到消息,此时我们可以运行一个消费者将日志保留在磁盘,另一个消费者在控制台打印

最终消息广播到所有消费者

Exchanges交换机

RabbitMQ的核心思想是,生产者永远不会将任何消息直接发送给消费者,甚至都不会知道消息是否会被传递到消息队列

生产者只能向交换机发送消息,交换机负责接收生产者的消再将消息推送到消息队列,交换机必须确切的知道如何处理接收到的消息,比如是否添加到特定的队列中?是否添加到多个对列?消息是否被丢弃?这些规则有exchanges类型定义

交换机类型:

direct(直连交换机)

topic(主题交换机)

fanout(扇出)

header

先来关注fanout交换机

fanout交换机可以将消息广播给所有他发现的对列

首先我们做两件事情,保证可以接收所有的日志消息,并且接收到的消息都是新消息.

首先连接到rabbitmq时需要一个空队列,其次服务器一旦断开,就自动删除对列

随机生成队列名

// 创建随机对列
String queque = UUID.randomUUID().toString();
//非持久,独占,自动删除
channel.queueDeclare(queque,false,true,true,null);

新建交换机并绑定Bindings

新建交换机

channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);

绑定

channel.queueBind(queque, "logs", "")

绑定就是告诉交换机向指定的对列发送消息

生产者

package rabbitmq.publishsubscribe;

import java.util.Scanner;

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

public class Test1 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);
		f.setUsername("admin");
		f.setPassword("admin");
		
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		
		//定义名字为logs的交换机,交换机类型为fanout
		//这一步是必须的，因为禁止发布到不存在的交换。
		ch.exchangeDeclare("logs", "fanout");
		
		while (true) {
			System.out.print("输入消息: ");
			String msg = new Scanner(System.in).nextLine();
			if ("exit".equals(msg)) {
				break;
			}
			
			//第一个参数,向指定的交换机发送消息
			//第二个参数,不指定队列,由消费者向交换机绑定队列
			//如果还没有队列绑定到交换器，消息就会丢失，
			//但这对我们来说没有问题;即使没有消费者接收，我们也可以安全地丢弃这些信息。
			ch.basicPublish("logs", "", null, msg.getBytes("UTF-8"));
			System.out.println("消息已发送: "+msg);
		}

		c.close();
	}
}

消费者

package rabbitmq.publishsubscribe;

import java.io.IOException;

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

public class Test2 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		
		//定义名字为 logs 的交换机, 它的类型是 fanout
		ch.exchangeDeclare("logs", "fanout");
		
		//自动生成对列名,
		//非持久,独占,自动删除
		String queque = UUID.randomUUID().toString();
		channel.queueDeclare(queque,false,true,true,null);
		//把该队列,绑定到 logs 交换机
		//对于 fanout 类型的交换机, routingKey会被忽略，不允许null值
		ch.queueBind(queueName, "logs", "");
		
		System.out.println("等待接收数据");
		
		//收到消息后用来处理消息的回调对象
		DeliverCallback callback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				String msg = new String(message.getBody(), "UTF-8");
				System.out.println("收到: "+msg);
			}
		};
		
		//消费者取消时的回调对象
		CancelCallback cancel = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		ch.basicConsume(queueName, true, callback, cancel);
	}
}

路由模式(Direct)

大体来讲路由模式和发布订阅模式是类似的,只不过路由模式多了一种匹配机制.消息中可携带路由键,通过路由键匹配相应的消息队列中

生产者定义:

交换机:direct

向direct交换机发送数据并携带路由键

消费者定义:

1.定义交换机

2.定义队列

3.用绑定建绑定

4.正常接受数据

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qm328Sof-1649837837884)(C:\Users\11500\AppData\Local\Temp\1649833920006.png)]$

本次我们只接收部分日志消息,比如我只接受error类型的日志保存到磁盘,同时仍然可以在控制台打印所有一直消息

创建交换机

//参数1: 交换机名
//参数2: 交换机类型
ch.exchangeDeclare("direct_logs", "direct");

生产者

package m4;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import utils.RabbitConnection;

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

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接并获取到连接通道
        Channel channel = RabbitConnection.getConnection().createChannel();

        // 创建DIRECT交换机 direct_logs  
        channel.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
        
        while (true){
            System.out.println("输入消息:");
            String s = new Scanner(System.in).nextLine();
            System.out.println("输入路由键:");
            String routKey = new Scanner(System.in).nextLine();
            /**
             * 第二个参数是路由键
             * 如果使用默认交换机,(""),默认使用队列名作为关键词
             * */
            channel.basicPublish("direct_logs", routKey, null , s.getBytes());
        }
    }
}

消费者

package m4;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import utils.RabbitConnection;

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

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 通信的通道
        Channel channel = RabbitConnection.getConnection().createChannel();
        // 创建随机对列
        String queque = UUID.randomUUID().toString();
        // false非持久  true独占  true自动删除
        channel.queueDeclare(queque,false,true,true,null);
        // 新建交换机
        channel.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
        // 绑定
        System.out.println("输入绑定建,用空格隔开:");
        String s = new Scanner(System.in).nextLine().trim(); // 去除两端空白字符
        String[] a = s.split("\\s+"); // \s表示空白字符  +:指的是多个
        for (String k :
                a) {
            channel.queueBind(queque, "direct_logs", k);
        }



        // 回调对象
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            String key = message.getEnvelope().getRoutingKey();
            String msg = new String(message.getBody());
            System.out.println("收到:"+key+"的消息:"+msg);

        };
        CancelCallback cancelCallback = consumerTag -> {};
        // 接收消息
        /**
         * 工作模式合理分发消息
         * 1.使用手动模式确认
         * 消息分发不合理的原因,是服务器不知道消费者有没有处理完消息
         * 使用手动确认模式,不仅是保证消息被正确的处理,也可以让服务器知道消费者有没有处理完消息
         * 2.设置qos=1
         *  每次只接收一条消息,处理完成之前不接收下一条
         *  只在手动确认模式才有效
         *
         * */
       // channel.basicQos(1); // 每次收1条,处理完之前不收下一条,手动确认模式才有效
        channel.basicConsume(queque,true,deliverCallback,cancelCallback);
    }
}

主题模式(Topic)

主题模式与路由模式又有些相似之处,也是处理有特殊关键词的消息,但是在路由模式的基础之上,又进行了扩展,使之变得更加灵活

比如在我们的日志系统中，我们可能不仅希望根据级别订阅日志，还希望根据发出日志的源订阅日志

这将给我们带来很大的灵活性——我们可能只想接收来自“cron”的关键错误，但也要接收来自“kern”的所有日志。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iveug6r1-1649837837884)(C:\Users\11500\AppData\Local\Temp\1649836199908.png)]$

在本例中，我们将发送描述动物的消息。这些消息将使用由三个单词(两个点)组成的routingKey发送。routingKey中的第一个单词表示速度，第二个是颜色,第三个是物种:“<速度>.<颜色>.<物种>”。

我们创建三个绑定:Q1与bindingKey “.orange.” 绑定。和Q2是 “..rabbit” 和 “lazy.#” 。

这些绑定可概括为:

Q1对所有橙色的动物感兴趣。
Q2想接收关于兔子和慢速动物的所有消息。
将routingKey设置为"quick.orange.rabbit"的消息将被发送到两个队列。消息 "lazy.orange.elephant“也发送到它们两个。另外”quick.orange.fox“只会发到第一个队列，”lazy.brown.fox“只发给第二个。”lazy.pink.rabbit“将只被传递到第二个队列一次，即使它匹配两个绑定。”quick.brown.fox"不匹配任何绑定，因此将被丢弃。

如果我们违反约定，发送一个或四个单词的信息，比如"orange“或”quick.orange.male.rabbit"，会发生什么?这些消息将不匹配任何绑定，并将丢失。

另外，“lazy.orange.male.rabbit”，即使它有四个单词，也将匹配最后一个绑定，并将被传递到第二个队列

生产者

package rabbitmq.topic;

import java.util.Random;
import java.util.Scanner;

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

public class Test1 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);
		f.setUsername("admin");
		f.setPassword("admin");
		
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		
		//参数1: 交换机名
		//参数2: 交换机类型
		ch.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
		
		while (true) {
			System.out.print("输入消息: ");
			String msg = new Scanner(System.in).nextLine();
			if ("exit".contentEquals(msg)) {
				break;
			}
			System.out.print("输入routingKey: ");
			String routingKey = new Scanner(System.in).nextLine();
			
			//参数1: 交换机名
			//参数2: routingKey, 路由键,这里我们用日志级别,如"error","info","warning"
			//参数3: 其他配置属性
			//参数4: 发布的消息数据 
			ch.basicPublish("topic_logs", routingKey, null, msg.getBytes());
			
			System.out.println("消息已发送: "+routingKey+" - "+msg);
		}

		c.close();
	}
}

消费者

package rabbitmq.topic;

import java.io.IOException;
import java.util.Scanner;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;

public class Test2 {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		
		ch.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
		
		//自动生成对列名,
		//非持久,独占,自动删除
		String queueName = ch.queueDeclare().getQueue();
		
		System.out.println("输入bindingKey,用空格隔开:");
		String[] a = new Scanner(System.in).nextLine().split("\\s");
		
		//把该队列,绑定到 topic_logs 交换机
		//允许使用多个 bindingKey
		for (String bindingKey : a) {
			ch.queueBind(queueName, "topic_logs", bindingKey);
		}
		
		System.out.println("等待接收数据");
		
		//收到消息后用来处理消息的回调对象
		DeliverCallback callback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				String msg = new String(message.getBody(), "UTF-8");
				String routingKey = message.getEnvelope().getRoutingKey();
				System.out.println("收到: "+routingKey+" - "+msg);
			}
		};
		
		//消费者取消时的回调对象
		CancelCallback cancel = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		ch.basicConsume(queueName, true, callback, cancel);
	}
}

RPC模式

服务器

package rabbitmq.rpc;

import java.io.IOException;
import java.util.Random;
import java.util.Scanner;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;
import com.rabbitmq.client.AMQP.BasicProperties;

public class RPCServer {
	public static void main(String[] args) throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setPort(5672);
		f.setUsername("admin");
		f.setPassword("admin");
		
		Connection c = f.newConnection();
		Channel ch = c.createChannel();
		/*
		 * 定义队列 rpc_queue, 将从它接收请求信息
		 * 
		 * 参数:
		 * 1. queue, 对列名
		 * 2. durable, 持久化
		 * 3. exclusive, 排他
		 * 4. autoDelete, 自动删除
		 * 5. arguments, 其他参数属性
		 */
		ch.queueDeclare("rpc_queue",false,false,false,null);
		ch.queuePurge("rpc_queue");//清除队列中的内容
		
		ch.basicQos(1);//一次只接收一条消息
		
		
		//收到请求消息后的回调对象
		DeliverCallback deliverCallback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				//处理收到的数据(要求第几个斐波那契数)
				String msg = new String(message.getBody(), "UTF-8");
				int n = Integer.parseInt(msg);
				//求出第n个斐波那契数
				int r = fbnq(n);
				String response = String.valueOf(r);
				
				//设置发回响应的id, 与请求id一致, 这样客户端可以把该响应与它的请求进行对应
				BasicProperties replyProps = new BasicProperties.Builder()
						.correlationId(message.getProperties().getCorrelationId())
						.build();
				/*
				 * 发送响应消息
				 * 1. 默认交换机
				 * 2. 由客户端指定的,用来传递响应消息的队列名
				 * 3. 参数(关联id)
				 * 4. 发回的响应消息
				 */
				ch.basicPublish("",message.getProperties().getReplyTo(), replyProps, response.getBytes("UTF-8"));
				//发送确认消息
				ch.basicAck(message.getEnvelope().getDeliveryTag(), false);
			}
		};
		
		//
		CancelCallback cancelCallback = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		//消费者开始接收消息, 等待从 rpc_queue接收请求消息, 不自动确认
		ch.basicConsume("rpc_queue", false, deliverCallback, cancelCallback);
	}

	protected static int fbnq(int n) {
		if(n == 1 || n == 2) return 1;
		
		return fbnq(n-1)+fbnq(n-2);
	}
}

客户端

package rabbitmq.rpc;

import java.io.IOException;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Delivery;
import com.rabbitmq.client.AMQP.BasicProperties;

public class RPCClient {
	Connection con;
	Channel ch;
	
	public RPCClient() throws Exception {
		ConnectionFactory f = new ConnectionFactory();
		f.setHost("192.168.64.140");
		f.setUsername("admin");
		f.setPassword("admin");
		con = f.newConnection();
		ch = con.createChannel();
	}
	
	public String call(String msg) throws Exception {
		//自动生成对列名,非持久,独占,自动删除
		String replyQueueName = ch.queueDeclare().getQueue();
		//生成关联id
		String corrId = UUID.randomUUID().toString();
		
		//设置两个参数:
		//1. 请求和响应的关联id
		//2. 传递响应数据的queue
		BasicProperties props = new BasicProperties.Builder()
				.correlationId(corrId)
				.replyTo(replyQueueName)
				.build();
		//向 rpc_queue 队列发送请求数据, 请求第n个斐波那契数
		ch.basicPublish("", "rpc_queue", props, msg.getBytes("UTF-8"));
		
		//用来保存结果的阻塞集合,取数据时,没有数据会暂停等待
		BlockingQueue<String> response = new ArrayBlockingQueue<String>(1);
		
		//接收响应数据的回调对象
		DeliverCallback deliverCallback = new DeliverCallback() {
			@Override
			public void handle(String consumerTag, Delivery message) throws IOException {
				//如果响应消息的关联id,与请求的关联id相同,我们来处理这个响应数据
				if (message.getProperties().getCorrelationId().contentEquals(corrId)) {
					//把收到的响应数据,放入阻塞集合
					response.offer(new String(message.getBody(), "UTF-8"));
				}
			}
		};

		CancelCallback cancelCallback = new CancelCallback() {
			@Override
			public void handle(String consumerTag) throws IOException {
			}
		};
		
		//开始从队列接收响应数据
		ch.basicConsume(replyQueueName, true, deliverCallback, cancelCallback);
		//返回保存在集合中的响应数据
		return response.take();
	}
	
	public static void main(String[] args) throws Exception {
		RPCClient client = new RPCClient();
		while (true) {
			System.out.print("求第几个斐波那契数:");
			int n = new Scanner(System.in).nextInt();
			String r = client.call(""+n);
			System.out.println(r);
		}
	}
}