RabbitMQ + SpringBoot整合
1. 整合springboot-rabbitmq
1.1 创建项目
1.1.1 导入rabbitmq依赖
这是springboot封装的rabbitmq依赖,非rabbitmq原装
org.springframework.boot
spring-boot-starter-amqp
1.1.2 配置application.yml
spring:
rabbitmq:
host: 192.168.64.140
username: admin
password: admin
2. rabbitmq-spring 不同模式的整合应用
2.1 简单模式
2.1.1 main主程序
package cn.tedu.m1;
import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Main {
@Autowired
private Producer p;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
@Bean
public Queue task_queue() {
/*
* 可用以下形式:
* new Queue("helloworld") - 持久,非排他,非自动删除
* new Queue("helloworld",false,false,false,null)
*/
return new Queue("helloworld",false);
}
//spring扫描创建完所有的实例,完成所有的依赖注入后,自动执行@PostConsutruct注解的方法
@PostConstruct
public void test(){
p.send();
}
}
2.1.2 生产者
- AmqpTemplate是rabbitmq客户端API的一个封装工具,提供了简便的方法来执行消息操作.
- AmqpTemplate由自动配置类自动创建
@Component
public class SimpleSender {
@Autowired
AmqpTemplate t;
public void send() {
// 这里向 helloworld 队列发送消息
t.convertAndSend("helloworld", "Hello world!! "+System.currentTimeMillis());
System.out.println("消息已发送");
}
}
2.1.3 消费者
- 通过@RabbitListener从指定的队列接收消息
- 使用@RebbitHandler注解的方法来处理消息
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "helloworld")
public class SimpleReceiver {
@RabbitHandler
public void receive(String msg) {
System.out.println("收到: "+msg);
}
}
- 另外一种形式(功能同上):
@Component
public class SimpleReceiver {
@RabbitListener(queues = "helloworld")
public void receive(String msg) {
System.out.println("收到: "+msg);
}
}
- @RabbitListener 注解中也可以直接定义队列:
@RabbitListener(queuesToDeclare = @Queue(name = "helloworld",durable = "false"))
2.1.4 测试
2.2 工作模式
2.2.1 main主程序
package cn.tedu.rabbitmqspringboot.m2;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import javax.annotation.PostConstruct;
@SpringBootApplication
public class Main {
@Autowired
private Producer p;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
@Bean
public Queue task_queue() {
//默认是持久队列,true,false,false
return new Queue("task_queue", true);
}
//spring扫描创建完所有的实例,完成所有的依赖注入后,自动执行@PostConsutruct注解的方法
@PostConstruct
public void test() {
/*new Thread(new Runnable() {
@Override
public void run() {
p.send();
}
}).start();*/
//lamda表达式 == Runnable匿名内部类
new Thread(() -> p.send()).start();
}
}
2.2.2 生产者
package cn.tedu.rabbitmqspringboot.m2;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Scanner;
@Component
public class Producer {
@Autowired
AmqpTemplate t;
public void send() {
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
t.convertAndSend("task_queue", s);
}
}
}
- spring boot封装的 rabbitmq api 中, 发送的消息默认是持久化消息.如果希望发送非持久化消息, 需要在发送消息时做以下设置:
使用 MessagePostProcessor 前置处理器参数
从消息中获取消息的属性对象
在属性中把 DeliveryMode 设置为非持久化
//如果需要设置消息为非持久化,可以取得消息的属性对象,修改它的deliveryMode属性
t.convertAndSend("task_queue", (Object) s, new MessagePostProcessor() {
@Override
public Message postProcessMessage(Message message) throws AmqpException {
MessageProperties props = message.getMessageProperties();
props.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
return message;
}
});
2.2.3 消费者
package cn.tedu.rabbitmqspringboot.m2;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class Consumer {
//每个@RabbitListener 都会注册成为一个消费者
@RabbitListener(queues = "task_queue")
public void receive1(String msg) {
System.out.println("消费者1收到: " + msg);
}
@RabbitListener(queues = "task_queue")
public void receive2(String msg) {
System.out.println("消费者2收到: " + msg);
}
}
2.2.4 测试
2.3 合理分发消息
2.3.1 ack模式
2.3.1.1 三种确认模式
在 spring boot 中提供了三种确认模式:
- NONE - 使用rabbitmq的自动确认
- AUTO - 使用rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
- MANUAL - 使用rabbitmq的手动确认, 且必须手动执行确认操作
默认的 AUTO 模式中, 处理消息的方法抛出异常, 则表示消息没有被正确处理, 该消息会被重新发送.
2.3.1.2 配置ack模式
spring:
rabbitmq:
listener:
simple:
# acknowledgeMode: NONE # rabbitmq的自动确认
acknowledgeMode: AUTO # rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
# acknowledgeMode: MANUAL # rabbitmq的手动确认, springboot不发送回执, 必须自己编码发送回执
2.3.1.3 配置ack模式
如果设置为 MANUAL 模式,必须手动执行确认操作
@RabbitListener(queues="task_queue")
public void receive1(String s, Channel c, @Header(name=AmqpHeaders.DELIVERY_TAG) long tag) throws Exception {
System.out.println("receiver1 - 收到: "+s);
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '.') {
Thread.sleep(1000);
}
}
// 手动发送确认回执
c.basicAck(tag, false);
}
2.3.2 抓取数量
工作模式中, 为了合理地分发数据, 需要将 qos 设置成 1, 每次只接收一条消息, 处理完成后才接收下一条消息.
配置application.yml
spring:
rabbitmq:
host: 192.168.64.140
username: admin
password: admin
listener:
simple:
prefetch: 1 #Qos=1,默认250
2.4 发布和订阅模式
2.4.1 主程序
package cn.tedu.rabbitmqspringboot.m3;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import javax.annotation.PostConstruct;
@SpringBootApplication
public class Main {
@Autowired
private Producer p;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
@Bean
public FanoutExchange logsExchange(){
return new FanoutExchange("logs", false, false);
}
//spring扫描创建完所有的实例,完成所有的依赖注入后,自动执行@PostConsutruct注解的方法
@PostConstruct
public void test() {
/*new Thread(new Runnable() {
@Override
public void run() {
p.send();
}
}).start();*/
//lamda表达式 == Runnable匿名内部类
new Thread(() -> p.send()).start();
}
}
2.4.2 生产者
package cn.tedu.rabbitmqspringboot.m3;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Scanner;
@Component
public class Producer {
@Autowired
AmqpTemplate t;
public void send() {
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
t.convertAndSend("logs", "", s);
}
}
}
2.4.3 消费者
package cn.tedu.rabbitmqspringboot.m3;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import javax.xml.ws.BindingType;
@Component
public class Consumer {
//每个@RabbitListener 都会注册成为一个消费者
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
value = @Queue(),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "logs", declare = "false")
))
public void receive1(String msg) {
System.out.println("消费者1收到: " + msg);
}
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
value = @Queue(),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "logs", declare = "false")
))
public void receive2(String msg) {
System.out.println("消费者2收到: " + msg);
}
}
2.4.4 测试
2.5 路由模式
2.5.1 主程序
package cn.tedu.rabbitmqspringboot.m4;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import javax.annotation.PostConstruct;
@SpringBootApplication
public class Main {
@Autowired
private Producer p;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
@Bean
public DirectExchange logsExchange(){
return new DirectExchange("direct_logs", false, false);
}
//spring扫描创建完所有的实例,完成所有的依赖注入后,自动执行@PostConsutruct注解的方法
@PostConstruct
public void test() {
/*new Thread(new Runnable() {
@Override
public void run() {
p.send();
}
}).start();*/
//lamda表达式 == Runnable匿名内部类
new Thread(() -> p.send()).start();
}
}
2.5.2 生产者
package cn.tedu.rabbitmqspringboot.m4;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Scanner;
@Component
public class Producer {
@Autowired
AmqpTemplate t;
public void send() {
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键: ");
String key = new Scanner(System.in).nextLine();
//默认发送持久消息
t.convertAndSend("direct_logs", key, s);
}
}
}
2.5.3 消费者
package cn.tedu.rabbitmqspringboot.m4;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class Consumer {
//每个@RabbitListener 都会注册成为一个消费者
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
value = @Queue(),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "direct_logs", declare = "false"),
key = {"error"}
))
public void receive1(String msg) {
System.out.println("消费者1收到: " + msg);
}
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
value = @Queue(),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "direct_logs", declare = "false"),
key = {"info","warning","error"}
))
public void receive2(String msg) {
System.out.println("消费者2收到: " + msg);
}
}
2.5.4 测试
2.6 主题模式
2.6.1 主程序
package cn.tedu.rabbitmqspringboot.m5;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import javax.annotation.PostConstruct;
import java.util.UUID;
@SpringBootApplication
public class Main {
@Autowired
private Producer p;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
//手动定义交换机
@Bean
public Queue rndQueue1(){
return new Queue(UUID.randomUUID().toString(), false, true, true);
}
@Bean
public Queue rndQueue2(){
return new Queue(UUID.randomUUID().toString(), false, true, true);
}
@Bean
public TopicExchange logsExchange(){
return new TopicExchange("topic_logs", false, false);
}
//spring扫描创建完所有的实例,完成所有的依赖注入后,自动执行@PostConsutruct注解的方法
@PostConstruct
public void test() {
/*new Thread(new Runnable() {
@Override
public void run() {
p.send();
}
}).start();*/
//lamda表达式 == Runnable匿名内部类
new Thread(() -> p.send()).start();
}
}
2.6.2 生产者
package cn.tedu.rabbitmqspringboot.m5;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Scanner;
@Component
public class Producer {
@Autowired
AmqpTemplate t;
public void send() {
while (true) {
System.out.println("输入消息: ");
String s = new Scanner(System.in).nextLine();
System.out.println("输入路由键: ");
String key = new Scanner(System.in).nextLine();
//默认发送持久消息
t.convertAndSend("topic_logs", key, s);
}
}
}
2.6.3 消费者
package cn.tedu.rabbitmqspringboot.m5;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class Consumer {
//每个@RabbitListener 都会注册成为一个消费者
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
//#{} - spring导航语言 spnl: 可以直接访问spring容器中的对象
//${} - Object导航语言 ognl
value = @Queue(name = "#{rndQueue1.name}",declare = "false"),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "topic_logs", declare = "false"),
key = {"*.orange.*"}
))
public void receive1(String msg) {
System.out.println("消费者1收到: " + msg);
}
@RabbitListener(bindings = @QueueBinding(
//不配置就是随机队列,非持久,独占,自动删除
value = @Queue(name = "#{rndQueue2.name}",declare = "false"),
//交换机,declare=false -- 不重复定义交换机
exchange = @Exchange(name = "topic_logs", declare = "false"),
key = {"*.*.error","lazy.#"}
))
public void receive2(String msg) {
System.out.println("消费者2收到: " + msg);
}
}
2.6.4 测试
