项目地址(gitee): https://gitee.com/qinenqi/online
springboot整合rabbitmq
小编参考rabbitmq
整合进自己的cloud系统,在此对 孔明1号 博主进行感谢
online-project 作为生产者
online-coupon 作为消费者
- online-common在公共服务中引入依赖
<!-- rabbitMQ -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 在 online-project 、online-coupon服务的配置文件中 添加
# rabbitmq配置信息
# ip
spring.rabbitmq.host=127.0.0.1
# 端口
spring.rabbitmq.port=5672
# 用户名
spring.rabbitmq.username=guest
# 密码
spring.rabbitmq.password=guest
# 配置虚拟机
spring.rabbitmq.virtual-host=/
# 消息开启手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual
# confirm机制 开启消息确认机制 confirm 异步
spring.rabbitmq.publisher-confirm-type=correlated
# 之前的旧版本 开启消息确认机制的方式
# spring.rabbitmq.publisher-confirms=true
# return机制 开启return机制
spring.rabbitmq.publisher-returns=true
- 新建 RabbitmqConfig ,rabbitmq的配置类
import org.springframework.amqp.core.*;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
@SpringBootConfiguration
public class RabbitmqConfig {
/**
* 配置一个工作模型队列
* @return
*/
@Bean
public Queue queueWork1() {
return new Queue("queue_work");
}
/**
* 发布订阅模式
* 声明两个队列
* @return
*/
@Bean
public Queue queueFanout1() {
return new Queue("queue_fanout1");
}
@Bean
public Queue queueFanout2() {
return new Queue("queue_fanout2");
}
// 准备一个交换机
@Bean
public FanoutExchange exchangeFanout() {
return new FanoutExchange("exchange_fanout");
}
/**
* 将队列绑定到交换机上
* @return
*/
@Bean
public Binding bindingExchange1() {
Queue queue = queueFanout1();
return BindingBuilder.bind(queue).to(exchangeFanout());
}
@Bean
public Binding bindingExchange2() {
Queue queue = queueFanout2();
return BindingBuilder.bind(queue).to(exchangeFanout());
}
/**
* topic 模型
* @return
*/
@Bean
public Queue queueTopic1() {
return new Queue("queue_topic1");
}
@Bean
public Queue queueTopic2() {
return new Queue("queue_topic2");
}
@Bean
public TopicExchange exchangeTopic() {
return new TopicExchange("exchange_topic");
}
@Bean
public Binding bindingTopic1() {
Queue queue = queueTopic1();
return BindingBuilder.bind(queue).to(exchangeTopic()).with("topic.#");
}
@Bean
public Binding bindingTopic2() {
Queue queue = queueTopic2();
return BindingBuilder.bind(queue).to(exchangeTopic()).with("topic.*");
}
/**
* confirm机制
* 测试confirm 机制,专门创建了一个队列
* @return
*/
@Bean
public Queue queueConfirm() {
return new Queue("queue_confirm");
}
/**
* return机制
* @return
*/
@Bean
public Queue queueReturn() {
return new Queue("queue_return");
}
@Bean
public TopicExchange exchangeReturn() {
return new TopicExchange("exchange_return");
}
@Bean
public Binding bindingReturn() {
Queue queue = queueReturn();
return BindingBuilder.bind(queue).to(exchangeReturn()).with("return.*");
}
}
- 在 online-project 新建 RabbitmqController RabbitmqService 和 RabbitmqServiceImpl
import com.example.onlineproject.service.RabbitmqService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/rabbitmqController")
public class RabbitmqController {
@Autowired
private RabbitmqService rabbitmqService;
/**
* work模型
* @return
*/
@RequestMapping("/sendWork")
public Object sendWork() {
rabbitmqService.sendWork();
return "发送成功...";
}
/**
* 发布订阅模型
* @return
*/
@RequestMapping("/sendPublish")
public String sendPublish() {
rabbitmqService.sendPublish();
return "发送成功...";
}
/**
* topic模型
* @return
*/
@RequestMapping("/sendTopic")
public String sendTopic() {
rabbitmqService.sendTopic();
return "发送成功...";
}
/**
* confirm机制
* @return
*/
@RequestMapping("/sendConfirm")
public String sendConfirm() {
rabbitmqService.sendConfirm();
return "发送成功...";
}
/**
* return机制
* @return
*/
@RequestMapping("/sendReturn")
public String sendReturn() {
rabbitmqService.sendReturn();
return "发送成功...";
}
}
public interface RabbitmqService {
public void sendWork();
public void sendPublish();
public void sendTopic();
public void sendConfirm();
public void sendReturn();
}
import com.example.onlinecommon.entry.User;
import com.example.onlineproject.mapper.RabbitmqMapper;
import com.example.onlineproject.service.RabbitmqService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class RabbitmqServiceImpl implements RabbitmqService {
@Autowired
private RabbitmqMapper rabbitmqMapper;
@Autowired
private RabbitTemplate rabbitTemplate;
@Override
public void sendWork() {
for (int i = 0; i < 10; i++) {
rabbitTemplate.convertAndSend("queue_work", "测试work模型: " + i);
}
}
@Override
public void sendPublish() {
for (int i = 0; i < 5; i++) {
rabbitTemplate.convertAndSend("exchange_fanout", "", "测试发布订阅模型:" + i);
}
}
@Override
public void sendTopic() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km.topic", "测试发布订阅模型:" + i);
} else {
rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km", "测试发布订阅模型:" + i);
}
}
}
@Override
public void sendConfirm() {
rabbitTemplate.convertAndSend("queue_confirm", new User(1, "km", "km123"), new CorrelationData("" + System.currentTimeMillis()));
rabbitTemplate.setConfirmCallback(confirmCallback);
}
// 配置 confirm 机制
private final RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
/**
* @param correlationData 消息相关的数据,一般用于获取 唯一标识 id
* @param b true 消息确认成功,false 失败
* @param s 确认失败的原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean b, String s) {
if (b) {
System.out.println("confirm 消息确认成功..." + correlationData.getId());
} else {
System.out.println("confirm 消息确认失败..." + correlationData.getId() + " cause: " + s);
}
}
};
@Override
public void sendReturn() {
rabbitTemplate.setReturnCallback(returnCallback);
rabbitTemplate.convertAndSend("exchange_return", "return.km.km", "测试 return 机制");
}
// 配置 return 消息机制
private final RabbitTemplate.ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {
/**
* return 的回调方法(找不到路由才会触发)
* @param message 消息的相关信息
* @param i 错误状态码
* @param s 错误状态码对应的文本信息
* @param s1 交换机的名字
* @param s2 路由的key
*/
@Override
public void returnedMessage(Message message, int i, String s, String s1, String s2) {
System.out.println(message);
System.out.println(new String(message.getBody()));
System.out.println(i);
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
}
};
}
- online-coupon 新建监听类 WorkReceiveListener TopicReceiveListener ReturnReceiveListener PublishReceiveListener ConfirmReceiveListener
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
//import java.nio.channels.Channel;
// 2个消费者
@Component
public class WorkReceiveListener {
@RabbitListener(queues = "queue_work")
public void receiveMessage(String msg, Channel channel, Message message) {
// 只包含发送的消息
System.out.println("1接收到消息-coupon:" + msg);
// channel 通道信息
// message 附加的参数信息
}
@RabbitListener(queues = "queue_work")
public void receiveMessage2(Object obj, Channel channel, Message message) {
// 包含所有的信息
System.out.println("2接收到消息-coupon:" + obj);
}
}
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* topic模型 监听
*/
@Component
public class TopicReceiveListener {
@RabbitListener(queues = "queue_topic1")
public void receiveMsg1(String msg) {
System.out.println("消费者1接收到:" + msg);
}
@RabbitListener(queues = "queue_topic2")
public void receiveMsg2(String msg) {
System.out.println("消费者2接收到:" + msg);
}
}
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ReturnReceiveListener {
@RabbitListener(queues = "queue_return")
public void receiveMsg(String msg) {
System.out.println("接收的消息为:" + msg);
}
}
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class PublishReceiveListener {
@RabbitListener(queues = "queue_fanout1")
public void receiveMsg1(String msg) {
System.out.println("队列1接收到消息:" + msg);
}
@RabbitListener(queues = "queue_fanout2")
public void receiveMsg2(String msg) {
System.out.println("队列2接收到消息:" + msg);
}
}
import com.example.onlinecommon.entry.User;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ConfirmReceiveListener {
@RabbitListener(queues = "queue_confirm")
public void receiveMsg(User user) {
System.out.println("接收到的消息为:" + user);
}
}
- 请求接口(结合gateway 方式,请根据自己的情况进行修改)
http://127.0.0.1:88/api/project/rabbitmqController/sendWork (work模型)
http://127.0.0.1:88/api/project/rabbitmqController/sendPublish (发布订阅模型)
http://127.0.0.1:88/api/project/rabbitmqController/sendTopic (topic模型)
http://127.0.0.1:88/api/project/rabbitmqController/sendConfirm (confirm机制)
http://127.0.0.1:88/api/project/rabbitmqController/sendReturn (return机制)