RabbitMQ三：工作模式

简单消息模式

搭建工程

工程坐标如下

<groupId>cn.com.javakf</groupId>
<artifactId>rabbitmq</artifactId>
<version>1.0-SNAPSHOT</version>

pom文件引入以下依赖

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

生产者

生产者的创建分为如下几个步骤

//创建链接工厂对象

//设置RabbitMQ服务主机地址,默认localhost

//设置RabbitMQ服务端口,默认5672

//设置虚拟主机名字，默认/

//设置用户连接名，默认guest

//设置链接密码，默认guest

//创建链接

//创建频道

//声明队列

//创建消息

//消息发送

//关闭资源

按照上面的步骤，创建一个消息生产者，创建cn.com.javakf.rabbitmq.simple.Producer

public class Producer {

	/***
	 * 消息生产者
	 * 
	 * @param args
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
		 * 声明队列
		 * 参数1：队列名称
		 * 参数2：是否定义持久化队列
		 * 参数3：是否独占本次连接
		 * 参数4：是否在不使用的时候自动删除队列
		 * 参数5：队列其它参数
		 */
		channel.queueDeclare("simple_queue", true, false, false, null);

		// 创建消息
		String message = "hello!welcome to javakf!";

		/**
         * 消息发送
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicPublish("", "simple_queue", null, message.getBytes());

		// 关闭资源
		channel.close();
		connection.close();
	}
}

在执行上述的消息发送之后；可以登录rabbitMQ的管理控制台，可以发现队列和其消息
在这里插入图片描述
如果想查看消息，可以点击队列名称->Get Messages,如下图

消费者

消费者创建可以按照如下步骤实现

//创建链接工厂对象

//设置RabbitMQ服务主机地址,默认localhost

//设置RabbitMQ服务端口,默认5672

//设置虚拟主机名字，默认/

//设置用户连接名，默认guest

//设置链接密码，默认guest

//创建链接

//创建频道

//创建队列

//创建消费者，并设置消息处理

//消息监听

//关闭资源(不建议关闭，建议一直监听消息)

按照上面的步骤创建消息消费者cn.com.javakf.rabbitmq.simple.Consumer

public class Consumer {

	/***
	 * 消息消费者
	 * 
	 * @param args
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		// 创建队列
		channel.queueDeclare("simple_queue", true, false, false, null);

		// 创建消费者，并设置消息处理
		DefaultConsumer defaultConsumer = 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 {
				// 路由的key
				String routingKey = envelope.getRoutingKey();
				// 获取交换机信息
				String exchange = envelope.getExchange();
				// 获取消息ID
				long deliveryTag = envelope.getDeliveryTag();
				// 获取消息信息
				String message = new String(body, "UTF-8");
				System.out.println("routingKey:" + routingKey + ",exchange:" + exchange + ",deliveryTag:" + deliveryTag
						+ ",message:" + message);
			}
		};

		/**
         * 消息监听
         * 参数1：队列名称
         * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
         * 参数3：消息接收到后回调
         */
		channel.basicConsume("simple_queue", true, defaultConsumer);

		// 关闭资源(不建议关闭，建议一直监听消息)
		// channel.close();
		// connection.close();
	}
}

执行后，控制台输入如下
在这里插入图片描述
RabbitMQ控制台如下

工具类抽取

无论是消费者，还是生产者，我们发现前面的几个步骤几乎一模一样，所以可以抽取一个工具类,将下面这段代码抽取出去。

// 创建链接工厂对象
ConnectionFactory connectionFactory = new ConnectionFactory();

// 设置RabbitMQ服务主机地址,默认localhost
connectionFactory.setHost("192.168.80.131");

// 设置RabbitMQ服务端口,默认5672
connectionFactory.setPort(5672);

// 设置虚拟主机名字，默认/
connectionFactory.setVirtualHost("/javakf");

// 设置用户连接名，默认guest
connectionFactory.setUsername("admin");

// 设置链接密码，默认guest
connectionFactory.setPassword("admin");

// 创建链接
Connection connection = connectionFactory.newConnection();

创建cn.com.javakf.rabbitmq.util.ConnectionUtil工具类对象，用于创建Connection

public class ConnectionUtil {

