基础工作模式
Mq = 超市 queue 里面的内容 相当于 货物
代码运行完成后信息就没了,被消费了
Ready : 0
代表消息已经被消费者消费过了
消费者消费消息:
- 加jar
<!-- mq-->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.6.0</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
- 编写代码
思路:先连接mq
创建channel
消费消息
package org.example.test;
import com.rabbitmq.client.*;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class MyTest {
@Test
public void aaa() throws IOException, TimeoutException {
//mq 建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setUsername("root");
connectionFactory.setPassword("root");
connectionFactory.setHost("192.168.44.34"); //mq主机
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("root");
//管道连接
Connection connection = connectionFactory.newConnection();
//创建管道
Channel channel = connection.createChannel();
//消费信息
Consumer consumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//获取队列里面的消息 body是字节
//->字符串
String s = new String(body);
System.out.println("mq中的消息:"+s);
}
};
channel.basicConsume("test",true,consumer);
}
}
生产者生产消息
package org.example.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;
/**
* @author xiaowu
*/
public class producer {
@Test
public void peoducter()throws IOException, TimeoutException {
//1.创建工厂
ConnectionFactory conn=new ConnectionFactory();
//2.设置参数
conn.setHost("192.168.44.34");
conn.setPort(5672);// 5672
conn.setUsername("root");//
conn.setPassword("root");
conn.setVirtualHost("root");
//3.建理连接
Connection connection = conn.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建 队列
channel.queueDeclare("hello",true,false,false,null);
//queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
* 对应的参数 queue 队列
* durable 是都为持久化
* exclusive
* 是否独占 一个生产者只有一个消费者
* 管理连接的时候删除队列
* autodelete 是都自动删除
* 参数 null
*
*/
//6.发送消息
/**
* basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
* 参数:
* 1. exchange:交换机名称。简单模式下交换机会使用默认的 ""
* 2. routingKey:路由名称
* 3. props:配置信息
* 4. body:发送消息数据
*/
String body="hello rabbit";
channel.basicPublish("","hello",null,body.getBytes());
//关闭资源
//channel.close();
// connection.close();
}
}
运行后
内容
在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争
的关系。
订阅模式类型☆
订阅模式示例图:
前面2个案例中,只有3个角色:
- P:生产者,也就是要发送消息的程序
- C:消费者:消息的接受者,会一直等待消息到来。
- queue:消息队列,图中红色部分
而在订阅模型中,多了一个exchange角色,而且过程略有变化:
生产者发消息给交换机,交换机将消息路由分发给队列,消费者监听队列接收信息
- P:生产者,也就是要发送消息的程序,但是不再发送到队列中,而是发给X(交换机)
- C:消费者,消息的接受者,会一直等待消息到来。
- Queue:消息队列,接收消息、缓存消息。
- Exchange:交换机,图中的X。一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于Exchange的类型。Exchange有常见以下3种类型:
- Fanout:广播,将消息交给所有绑定到交换机的队列
- Direct:定向,把消息交给符合指定routing key 的队列
- Topic:通配符,把消息交给符合routing pattern(路由模式) 的队列
Exchange(交换机)只负责转发消息,不具备存储消息的能力
,因此如果没有任何队列与Exchange绑定,或者没有符合路由规则的队列,那么消息会丢失!
例子:
消费者1 将日志的消息打印到控制台
消费者2 将日志的信息保存到数据库
创建一个交换机两个队列
bindings
发布订阅测试
都可消费接收
package org.example.Test;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author xiaowu
*/
public class producerEx {
@Test
public void peoducter()throws IOException, TimeoutException {
//1.创建工厂
ConnectionFactory conn=new ConnectionFactory();
//2.设置参数
conn.setHost("192.168.44.34");
conn.setPort(5672);// 5672
conn.setUsername("root");//
conn.setPassword("root");
conn.setVirtualHost("/root");
//3.建理连接
Connection connection = conn.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建 队列
channel.queueDeclare("hello",true,false,false,null);
//queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
* String queue队列名称对应的参数 queue 队列
* boolean durable 是否持久化
* boolean exclusive 是否独占
* boolean autoDelete 是否自动删除
* Map<String, Object> arguments 参数
* exclusive
* 是否独占 一个生产者只有一个消费者
* 管理连接的时候删除队列
* autodelete 是都自动删除
* 参数 null
*/
//6.发送消息
/**
* basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
* 参数:
* 1. exchange:交换机名称。简单模式下交换机会使用默认的 ""
* 2. routingKey:路由名称
* 3. props:配置信息
* 4. body:发送消息数据
*/
// for (int i = 0; i < 10; i++) {
// String body="hello rabbit";
// channel.basicPublish("","test22",null,body.getBytes());
// }
/**
* 发布订阅时
* 交换机-》fanout
* 队列-》两个队列
*/
//1 创建交换机
/**
* String exchange,BuiltinExchangeType type, boolean durable
*/
channel.exchangeDeclare("myex1", BuiltinExchangeType.FANOUT,false);
//2 创建队列
channel.queueDeclare("testqiu3",false,false,false,null);
channel.queueDeclare("testqiu4",false,false,false,null);
//3 交换机绑定队列String destination , String source , String routingkey
channel.queueBind("testqiu3","myex1","");
channel.queueBind("testqiu4","myex1","");
channel.basicPublish("myex1","",null,"xixixixix".getBytes());
//关闭资源
//channel.close();
// connection.close();
}
}
测试成功
4. Routing路由模式
4.1 模式说明
路由模式特点:
- 队列与交换机的绑定,不能是任意绑定了,而是要指定一个
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 的消息
创建交换机
4.2 代码
在编码上与 Publish/Subscribe发布与订阅模式
的区别是交换机的类型为:Direct,还有队列绑定交换机的时候需要指定routing key。
生产者
public class MyTestExdirect {
@Test
public void peoducter()throws IOException, TimeoutException {
//1.创建工厂
ConnectionFactory conn=new ConnectionFactory();
//2.设置参数
conn.setHost("192.168.44.34");
conn.setPort(5672);// 5672
conn.setUsername("root");//
conn.setPassword("root");
conn.setVirtualHost("/root");
//3.建理连接
Connection connection = conn.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建 队列
channel.queueDeclare("hello",true,false,false,null);
//queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
* String queue队列名称对应的参数 queue 队列
* boolean durable 是否持久化
* boolean exclusive 是否独占
* boolean autoDelete 是否自动删除
* Map<String, Object> arguments 参数
* exclusive
* 是否独占 一个生产者只有一个消费者
* 管理连接的时候删除队列
* autodelete 是都自动删除
* 参数 null
*/
//6.发送消息
/**
* basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
* 参数:
* 1. exchange:交换机名称。简单模式下交换机会使用默认的 ""
* 2. routingKey:路由名称
* 3. props:配置信息
* 4. body:发送消息数据
*/
// for (int i = 0; i < 10; i++) {
// String body="hello rabbit";
// channel.basicPublish("","test22",null,body.getBytes());
// }
/**
* 发布订阅时
* 交换机-》fanout
* 队列-》两个队列
*/
//1 创建交换机
/**
* String exchange,BuiltinExchangeType type, boolean durable
* 交换机为direct的时候 routingkey 是一个具体的值
*/
channel.exchangeDeclare("exchange_direct_test", BuiltinExchangeType.DIRECT,false);
//2 创建队列
channel.queueDeclare("exchange_direct_queue_1",false,false,false,null);
channel.queueDeclare("exchange_direct_queue_2",false,false,false,null);
//3 交换机绑定队列String destination , String source , String routingkey
channel.queueBind("exchange_direct_queue_1","exchange_direct_test","error");
channel.queueBind("exchange_direct_queue_2","exchange_direct_test","test");
channel.queueBind("exchange_direct_queue_2","exchange_direct_test","test2");
//String exchange, String routingKey, AMQP.BasicProperties props, byte[] body
channel.basicPublish("exchange_direct_test","error",null,"我就测试一下路由模式".getBytes());
//关闭资源
//channel.close();
// connection.close();
}
}
运行后生成
消费者1
public class Appchangedirect
{
public static void main( String[] args ) throws IOException, TimeoutException {
//mq 建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setUsername("root");
connectionFactory.setPassword("root");
connectionFactory.setHost("192.168.44.34"); //mq主机
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/root");
//管道连接
Connection connection = connectionFactory.newConnection();
//创建管道
Channel channel = connection.createChannel();
//消费信息
Consumer consumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//获取队列里面的消息 body是字节
//->字符串
String s = new String(body);
System.out.println("mq中的消息:"+s);
}
};
channel.basicConsume("exchange_direct_queue_1",true,consumer);
}
}
消费成功
总结:
Routing模式要求队列在绑定交换机时要指定routing key,消息会转发到符合routing key的队列。
5. Topics通配符模式(主题模式)
5.1. 模式说明
Topic
类型与Direct
相比,都是可以根据RoutingKey
把消息路由到不同的队列。只不过Topic
类型Exchange
可以让队列在绑定Routing key
的时候使用通配符
!
Routingkey
一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert
通配符规则:
#
:匹配一个或多个词
*
:匹配不多不少恰好1个词 test.* test.insert
举例:
item.#
:能够匹配item.insert.abc
或者 item.insert
item.*
:只能匹配item.insert
图解:
- 红色Queue:绑定的是
usa.#
,因此凡是以usa.
开头的routing key
都会被匹配到 - 黄色Queue:绑定的是
#.news
,因此凡是以.news
结尾的routing key
都会被匹配
5.2. 代码
所有的error级别的日志以及订单系统产生的日志全部让队列1接收
error
order.#
生产者
public class MyTestExdirect {
@Test
public void peoducter()throws IOException, TimeoutException {
//1.创建工厂
ConnectionFactory conn=new ConnectionFactory();
//2.设置参数
conn.setHost("192.168.44.34");
conn.setPort(5672);// 5672
conn.setUsername("root");//
conn.setPassword("root");
conn.setVirtualHost("/root");
//3.建理连接
Connection connection = conn.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建 队列
channel.queueDeclare("hello",true,false,false,null);
//queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
* String queue队列名称对应的参数 queue 队列
* boolean durable 是否持久化
* boolean exclusive 是否独占
* boolean autoDelete 是否自动删除
* Map<String, Object> arguments 参数
* exclusive
* 是否独占 一个生产者只有一个消费者
* 管理连接的时候删除队列
* autodelete 是都自动删除
* 参数 null
*/
//6.发送消息
/**
* basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
* 参数:
* 1. exchange:交换机名称。简单模式下交换机会使用默认的 ""
* 2. routingKey:路由名称
* 3. props:配置信息
* 4. body:发送消息数据
*/
// for (int i = 0; i < 10; i++) {
// String body="hello rabbit";
// channel.basicPublish("","test22",null,body.getBytes());
// }
/**
* 发布订阅时
* 交换机-》fanout
* 队列-》两个队列
*/
//1 创建交换机
/**
* String exchange,BuiltinExchangeType type, boolean durable
* 交换机为direct的时候 routingkey 是一个具体的值
*/
channel.exchangeDeclare("exchange_topic_test", BuiltinExchangeType.TOPIC,false);
//2 创建队列
channel.queueDeclare("exchange_topic_queue_1",false,false,false,null);
channel.queueDeclare("exchange_topic_queue_2",false,false,false,null);
//3 交换机绑定队列String destination , String source , String routingkey
channel.queueBind("exchange_topic_queue_1","exchange_topic_test","test.#");
channel.queueBind("exchange_topic_queue_2","exchange_topic_test","*.aaa");
channel.queueBind("exchange_topic_queue_2","exchange_topic_test","test.*");
//String exchange, String routingKey, AMQP.BasicProperties props, byte[] body
channel.basicPublish("exchange_topic_test","test.aaa",null,"我就测试一下TOPIC模式".getBytes());
//关闭资源
//channel.close();
// connection.close();
}
}
消费者
public class AppchangeTopicdirect
{
public static void main( String[] args ) throws IOException, TimeoutException {
//mq 建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setUsername("root");
connectionFactory.setPassword("root");
connectionFactory.setHost("192.168.44.34"); //mq主机
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/root");
//管道连接
Connection connection = connectionFactory.newConnection();
//创建管道
Channel channel = connection.createChannel();
//消费信息
Consumer consumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//获取队列里面的消息 body是字节
//->字符串
String s = new String(body);
System.out.println("mq中的消息:"+s);
}
};
channel.basicConsume("exchange_topic_queue_1",true,consumer);
}
}
消费成功
测试
总结
Topic主题模式可以实现 Publish/Subscribe发布与订阅模式
和 Routing路由模式
的功能;只是Topic在配置routing key 的时候可以使用通配符,显得更加灵活。
6. 模式总结
RabbitMQ工作模式:
1、简单模式 HelloWorld
一个生产者、一个消费者,不需要设置交换机(使用默认的交换机)
`2、工作队列模式 Work Queue
一个生产者、多个消费者(竞争关系),不需要设置交换机(使用默认的交换机)
3、发布订阅模式 Publish/subscribe
需要设置类型为fanout的交换机,并且交换机和队列进行绑定,当发送消息到交换机后,交换机会将消息发送到绑定的队列
4、路由模式 Routing
需要设置类型为direct的交换机,交换机和队列进行绑定,并且指定routing key,当发送消息到交换机后,交换机会根据routing key将消息发送到对应的队列
5、通配符模式 Topic
需要设置类型为topic的交换机,交换机和队列进行绑定,并且指定通配符方式的routing key,当发送消息到交换机后,交换机会根据routing key将消息发送到对应的队列
Spring Boot整合RabbitMQ
1. 简介
在Spring项目中,可以使用Spring-Rabbit去操作RabbitMQ
尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可,方便的使用RabbitTemplate发送消息,使用注解接收消息。
一般在开发过程中:
生产者工程:
- application.yml文件配置相关信息;
- 在生产者工程中编写配置类,用于创建交换机和队列,并进行绑定
- 注入RabbitTemplate对象,通过RabbitTemplate对象发送消息到交换机
消费者工程:
- application.yml文件配置相关信息
- 创建消息处理类,用于接收队列中的消息并进行处理
2.搭建生产者工程(适配类型)
1 添加依赖
修改pom.xml文件内容为如下:
<?xml version="1.0" encoding="UTF-8"?>
<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.yyl</groupId>
<artifactId>producer-springboot</artifactId>
<version>1.0-SNAPSHOT</version>
<!--1. 父工程依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.2</version>
</parent>
<dependencies>
<!--2. rabbitmq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
</dependencies>
</project>
启动类
@SpringBootApplication
public class MqApp
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
SpringApplication.run(MqApp.class);
}
}
2配置RabbitMQ
配置文件
创建application.yml,内容如下:
# 配置RabbitMQ的基本信息 ip 端口 username password..
spring:
rabbitmq:
username: root
password: root
host: 192.168.44.34
virtual-host: /root #必须以/开头
port: 5672
mq:
exchange:
name: test_exchange_topic
queue:
name1: test_topic_exchange_queue_1
name2: test_topic_exchange_queue_2
3 配置类
声明交换机
声明队列
交换机和对垒进行绑定
package com.example.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TopicMqConfig {
//这行代码使用@Value注解来注入一个名为mq.exchange.name的配置属性值。
// 这个值通常在配置文件(如application.properties或application.yml)中定义。
// 在这个例子中,EXCHANGENAME变量的值将被设置为配置文件中mq.exchange.name属性的值。
@Value("${mq.exchange.name}")
private String EXCHANGENAME;
@Value("${mq.queue.name1}")
private String QUEUENAME1;
@Value("${mq.queue.name2}")
private String QUEUENAME2;
//1 交换机
@Bean("ex1")
public Exchange getExchange(){
Exchange exchange = ExchangeBuilder.topicExchange(EXCHANGENAME).durable(false).build();
return exchange;
}
//2 队列
@Bean("queue1")
public Queue getQueue1(){
Queue queue = QueueBuilder.nonDurable(QUEUENAME1).build();
return queue;
}
@Bean("queue2")
public Queue getQueue2(){
Queue queue = QueueBuilder.nonDurable(QUEUENAME2).build();
return queue;
}
//3 交换机和队列进行绑定
@Bean("binding1")
public Binding bindQueueToExchange(@Qualifier("ex1")Exchange exchange,@Qualifier("queue1")Queue queue){
Binding binding = BindingBuilder.bind(queue).to(exchange).with("*.*").noargs();
return binding;
}
@Bean("binding2")
public Binding bindQueue2ToExchange(@Qualifier("ex1")Exchange exchange,@Qualifier("queue2")Queue queue){
Binding binding = BindingBuilder.bind(queue).to(exchange).with("test.#").noargs();
return binding;
}
}
4 生产者发布消息:
Starter组件里面封装的类rabbitTemplate
在test文件夹中添加Mytest测试类
package com.example;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
@SpringBootTest
public class MyTest {
@Value("${mq.exchange.name}")
private String EXCHANGENAME;
/**
* mq
*/
@Resource
private RabbitTemplate rabbitTemplate;
@Test
void sendMsg(){
rabbitTemplate.convertAndSend(EXCHANGENAME,"test.topic","我就是测试一下spring boot和mq的整合");
}
}
测试成功
5 消费者消费消息
消费者的服务application.yml和生产者是一样的
只需要监听队列(队列里面只要有消息就开始接收)
项目结构整理如下
监听的配置文件
spring:
rabbitmq:
username: root
password: root
host: 192.168.44.34
virtual-host: /root #????????????/????
port: 5672
#mq:
# exchange:
# name: test_exchange_topic
# queue:
# name1: test_topic_exchange_queue_1
# name2: test_topic_exchange_queue_2
server:
port: 8085
监听实现代码
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ConstumerMessage {
//监听队列
@RabbitListener(queues = "test_topic_exchange_queue_2")
public void aaa(Message message){
byte[] body = message.getBody();
String string = new String(body);
System.out.println("-------:"+string);
}
}
测试成功