	/***
	 * 创建链接对象
	 * 
	 * @return
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static Connection getConnection() throws IOException, TimeoutException {
		// 创建链接工厂对象
		ConnectionFactory connectionFactory = new ConnectionFactory();

		// 设置RabbitMQ服务主机地址,默认localhost
		connectionFactory.setHost("192.168.80.131");

		// 设置RabbitMQ服务端口,默认5672
		connectionFactory.setPort(5672);

		// 设置虚拟主机名字，默认/
		connectionFactory.setVirtualHost("/javakf");

		// 设置用户连接名，默认guest
		connectionFactory.setUsername("admin");

		// 设置链接密码，默认guest
		connectionFactory.setPassword("admin");

		// 创建链接
		Connection connection = connectionFactory.newConnection();
		return connection;
	}
}

生产者优化

修改cn.com.javakf.rabbitmq.simple.Producer，链接对象使用上面的ConnectionUtil工具类创建

//创建链接
Connection connection = ConnectionUtil.getConnection();

消费者优化

修改cn.com.javakf.rabbitmq.simple.Consumer，链接对象使用上面的ConnectionUtil工具类创建

//创建链接
Connection connection = ConnectionUtil.getConnection();

小结

上述的案例中其实使用的是如下的简单模式：
在这里插入图片描述
在上图的模型中，有以下概念：

P：生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

在rabbitMQ中消息者是一定要到某个消息队列中去获取消息的

Work queues工作队列模式

模式说明

在这里插入图片描述
Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

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

Work Queues与入门程序的简单模式的代码是几乎一样的；可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。

生产者

创建cn.com.javakf.rabbitmq.work.WorkProducer消息生产者对象

public class WorkProducer {

	/***
	 * 消息生产者
	 * 
	 * @param args
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		 /**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
          **/
		channel.queueDeclare("work_queue", true, false, false, null);

		// 创建消息
		String message = "hello!welcome to rabbitmq!";

		/**
         * 消息发送
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicPublish("", "work_queue", null, message.getBytes());

		// 关闭资源
		channel.close();
		connection.close();
	}
}

消费者One

创建第1个Work消费者cn.com.javakf.rabbitmq.work.WorkConsumerOne

public class WorkConsumerOne {

	/***
	 * 消息消费者
	 * 
	 * @param args
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		// 创建队列
		channel.queueDeclare("work_queue", true, false, false, null);

		// 创建消费者，并设置消息处理
		DefaultConsumer defaultConsumer = 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 {
				// 路由的key
				String routingKey = envelope.getRoutingKey();
				// 获取交换机信息
				String exchange = envelope.getExchange();
				// 获取消息ID
				long deliveryTag = envelope.getDeliveryTag();
				// 获取消息信息
				String message = new String(body, "UTF-8");
				System.out.println("Work-One:routingKey:" + routingKey + ",exchange:" + exchange + ",deliveryTag:"
						+ deliveryTag + ",message:" + message);
			}
		};

		 /**
         * 消息发送
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicConsume("work_queue", true, defaultConsumer);

		// 关闭资源(不建议关闭，建议一直监听消息)
		// channel.close();
		// connection.close();
	}
}

消费者Two

创建第1个Work消费者cn.com.javakf.rabbitmq.work.WorkConsumerTwo

public class WorkConsumerTwo {

	/**
	 * 消息消费者
	 * 
	 * @param args
	 * @throws IOException
	 * @throws TimeoutException
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		// 创建队列
		channel.queueDeclare("work_queue", true, false, false, null);

		// 创建消费者，并设置消息处理
		DefaultConsumer defaultConsumer = 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 {
				// 路由的key
				String routingKey = envelope.getRoutingKey();
				// 获取交换机信息
				String exchange = envelope.getExchange();
				// 获取消息ID
				long deliveryTag = envelope.getDeliveryTag();
				// 获取消息信息
				String message = new String(body, "UTF-8");
				System.out.println("Work-Two:routingKey:" + routingKey + ",exchange:" + exchange + ",deliveryTag:"
						+ deliveryTag + ",message:" + message);
			}
		};

		/**
         * 消息监听
         * 参数1：队列名称
         * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
         * 参数3：消息接收到后回调
         */
		channel.basicConsume("work_queue", true, defaultConsumer);

		// 关闭资源(不建议关闭，建议一直监听消息)
		// channel.close();
		// connection.close();
	}
}

测试

启动两个消费者，然后再启动生产者发送消息；到IDEA的两个消费者对应的控制台查看是否竞争性的接收到消息。
在这里插入图片描述

小结

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是 竞争的关系 。

订阅模式类型

订阅模式示例图
前面2个案例中，只有3个角色

P：生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
Queue：消息队列，图中红色部分

而在订阅模型中，多了一个exchange角色，而且过程略有变化

P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
C：消费者，消息的接受者，会一直等待消息到来。
Queue：消息队列，接收消息、缓存消息。
Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

Publish/Subscribe发布与订阅模式

模式说明

在这里插入图片描述
发布订阅模式：

每个消费者监听自己的队列。
生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

生产者

生产者需要注意如下3点

声明交换机
声明队列
队列需要绑定指定的交换机

创建cn.com.javakf.rabbitmq.ps.PublishSubscribeProducer消息生产者

public class PublishSubscribeProducer {

	/***
	 * 订阅模式
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型，fanout、topic、direct、headers
         */
		channel.exchangeDeclare("fanout_exchange", BuiltinExchangeType.FANOUT);

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("fanout_queue_1", true, false, false, null);
		channel.queueDeclare("fanout_queue_2", true, false, false, null);

		// 队列绑定交换机
		channel.queueBind("fanout_queue_1", "fanout_exchange", "");
		channel.queueBind("fanout_queue_2", "fanout_exchange", "");

		// 消息
		String message = "发布订阅模式:欢迎来到XXX！";
		 /**
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicPublish("fanout_exchange", "", null, message.getBytes());

		// 关闭资源
		channel.close();
		connection.close();
	}
}

消费者One

创建cn.com.javakf.rabbitmq.ps.PublishSubscribeConsumerOne消息消费对象

public class PublishSubscribeConsumerOne {

	/***
	 * 订阅模式消息消费者
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("fanout_queue_1", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者One-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("fanout_queue_1", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}
}

消费者Two

创建cn.com.javakf.rabbitmq.ps.PublishSubscribeConsumerTwo消息消费对象

public class PublishSubscribeConsumerTwo {

	/***
	 * 订阅模式消息消费者
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		 /**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("fanout_queue_2", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者Two-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("fanout_queue_2", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}

}

测试

启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息；到达 广播的效果 。
在这里插入图片描述

在执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击 fanout_exchange 的交换机，可以查看到如下的绑定：

小结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式与work队列模式的区别

work队列模式不用定义交换机，而发布/订阅模式需要定义交换机。
发布/订阅模式的生产方是面向交换机发送消息，work队列模式的生产方是面向队列发送消息(底层使用默认交换机)。
发布/订阅模式需要设置队列和交换机的绑定，work队列模式不需要设置，实际上work队列模式会将队列绑定到默认的交换机。

Routing路由模式

模式说明

路由模式特点

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

在这里插入图片描述
图解

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，然后把消息递交给与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

在编码上与 Publish/Subscribe发布与订阅模式的区别是交换机的类型为：Direct，还有队列绑定交换机的时候需要指定routing key。

生产者

创建cn.com.javakf.rabbitmq.toutekey.RouteKeyProducer消息生产者

public class RouteKeyProducer {

	/***
	 * 订阅模式-RouteKey
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型，fanout、topic、direct、headers
         */
		channel.exchangeDeclare("direct_exchange", BuiltinExchangeType.DIRECT);

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("direct_queue_insert", true, false, false, null);
		channel.queueDeclare("direct_queue_update", true, false, false, null);

		// 队列绑定交换机
		channel.queueBind("direct_queue_insert", "direct_exchange", "insert");
		channel.queueBind("direct_queue_update", "direct_exchange", "update");

		// 消息-direct_queue_insert
		String message_insert = "发布订阅模式-RouteKey-Insert:欢迎来到XXX！";
		/**
         * 消息发送
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicPublish("direct_exchange", "insert", null, message_insert.getBytes());

		// 消息-direct_queue_update
		String message_update = "发布订阅模式-RouteKey-Update:欢迎来到XXX！";
		channel.basicPublish("direct_exchange", "update", null, message_update.getBytes());

		// 关闭资源
		channel.close();
		connection.close();
	}
}

消费者RouteKey-Insert

创建direct_queue_insert队列的消费者cn.com.javakf.rabbitmq.toutekey.ConsumerInsert

public class ConsumerInsert {

	/***
	 * 订阅模式消息消费者-RouteKey-insert
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("direct_queue_insert", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者Insert-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("direct_queue_insert", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}
}

消费者-RouteKey-Update

创建direct_queue_update队列的消费者cn.com.javakf.rabbitmq.toutekey.ConsumerUpdate

public class ConsumerUpdate {

	/***
	 * 订阅模式消息消费者-RouteKey-update
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("direct_queue_update", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者Two-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("direct_queue_update", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}
}

测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达 按照需要接收的效果 。
在这里插入图片描述

在执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击 direct_exchange 的交换机，可以查看到如下的绑定：

小结

Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。

Topics通配符模式

模式说明

在这里插入图片描述
Topic类型与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如：item.insert

通配符规则：

#：匹配一个或多个词
*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.insert.abc 或者 item.insert
item.*：只能匹配item.insert

图解：
红色Queue：绑定的是usa.# ，因此凡是以 usa.开头的routing key 都会被匹配到
黄色Queue：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配

生产者

使用topic类型的Exchange，发送消息的routing key有3种： item.insert、item.update、item.delete：
创建cn.com.javakf.rabbitmq.topic.TopicProducer实现消息生产

public class TopicProducer {

	/***
	 * 订阅模式-Topic
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明交换机
         * 参数1：交换机名称
         * 参数2：交换机类型，fanout、topic、direct、headers
         */
		channel.exchangeDeclare("topic_exchange", BuiltinExchangeType.TOPIC);

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("topic_queue_1", true, false, false, null);
		channel.queueDeclare("topic_queue_2", true, false, false, null);

		// 队列绑定交换机
		channel.queueBind("topic_queue_1", "topic_exchange", "item.update");
		channel.queueBind("topic_queue_1", "topic_exchange", "item.delete");
		channel.queueBind("topic_queue_2", "topic_exchange", "item.*");

		// 消息-item.insert
		String message_insert = "发布订阅模式-Topic-item.insert:欢迎来到XXX！";
		/**
         * 消息发送
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
		channel.basicPublish("topic_exchange", "item.insert", null, message_insert.getBytes());

		// 消息-item.update
		String message_update = "发布订阅模式-Topic-item.update:欢迎来到XXX！";
		channel.basicPublish("topic_exchange", "item.update", null, message_update.getBytes());

		// 消息-item.delete
		String message_delete = "发布订阅模式-Topic-item.delete:欢迎来到XXX！";
		channel.basicPublish("topic_exchange", "item.update", null, message_delete.getBytes());

		// 关闭资源
		channel.close();
		connection.close();
	}
}

消费者one

上面配置了路由绑定过滤的规则，如下图：
在这里插入图片描述
创建cn.com.javakf.rabbitmq.topic.ConsumerOne实现对topic_queue_1队列数据的消费

public class ConsumerOne {

	/***
	 * 订阅模式消息消费者-Topic
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("topic_queue_1", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者Topic-Queue-1-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("topic_queue_1", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}
}

消费者Two

在这里插入图片描述
接收所有类型的消息：新增商品，更新商品和删除商品。
创建cn.com.javakf.rabbitmq.topic.ConsumerTwo实现消息消费

public class ConsumerTwo {

	/***
	 * 订阅模式消息消费者-Topic
	 * 
	 * @param args
	 */
	public static void main(String[] args) throws IOException, TimeoutException {
		// 创建链接对象
		Connection connection = ConnectionUtil.getConnection();

		// 创建频道
		Channel channel = connection.createChannel();

		/**
         * 声明队列
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
		channel.queueDeclare("topic_queue_2", true, false, false, null);

		// 创建消费者；并设置消息处理
		DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
					byte[] body) throws IOException {
				// 路由key
				System.out.println("路由key为：" + envelope.getRoutingKey());
				// 交换机
				System.out.println("交换机为：" + envelope.getExchange());
				// 消息id
				System.out.println("消息id为：" + envelope.getDeliveryTag());
				// 收到的消息
				System.out.println("消费者Topic-Queue-2-接收到的消息为：" + new String(body, "utf-8"));
			}
		};

		// 消息监听
		channel.basicConsume("topic_queue_2", true, defaultConsumer);

		// 关闭资源
		// channel.close();
		// connection.close();
	}
}

测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达 按照需要接收 的效果；并且这些routing key可以使用通配符。
在这里插入图片描述

在执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击 topic_exchange 的交换机，可以查看到如下的绑定：

小结

Topic主题模式可以实现 Publish/Subscribe发布与订阅模式和 Routing路由模式的功能；只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

模式总结

简单模式 HelloWorld
一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）
工作队列模式 Work Queue
一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）
发布订阅模式 Publish/subscribe
需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列
路由模式 Routing
需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
通配符模式 Topic
需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

代码托管：rabbitmq

ME_邱康

发布了160 篇原创文章 · 获赞 6 · 访问量 1万+

私信关注